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;
}
/**
* Parse command line arguments
*/
bool iotjs_environment_parse_command_line_arguments(iotjs_environment_t* env,
int argc, char** argv) {
IOTJS_VALIDATED_STRUCT_METHOD(iotjs_environment_t, env);
// There must be at least two arguments.
if (argc < 2) {
fprintf(stderr,
"usage: iotjs <js> [<iotjs arguments>] [-- <app arguments>]\n");
return false;
}
// Parse IoT.js command line arguments.
int i = 2;
while (i < argc) {
if (!strcmp(argv[i], "--")) {
++i;
break;
}
if (!strcmp(argv[i], "--memstat")) {
_this->config.memstat = true;
} else if (!strcmp(argv[i], "--show-opcodes")) {
_this->config.show_opcode = true;
} else if (!strcmp(argv[i], "--start-debug-server")) {
_this->config.debugger = true;
} else {
fprintf(stderr, "unknown command line argument %s\n", argv[i]);
return false;
}
++i;
}
// Remaining arguments are for application.
_this->argc = 2;
size_t buffer_size = (_this->argc + argc - i) * sizeof(char*);
_this->argv = (char**)iotjs_buffer_allocate(buffer_size);
_this->argv[0] = argv[0];
_this->argv[1] = argv[1];
while (i < argc) {
_this->argv[_this->argc] = iotjs_buffer_allocate(strlen(argv[i]) + 1);
strcpy(_this->argv[_this->argc], argv[i]);
_this->argc++;
i++;
}
return true;
}
void OnAlloc(uv_handle_t* handle, size_t suggested_size, uv_buf_t* buf) {
if (suggested_size > IOTJS_MAX_READ_BUFFER_SIZE) {
suggested_size = IOTJS_MAX_READ_BUFFER_SIZE;
}
buf->base = iotjs_buffer_allocate(suggested_size);
buf->len = suggested_size;
}
iotjs_jargs_t iotjs_jargs_create(uint16_t capacity) {
iotjs_jargs_t jargs;
IOTJS_VALIDATED_STRUCT_CONSTRUCTOR(iotjs_jargs_t, &jargs);
_this->capacity = capacity;
_this->argc = 0;
if (capacity > 0) {
unsigned buffer_size = sizeof(iotjs_jval_t) * capacity;
_this->argv = (iotjs_jval_t*)iotjs_buffer_allocate(buffer_size);
} else {
return jargs_empty;
}
return jargs;
}
bool iotjs_i2c_read(iotjs_i2c_t* i2c) {
I2C_METHOD_HEADER(i2c);
uint8_t len = _this->buf_len;
_this->buf_data = iotjs_buffer_allocate(len);
IOTJS_ASSERT(len > 0);
if (iotbus_i2c_read(platform_data->i2c_context, (uint8_t*)_this->buf_data,
len) < 0) {
DLOG("%s: cannot read data", __func__);
return false;
}
return true;
}
static uint8_t spi_transfer_helper(jerry_value_t jtx_buf, iotjs_spi_t* spi) {
uint8_t result = kSpiOpTransferBuffer;
if (jerry_value_is_array(jtx_buf)) {
spi->buf_len = spi_get_array_data(&spi->tx_buf_data, jtx_buf);
result = kSpiOpTransferArray;
} else if (jerry_value_is_object(jtx_buf)) {
iotjs_bufferwrap_t* tx_buf = iotjs_bufferwrap_from_jbuffer(jtx_buf);
spi->tx_buf_data = tx_buf->buffer;
spi->buf_len = iotjs_bufferwrap_length(tx_buf);
}
IOTJS_ASSERT(spi->buf_len > 0);
spi->rx_buf_data = iotjs_buffer_allocate(spi->buf_len);
IOTJS_ASSERT(spi->tx_buf_data != NULL && spi->rx_buf_data != NULL);
return result;
}
static int iotjs_spi_get_array_data(char** buf, const iotjs_jval_t* jarray) {
iotjs_jval_t jlength =
iotjs_jval_get_property(jarray, IOTJS_MAGIC_STRING_LENGTH);
IOTJS_ASSERT(!iotjs_jval_is_undefined(&jlength));
size_t length = iotjs_jval_as_number(&jlength);
IOTJS_ASSERT((int)length >= 0);
*buf = iotjs_buffer_allocate(length);
for (size_t i = 0; i < length; i++) {
iotjs_jval_t jdata = iotjs_jval_get_property_by_index(jarray, i);
(*buf)[i] = iotjs_jval_as_number(&jdata);
iotjs_jval_destroy(&jdata);
}
iotjs_jval_destroy(&jlength);
return (int)length;
}
static int spi_get_array_data(char** buf, jerry_value_t jarray) {
jerry_value_t jlength =
iotjs_jval_get_property(jarray, IOTJS_MAGIC_STRING_LENGTH);
IOTJS_ASSERT(!jerry_value_is_undefined(jlength));
size_t length = iotjs_jval_as_number(jlength);
IOTJS_ASSERT((int)length >= 0);
*buf = iotjs_buffer_allocate(length);
for (size_t i = 0; i < length; i++) {
jerry_value_t jdata = iotjs_jval_get_property_by_index(jarray, i);
(*buf)[i] = iotjs_jval_as_number(jdata);
jerry_release_value(jdata);
}
jerry_release_value(jlength);
return (int)length;
}
void ReadWorker(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;
req_data->buf_data = iotjs_buffer_allocate(len);
IOTJS_ASSERT(!_this->i2c_master);
IOTJS_ASSERT(len > 0);
int ret = i2c_read(_this->i2c_master, &_this->config,
(uint8_t*)req_data->buf_data, len);
if (ret != 0) {
DDLOG("I2C ReadWorker : cannot read - %d", ret);
req_data->error = kI2cErrRead;
return;
}
req_data->error = kI2cErrOk;
}
iotjs_string_t iotjs_jval_as_string(const iotjs_jval_t* jval) {
const IOTJS_VALIDATED_STRUCT_METHOD(iotjs_jval_t, jval);
IOTJS_ASSERT(iotjs_jval_is_string(jval));
jerry_size_t size = jerry_get_string_size(_this->value);
if (size == 0)
return iotjs_string_create("");
char* buffer = iotjs_buffer_allocate(size + 1);
jerry_char_t* jerry_buffer = (jerry_char_t*)(buffer);
size_t check = jerry_string_to_char_buffer(_this->value, jerry_buffer, size);
IOTJS_ASSERT(check == size);
buffer[size] = '\0';
iotjs_string_t res = iotjs_string_create_with_buffer(buffer, size);
return res;
}
iotjs_bufferwrap_t* iotjs_bufferwrap_create(const iotjs_jval_t* jbuiltin,
size_t length) {
iotjs_bufferwrap_t* bufferwrap = IOTJS_ALLOC(iotjs_bufferwrap_t);
IOTJS_VALIDATED_STRUCT_CONSTRUCTOR(iotjs_bufferwrap_t, bufferwrap);
iotjs_jobjectwrap_initialize(&_this->jobjectwrap, jbuiltin,
&this_module_native_info);
if (length > 0) {
_this->length = length;
_this->buffer = iotjs_buffer_allocate(length);
IOTJS_ASSERT(_this->buffer != NULL);
} else {
_this->length = 0;
_this->buffer = NULL;
}
IOTJS_ASSERT(
bufferwrap ==
(iotjs_bufferwrap_t*)(iotjs_jval_get_object_native_handle(jbuiltin)));
return bufferwrap;
}
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);
}
