void iotjs_jhandler_initialize(iotjs_jhandler_t* jhandler,
const jerry_value_t jfunc,
const jerry_value_t jthis,
const jerry_value_t jargv[],
const uint16_t jargc) {
IOTJS_VALIDATED_STRUCT_CONSTRUCTOR(iotjs_jhandler_t, jhandler);
_this->jfunc = iotjs_jval_create_raw(jfunc);
_this->jthis = iotjs_jval_create_raw(jthis);
_this->jret = iotjs_jval_create_copied(iotjs_jval_get_undefined());
#ifdef NDEBUG
_this->jargv = (iotjs_jval_t*)jargv;
#else
if (jargc > 0) {
unsigned buffer_size = sizeof(iotjs_jval_t) * jargc;
_this->jargv = (iotjs_jval_t*)iotjs_buffer_allocate(buffer_size);
for (int i = 0; i < jargc; ++i) {
_this->jargv[i] = iotjs_jval_create_raw(jargv[i]);
}
} else {
_this->jargv = NULL;
}
_this->finished = false;
#endif
_this->jargc = jargc;
}
iotjs_jval_t iotjs_jval_get_property_by_index(const iotjs_jval_t* jarr,
uint32_t idx) {
const IOTJS_VALIDATED_STRUCT_METHOD(iotjs_jval_t, jarr);
IOTJS_ASSERT(iotjs_jval_is_object(jarr));
jerry_value_t res = jerry_get_property_by_index(_this->value, idx);
if (jerry_value_has_error_flag(res)) {
jerry_release_value(res);
return iotjs_jval_create_copied(iotjs_jval_get_undefined());
}
return iotjs_jval_create_raw(res);
}
static void iotjs_adc_after_work(uv_work_t* work_req, int status) {
iotjs_adc_reqwrap_t* req_wrap = iotjs_adc_reqwrap_from_request(work_req);
iotjs_adc_reqdata_t* req_data = iotjs_adc_reqwrap_data(req_wrap);
iotjs_jargs_t jargs = iotjs_jargs_create(2);
bool result = req_data->result;
if (status) {
iotjs_jval_t error = iotjs_jval_create_error("System error");
iotjs_jargs_append_jval(&jargs, &error);
iotjs_jval_destroy(&error);
} else {
switch (req_data->op) {
case kAdcOpOpen:
if (!result) {
iotjs_jargs_append_error(&jargs, "Failed to open ADC device");
} else {
iotjs_jargs_append_null(&jargs);
}
break;
case kAdcOpRead:
if (!result) {
iotjs_jargs_append_error(&jargs, "Cannot read from ADC device");
} else {
iotjs_jargs_append_null(&jargs);
iotjs_jargs_append_number(&jargs, req_data->value);
}
break;
case kAdcOpClose:
if (!result) {
iotjs_jargs_append_error(&jargs, "Cannot close ADC device");
} else {
iotjs_jargs_append_null(&jargs);
}
break;
default: {
IOTJS_ASSERT(!"Unreachable");
break;
}
}
}
const iotjs_jval_t* jcallback = iotjs_adc_reqwrap_jcallback(req_wrap);
iotjs_make_callback(jcallback, iotjs_jval_get_undefined(), &jargs);
iotjs_jargs_destroy(&jargs);
iotjs_adc_reqwrap_dispatched(req_wrap);
}
iotjs_jval_t iotjs_jval_get_property(const iotjs_jval_t* jobj,
const char* name) {
const IOTJS_VALIDATED_STRUCT_METHOD(iotjs_jval_t, jobj);
IOTJS_ASSERT(iotjs_jval_is_object(jobj));
jerry_value_t prop_name = jerry_create_string((const jerry_char_t*)(name));
jerry_value_t res = jerry_get_property(_this->value, prop_name);
jerry_release_value(prop_name);
if (jerry_value_has_error_flag(res)) {
jerry_release_value(res);
return iotjs_jval_create_copied(iotjs_jval_get_undefined());
}
return iotjs_jval_create_raw(res);
}
// Calls next tick callbacks registered via `process.nextTick()`.
bool iotjs_process_next_tick() {
const iotjs_jval_t* process = iotjs_module_get(MODULE_PROCESS);
iotjs_jval_t jon_next_tick =
iotjs_jval_get_property(process, IOTJS_MAGIC_STRING__ONNEXTTICK);
IOTJS_ASSERT(iotjs_jval_is_function(&jon_next_tick));
iotjs_jval_t jres =
iotjs_jhelper_call_ok(&jon_next_tick, iotjs_jval_get_undefined(),
iotjs_jargs_get_empty());
IOTJS_ASSERT(iotjs_jval_is_boolean(&jres));
bool ret = iotjs_jval_as_boolean(&jres);
iotjs_jval_destroy(&jres);
iotjs_jval_destroy(&jon_next_tick);
return ret;
}
iotjs_jval_t iotjs_bufferwrap_create_buffer(size_t len) {
iotjs_jval_t* jglobal = iotjs_jval_get_global_object();
iotjs_jval_t jbuffer =
iotjs_jval_get_property(jglobal, IOTJS_MAGIC_STRING_BUFFER);
IOTJS_ASSERT(iotjs_jval_is_function(&jbuffer));
iotjs_jargs_t jargs = iotjs_jargs_create(1);
iotjs_jargs_append_number(&jargs, len);
iotjs_jval_t jres =
iotjs_jhelper_call_ok(&jbuffer, iotjs_jval_get_undefined(), &jargs);
IOTJS_ASSERT(iotjs_jval_is_object(&jres));
iotjs_jargs_destroy(&jargs);
iotjs_jval_destroy(&jbuffer);
return jres;
}
static void iotjs_spi_after_work(uv_work_t* work_req, int status) {
iotjs_spi_reqwrap_t* req_wrap = iotjs_spi_reqwrap_from_request(work_req);
iotjs_spi_reqdata_t* req_data = iotjs_spi_reqwrap_data(req_wrap);
iotjs_spi_t* spi = iotjs_spi_instance_from_reqwrap(req_wrap);
iotjs_jargs_t jargs = iotjs_jargs_create(2);
bool result = req_data->result;
if (status) {
iotjs_jargs_append_error(&jargs, "System error");
} else {
switch (req_data->op) {
case kSpiOpOpen:
if (!result) {
iotjs_jargs_append_error(&jargs, "Failed to export SPI device");
} else {
iotjs_jargs_append_null(&jargs);
}
break;
case kSpiOpTransferArray:
case kSpiOpTransferBuffer:
if (!result) {
iotjs_jargs_append_error(&jargs, "Cannot transfer from SPI device");
} else {
iotjs_jargs_append_null(&jargs);
IOTJS_VALIDATED_STRUCT_METHOD(iotjs_spi_t, spi);
// Append read data
iotjs_jval_t result_data =
iotjs_jval_create_byte_array(_this->buf_len, _this->rx_buf_data);
iotjs_jargs_append_jval(&jargs, &result_data);
iotjs_jval_destroy(&result_data);
}
if (req_data->op == kSpiOpTransferArray)
iotjs_spi_release_buffer(spi);
break;
case kSpiOpClose:
if (!result) {
iotjs_jargs_append_error(&jargs, "Failed to unexport SPI device");
} else {
iotjs_jargs_append_null(&jargs);
}
break;
default: {
IOTJS_ASSERT(!"Unreachable");
break;
}
}
}
const iotjs_jval_t* jcallback = iotjs_spi_reqwrap_jcallback(req_wrap);
iotjs_make_callback(jcallback, iotjs_jval_get_undefined(), &jargs);
iotjs_jargs_destroy(&jargs);
iotjs_spi_reqwrap_dispatched(req_wrap);
}
static void iotjs_pwm_after_worker(uv_work_t* work_req, int status) {
iotjs_pwm_reqwrap_t* req_wrap = iotjs_pwm_reqwrap_from_request(work_req);
iotjs_pwm_reqdata_t* req_data = iotjs_pwm_reqwrap_data(req_wrap);
iotjs_jargs_t jargs = iotjs_jargs_create(1);
bool result = req_data->result;
if (status) {
iotjs_jval_t error = iotjs_jval_create_error("System error");
iotjs_jargs_append_jval(&jargs, &error);
iotjs_jval_destroy(&error);
} else {
switch (req_data->op) {
case kPwmOpOpen:
if (!result) {
iotjs_jargs_append_error(&jargs, "Failed to open PWM device");
} else {
iotjs_jargs_append_null(&jargs);
}
break;
case kPwmOpSetDutyCycle:
if (!result) {
iotjs_jargs_append_error(&jargs, "Failed to set duty-cycle");
} else {
iotjs_jargs_append_null(&jargs);
}
break;
case kPwmOpSetPeriod:
if (!result) {
iotjs_jargs_append_error(&jargs, "Failed to set period");
} else {
iotjs_jargs_append_null(&jargs);
}
break;
case kPwmOpSetEnable:
if (!result) {
iotjs_jargs_append_error(&jargs, "Failed to set enable");
} else {
iotjs_jargs_append_null(&jargs);
}
break;
case kPwmOpClose:
if (!result) {
iotjs_jargs_append_error(&jargs, "Cannot close PWM device");
} else {
iotjs_jargs_append_null(&jargs);
}
break;
default: {
IOTJS_ASSERT(!"Unreachable");
break;
}
}
}
const iotjs_jval_t* jcallback = iotjs_pwm_reqwrap_jcallback(req_wrap);
iotjs_make_callback(jcallback, iotjs_jval_get_undefined(), &jargs);
iotjs_jargs_destroy(&jargs);
iotjs_pwm_reqwrap_dispatched(req_wrap);
}
void iotjs_jhandler_return_undefined(iotjs_jhandler_t* jhandler) {
IOTJS_VALIDATED_STRUCT_METHOD(iotjs_jhandler_t, jhandler);
iotjs_jhandler_return_jval(jhandler, iotjs_jval_get_undefined());
}
void iotjs_jargs_append_undefined(iotjs_jargs_t* jargs) {
IOTJS_VALIDATED_STRUCT_METHOD(iotjs_jargs_t, jargs);
iotjs_jargs_append_jval(jargs, iotjs_jval_get_undefined());
}
void iotjs_jval_set_property_undefined(const iotjs_jval_t* jobj,
const char* name) {
const IOTJS_VALIDATED_STRUCT_METHOD(iotjs_jval_t, jobj);
iotjs_jval_set_property_jval(jobj, name, iotjs_jval_get_undefined());
}
