/**
* Destroy an instance of iotjs_environment_t.
*/
static void iotjs_environment_destroy(iotjs_environment_t* env) {
IOTJS_VALIDATED_STRUCT_DESTRUCTOR(iotjs_environment_t, env);
if (_this->argv) {
// release command line argument strings.
// _argv[0] and _argv[1] refer addresses in static memory space.
// Others refer addresses in heap space that is need to be deallocated.
int i;
for (i = 2; i < _this->argc; ++i) {
iotjs_buffer_release(_this->argv[i]);
}
iotjs_buffer_release((char*)_this->argv);
}
}
void OnRead(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) {
iotjs_tcpwrap_t* tcp_wrap = iotjs_tcpwrap_from_handle((uv_tcp_t*)handle);
// tcp handle
jerry_value_t jtcp = iotjs_tcpwrap_jobject(tcp_wrap);
// socket object
jerry_value_t jsocket =
iotjs_jval_get_property(jtcp, IOTJS_MAGIC_STRING_OWNER);
IOTJS_ASSERT(jerry_value_is_object(jsocket));
// onread callback
jerry_value_t jonread =
iotjs_jval_get_property(jtcp, IOTJS_MAGIC_STRING_ONREAD);
IOTJS_ASSERT(jerry_value_is_function(jonread));
iotjs_jargs_t jargs = iotjs_jargs_create(4);
iotjs_jargs_append_jval(&jargs, jsocket);
iotjs_jargs_append_number(&jargs, nread);
iotjs_jargs_append_bool(&jargs, false);
if (nread <= 0) {
if (buf->base != NULL) {
iotjs_buffer_release(buf->base);
}
if (nread < 0) {
if (nread == UV__EOF) {
iotjs_jargs_replace(&jargs, 2, jerry_create_boolean(true));
}
iotjs_make_callback(jonread, jerry_create_undefined(), &jargs);
}
} else {
jerry_value_t jbuffer = iotjs_bufferwrap_create_buffer((size_t)nread);
iotjs_bufferwrap_t* buffer_wrap = iotjs_bufferwrap_from_jbuffer(jbuffer);
iotjs_bufferwrap_copy(buffer_wrap, buf->base, (size_t)nread);
iotjs_jargs_append_jval(&jargs, jbuffer);
iotjs_make_callback(jonread, jerry_create_undefined(), &jargs);
jerry_release_value(jbuffer);
iotjs_buffer_release(buf->base);
}
iotjs_jargs_destroy(&jargs);
jerry_release_value(jonread);
jerry_release_value(jsocket);
}
void WriteWorker(uv_work_t* work_req) {
I2C_WORKER_INIT_TEMPLATE;
iotjs_i2c_t* i2c = iotjs_i2c_instance_from_reqwrap(req_wrap);
IOTJS_VALIDATED_STRUCT_METHOD(iotjs_i2c_t, i2c);
uint8_t len = req_data->buf_len;
uint8_t* data = (uint8_t*)req_data->buf_data;
IOTJS_ASSERT(!_this->i2c_master);
IOTJS_ASSERT(len > 0);
int ret = i2c_write(_this->i2c_master, &_this->config, data, len);
if (ret < 0) {
DDLOG("I2C WriteWorker : cannot write - %d", ret);
req_data->error = kI2cErrWrite;
} else {
req_data->error = kI2cErrOk;
}
if (req_data->buf_data != NULL) {
iotjs_buffer_release(req_data->buf_data);
}
req_data->error = kI2cErrOk;
}
static void iotjs_bufferwrap_destroy(iotjs_bufferwrap_t* bufferwrap) {
IOTJS_VALIDATED_STRUCT_DESTRUCTOR(iotjs_bufferwrap_t, bufferwrap);
if (_this->buffer != NULL) {
iotjs_buffer_release(_this->buffer);
}
iotjs_jobjectwrap_destroy(&_this->jobjectwrap);
IOTJS_RELEASE(bufferwrap);
}
void iotjs_jargs_destroy(iotjs_jargs_t* jargs) {
IOTJS_VALIDATED_STRUCT_DESTRUCTOR(iotjs_jargs_t, jargs);
IOTJS_ASSERT(_this->argv == NULL || _this->argc > 0);
IOTJS_ASSERT(_this->argc <= _this->capacity);
if (_this->capacity > 0) {
for (unsigned i = 0; i < _this->argc; ++i) {
iotjs_jval_destroy(&_this->argv[i]);
}
iotjs_buffer_release((char*)_this->argv);
} else {
IOTJS_ASSERT(_this->argv == NULL);
}
}
void iotjs_jhandler_destroy(iotjs_jhandler_t* jhandler) {
IOTJS_VALIDATED_STRUCT_DESTRUCTOR(iotjs_jhandler_t, jhandler);
iotjs_jval_destroy_norelease(&_this->jfunc);
iotjs_jval_destroy_norelease(&_this->jthis);
iotjs_jval_destroy_norelease(&_this->jret);
#ifndef NDEBUG
if (_this->jargc > 0) {
for (int i = 0; i < _this->jargc; ++i) {
iotjs_jval_destroy_norelease(&_this->jargv[i]);
}
iotjs_buffer_release((char*)(_this->jargv));
} else {
IOTJS_ASSERT(_this->jargv == NULL);
}
#endif
}
bool iotjs_i2c_write(iotjs_i2c_t* i2c) {
I2C_METHOD_HEADER(i2c);
uint8_t len = _this->buf_len;
IOTJS_ASSERT(len > 0);
uint8_t* data = (uint8_t*)_this->buf_data;
int ret = iotbus_i2c_write(platform_data->i2c_context, data, len);
if (_this->buf_data != NULL) {
iotjs_buffer_release(_this->buf_data);
}
if (ret < 0) {
DLOG("%s: cannot write data", __func__);
return false;
}
return true;
}
iotjs_jval_t iotjs_jhelper_call(const iotjs_jval_t* jfunc,
const iotjs_jval_t* jthis,
const iotjs_jargs_t* jargs, bool* throws) {
IOTJS_ASSERT(iotjs_jval_is_object(jfunc));
jerry_value_t* jargv_ = NULL;
jerry_length_t jargc_ = iotjs_jargs_length(jargs);
#ifdef NDEBUG
jargv_ = (jerry_value_t*)jargs->unsafe.argv;
#else
if (jargc_ > 0) {
unsigned buffer_size = sizeof(iotjs_jval_t) * jargc_;
jargv_ = (jerry_value_t*)iotjs_buffer_allocate(buffer_size);
for (unsigned i = 0; i < jargc_; ++i) {
jargv_[i] = iotjs_jval_as_raw(iotjs_jargs_get(jargs, i));
}
}
#endif
jerry_value_t jfunc_ = iotjs_jval_as_raw(jfunc);
jerry_value_t jthis_ = iotjs_jval_as_raw(jthis);
jerry_value_t res = jerry_call_function(jfunc_, jthis_, jargv_, jargc_);
#ifndef NDEBUG
if (jargv_) {
iotjs_buffer_release((char*)jargv_);
}
#endif
*throws = jerry_value_has_error_flag(res);
jerry_value_clear_error_flag(&res);
return iotjs_jval_create_raw(res);
}
static void iotjs_spi_release_buffer(iotjs_spi_t* spi) {
IOTJS_VALIDATED_STRUCT_METHOD(iotjs_spi_t, spi);
iotjs_buffer_release(_this->tx_buf_data);
iotjs_buffer_release(_this->rx_buf_data);
}
