// Call any property of ClientRequest._Incoming
bool iotjs_https_jcallback(iotjs_https_t* https_data, const char* property,
const iotjs_jargs_t* jarg, bool resultvalue) {
iotjs_jval_t* jthis = iotjs_https_jthis_from_https(https_data);
bool retval = true;
if (iotjs_jval_is_null(jthis))
return retval;
iotjs_jval_t jincoming =
iotjs_jval_get_property(jthis, IOTJS_MAGIC_STRING__INCOMING);
iotjs_jval_t cb = iotjs_jval_get_property(&jincoming, property);
IOTJS_ASSERT(iotjs_jval_is_function(&cb));
if (!resultvalue) {
iotjs_make_callback(&cb, &jincoming, jarg);
} else {
iotjs_jval_t result =
iotjs_make_callback_with_result(&cb, &jincoming, jarg);
retval = iotjs_jval_as_boolean(&result);
iotjs_jval_destroy(&result);
}
iotjs_jval_destroy(&jincoming);
iotjs_jval_destroy(&cb);
return retval;
}
static void iotjs_pwm_set_configuration(const iotjs_jval_t* jconfiguration,
iotjs_pwm_t* pwm) {
IOTJS_VALIDATED_STRUCT_METHOD(iotjs_pwm_t, pwm);
iotjs_jval_t jpin =
iotjs_jval_get_property(jconfiguration, IOTJS_MAGIC_STRING_PIN);
_this->pin = iotjs_jval_as_number(&jpin);
#if defined(__linux__)
iotjs_jval_t jchip =
iotjs_jval_get_property(jconfiguration, IOTJS_MAGIC_STRING_CHIP);
_this->chip = iotjs_jval_as_number(&jchip);
iotjs_jval_destroy(&jchip);
#endif
iotjs_jval_t jperiod =
iotjs_jval_get_property(jconfiguration, IOTJS_MAGIC_STRING_PERIOD);
if (iotjs_jval_is_number(&jperiod))
_this->period = iotjs_jval_as_number(&jperiod);
iotjs_jval_t jduty_cycle =
iotjs_jval_get_property(jconfiguration, IOTJS_MAGIC_STRING_DUTYCYCLE);
if (iotjs_jval_is_number(&jduty_cycle))
_this->duty_cycle = iotjs_jval_as_number(&jduty_cycle);
iotjs_jval_destroy(&jpin);
iotjs_jval_destroy(&jperiod);
iotjs_jval_destroy(&jduty_cycle);
}
// A client socket wants to connect to this server.
// Parameters:
// * uv_stream_t* handle - server handle
// * int status - status code
static void OnConnection(uv_stream_t* handle, int status) {
// Server tcp wrapper.
iotjs_tcpwrap_t* tcp_wrap = iotjs_tcpwrap_from_handle((uv_tcp_t*)handle);
// Tcp object
jerry_value_t jtcp = iotjs_tcpwrap_jobject(tcp_wrap);
// `onconnection` callback.
jerry_value_t jonconnection =
iotjs_jval_get_property(jtcp, IOTJS_MAGIC_STRING_ONCONNECTION);
IOTJS_ASSERT(jerry_value_is_function(jonconnection));
// The callback takes two parameter
// [0] status
// [1] client tcp object
iotjs_jargs_t args = iotjs_jargs_create(2);
iotjs_jargs_append_number(&args, status);
if (status == 0) {
// Create client socket handle wrapper.
jerry_value_t jcreate_tcp =
iotjs_jval_get_property(jtcp, IOTJS_MAGIC_STRING_CREATETCP);
IOTJS_ASSERT(jerry_value_is_function(jcreate_tcp));
jerry_value_t jclient_tcp =
iotjs_jhelper_call_ok(jcreate_tcp, jerry_create_undefined(),
iotjs_jargs_get_empty());
IOTJS_ASSERT(jerry_value_is_object(jclient_tcp));
iotjs_tcpwrap_t* tcp_wrap_client =
(iotjs_tcpwrap_t*)(iotjs_jval_get_object_native_handle(jclient_tcp));
uv_stream_t* client_handle =
(uv_stream_t*)(iotjs_tcpwrap_tcp_handle(tcp_wrap_client));
int err = uv_accept(handle, client_handle);
if (err) {
iotjs_jargs_destroy(&args);
return;
}
iotjs_jargs_append_jval(&args, jclient_tcp);
jerry_release_value(jcreate_tcp);
jerry_release_value(jclient_tcp);
}
iotjs_make_callback(jonconnection, jtcp, &args);
jerry_release_value(jonconnection);
iotjs_jargs_destroy(&args);
}
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);
}
jerry_value_t MakeStatObject(uv_stat_t* statbuf) {
const jerry_value_t fs = iotjs_module_get("fs");
jerry_value_t stat_prototype =
iotjs_jval_get_property(fs, IOTJS_MAGIC_STRING_STATS);
IOTJS_ASSERT(jerry_value_is_object(stat_prototype));
jerry_value_t jstat = jerry_create_object();
iotjs_jval_set_prototype(jstat, stat_prototype);
jerry_release_value(stat_prototype);
#define X(statobj, name) \
iotjs_jval_set_property_number(statobj, #name, statbuf->st_##name);
X(jstat, dev)
X(jstat, mode)
X(jstat, nlink)
X(jstat, uid)
X(jstat, gid)
X(jstat, rdev)
X(jstat, blksize)
X(jstat, ino)
X(jstat, size)
X(jstat, blocks)
#undef X
return jstat;
}
static void iotjs_adc_set_configuration(iotjs_adc_t* adc,
const iotjs_jval_t* jconfiguration) {
#if defined(__linux__)
IOTJS_VALIDATED_STRUCT_METHOD(iotjs_adc_t, adc);
iotjs_jval_t jdevice =
iotjs_jval_get_property(jconfiguration, IOTJS_MAGIC_STRING_DEVICE);
_this->device = iotjs_jval_as_string(&jdevice);
iotjs_jval_destroy(&jdevice);
#elif defined(__NUTTX__)
IOTJS_VALIDATED_STRUCT_METHOD(iotjs_adc_t, adc);
iotjs_jval_t jpin =
iotjs_jval_get_property(jconfiguration, IOTJS_MAGIC_STRING_PIN);
_this->pin = iotjs_jval_as_number(&jpin);
iotjs_jval_destroy(&jpin);
#endif
}
static bool bridge_native_call(const char* module_name, const char* func_name,
const char* message,
iotjs_string_t* output_str) {
bool result = false;
jerry_value_t jmodule = iotjs_module_get(module_name);
jerry_value_t jfunc = iotjs_jval_get_property(jmodule, func_name);
if (jerry_value_is_function(jfunc) == false) {
return result;
}
jerry_value_t jval = jerry_create_string((const jerry_char_t*)message);
jerry_value_t jres =
iotjs_invoke_callback_with_result(jfunc, jmodule, &jval, 1);
if (jerry_value_is_string(jres)) {
IOTJS_ASSERT(output_str != NULL);
*output_str = iotjs_jval_as_string(jres);
result = true;
}
jerry_release_value(jfunc);
jerry_release_value(jres);
jerry_release_value(jval);
return result;
}
iotjs_bufferwrap_t* iotjs_bufferwrap_from_jbuffer(const iotjs_jval_t* jbuffer) {
IOTJS_ASSERT(iotjs_jval_is_object(jbuffer));
iotjs_jval_t jbuiltin =
iotjs_jval_get_property(jbuffer, IOTJS_MAGIC_STRING__BUILTIN);
iotjs_bufferwrap_t* buffer = iotjs_bufferwrap_from_jbuiltin(&jbuiltin);
iotjs_jval_destroy(&jbuiltin);
return buffer;
}
static jerry_value_t StatsIsTypeOf(jerry_value_t stats, int type) {
jerry_value_t mode = iotjs_jval_get_property(stats, IOTJS_MAGIC_STRING_MODE);
int mode_number = (int)iotjs_jval_as_number(mode);
jerry_release_value(mode);
return jerry_create_boolean((mode_number & S_IFMT) == type);
}
static void gpio_emit_change_event(iotjs_gpio_t* gpio) {
IOTJS_VALIDATED_STRUCT_METHOD(iotjs_gpio_t, gpio);
jerry_value_t jgpio = _this->jobject;
jerry_value_t jonChange = iotjs_jval_get_property(jgpio, "onChange");
IOTJS_ASSERT(jerry_value_is_function(jonChange));
iotjs_jhelper_call_ok(jonChange, jgpio, iotjs_jargs_get_empty());
jerry_release_value(jonChange);
}
size_t iotjs_bufferwrap_length(iotjs_bufferwrap_t* bufferwrap) {
IOTJS_VALIDATED_STRUCT_METHOD(iotjs_bufferwrap_t, bufferwrap);
#ifndef NDEBUG
iotjs_jval_t jbuf = iotjs_bufferwrap_jbuffer(bufferwrap);
iotjs_jval_t jlength =
iotjs_jval_get_property(&jbuf, IOTJS_MAGIC_STRING_LENGTH);
size_t length = iotjs_jval_as_number(&jlength);
IOTJS_ASSERT(length == _this->length);
iotjs_jval_destroy(&jbuf);
iotjs_jval_destroy(&jlength);
#endif
return _this->length;
}
// Socket close result handler.
void AfterClose(uv_handle_t* handle) {
iotjs_handlewrap_t* wrap = iotjs_handlewrap_from_handle(handle);
// tcp object.
jerry_value_t jtcp = iotjs_handlewrap_jobject(wrap);
// callback function.
jerry_value_t jcallback =
iotjs_jval_get_property(jtcp, IOTJS_MAGIC_STRING_ONCLOSE);
if (jerry_value_is_function(jcallback)) {
iotjs_make_callback(jcallback, jerry_create_undefined(),
iotjs_jargs_get_empty());
}
jerry_release_value(jcallback);
}
void iotjs_tizen_app_control_cb(app_control_h app_control, void* user_data) {
DDDLOG("%s", __func__);
iotjs_environment_t* env = iotjs_environment_get();
if (env->state != kRunningMain && env->state != kRunningLoop) {
return;
}
const char* event_emitter_name = IOTJS_MAGIC_STRING_TIZEN;
const char* event_name = IOTJS_MAGIC_STRING_APP_CONTROL;
jerry_value_t tizen = iotjs_module_get(event_emitter_name);
jerry_value_t fn = iotjs_jval_get_property(tizen, IOTJS_MAGIC_STRING_EMIT);
if (jerry_value_is_function(fn) == false) {
DDDLOG("tizen module is not loaded");
goto exit;
}
// parse app control
char* json = NULL;
bundle* b = NULL;
app_control_export_as_bundle(app_control, &b);
if (BUNDLE_ERROR_NONE != bundle_to_json(b, &json)) {
DDLOG("bundle_to_json failed");
bundle_free(b);
return;
}
DDDLOG("JSON: %s", json);
// call emit
jerry_value_t jargv[2] = { jerry_create_string(
(const jerry_char_t*)event_name),
jerry_create_string((const jerry_char_t*)json) };
iotjs_invoke_callback(fn, tizen, jargv, 2);
jerry_release_value(jargv[0]);
jerry_release_value(jargv[1]);
free(json);
bundle_free(b);
exit:
jerry_release_value(fn);
}
static void iotjs_spi_set_configuration(iotjs_spi_t* spi,
const iotjs_jval_t* joptions) {
IOTJS_VALIDATED_STRUCT_METHOD(iotjs_spi_t, spi);
#if defined(__linux__)
iotjs_jval_t jdevice =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_DEVICE);
_this->device = iotjs_jval_as_string(&jdevice);
iotjs_jval_destroy(&jdevice);
#elif defined(__NUTTX__) || defined(__TIZENRT__)
iotjs_jval_t jbus = iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_BUS);
_this->bus = iotjs_jval_as_number(&jbus);
iotjs_jval_destroy(&jbus);
#endif
iotjs_jval_t jmode =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_MODE);
_this->mode = (SpiMode)iotjs_jval_as_number(&jmode);
iotjs_jval_destroy(&jmode);
iotjs_jval_t jchip_select =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_CHIPSELECT);
_this->chip_select = (SpiChipSelect)iotjs_jval_as_number(&jchip_select);
iotjs_jval_destroy(&jchip_select);
iotjs_jval_t jmax_speed =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_MAXSPEED);
_this->max_speed = iotjs_jval_as_number(&jmax_speed);
iotjs_jval_destroy(&jmax_speed);
iotjs_jval_t jbits_per_word =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_BITSPERWORD);
_this->bits_per_word = (SpiOrder)iotjs_jval_as_number(&jbits_per_word);
iotjs_jval_destroy(&jbits_per_word);
iotjs_jval_t jbit_order =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_BITORDER);
_this->bit_order = (SpiOrder)iotjs_jval_as_number(&jbit_order);
iotjs_jval_destroy(&jbit_order);
iotjs_jval_t jloopback =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_LOOPBACK);
_this->loopback = iotjs_jval_as_boolean(&jloopback);
iotjs_jval_destroy(&jloopback);
}
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;
}
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;
}
// 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;
}
void iotjs_process_emit_exit(int code) {
const iotjs_jval_t* process = iotjs_module_get(MODULE_PROCESS);
iotjs_jval_t jexit =
iotjs_jval_get_property(process, IOTJS_MAGIC_STRING_EMITEXIT);
IOTJS_ASSERT(iotjs_jval_is_function(&jexit));
iotjs_jargs_t jargs = iotjs_jargs_create(1);
iotjs_jargs_append_number(&jargs, code);
bool throws;
iotjs_jval_t jres = iotjs_jhelper_call(&jexit, process, &jargs, &throws);
iotjs_jargs_destroy(&jargs);
iotjs_jval_destroy(&jres);
iotjs_jval_destroy(&jexit);
if (throws) {
exit(2);
}
}
void iotjs_uncaught_exception(const iotjs_jval_t* jexception) {
const iotjs_jval_t* process = iotjs_module_get(MODULE_PROCESS);
iotjs_jval_t jonuncaughtexception =
iotjs_jval_get_property(process, IOTJS_MAGIC_STRING__ONUNCAUGHTEXCEPTION);
IOTJS_ASSERT(iotjs_jval_is_function(&jonuncaughtexception));
iotjs_jargs_t args = iotjs_jargs_create(1);
iotjs_jargs_append_jval(&args, jexception);
bool throws;
iotjs_jval_t jres =
iotjs_jhelper_call(&jonuncaughtexception, process, &args, &throws);
iotjs_jargs_destroy(&args);
iotjs_jval_destroy(&jres);
iotjs_jval_destroy(&jonuncaughtexception);
if (throws) {
exit(2);
}
}
static jerry_value_t gpio_set_configuration(iotjs_gpio_t* gpio,
jerry_value_t jconfigurable) {
jerry_value_t jpin =
iotjs_jval_get_property(jconfigurable, IOTJS_MAGIC_STRING_PIN);
gpio->pin = iotjs_jval_as_number(jpin);
jerry_release_value(jpin);
// Direction
jerry_value_t jdirection =
iotjs_jval_get_property(jconfigurable, IOTJS_MAGIC_STRING_DIRECTION);
if (jerry_value_is_undefined(jdirection)) {
gpio->direction = kGpioDirectionOut;
} else {
if (jerry_value_is_number(jdirection)) {
gpio->direction = (GpioDirection)iotjs_jval_as_number(jdirection);
} else {
gpio->direction = __kGpioDirectionMax;
}
if (gpio->direction >= __kGpioDirectionMax) {
return JS_CREATE_ERROR(
TYPE, "Bad arguments - gpio.direction should be DIRECTION.IN or OUT");
}
}
jerry_release_value(jdirection);
// Mode
jerry_value_t jmode =
iotjs_jval_get_property(jconfigurable, IOTJS_MAGIC_STRING_MODE);
if (jerry_value_is_undefined(jmode)) {
gpio->mode = kGpioModeNone;
} else {
if (jerry_value_is_number(jmode)) {
gpio->mode = (GpioMode)iotjs_jval_as_number(jmode);
} else {
gpio->mode = __kGpioModeMax;
}
if (gpio->mode >= __kGpioModeMax) {
return JS_CREATE_ERROR(TYPE,
"Bad arguments - gpio.mode should be MODE.NONE, "
"PULLUP, PULLDOWN, FLOAT, PUSHPULL or OPENDRAIN");
} else if (gpio->direction == kGpioDirectionIn &&
gpio->mode != kGpioModeNone && gpio->mode != kGpioModePullup &&
gpio->mode != kGpioModePulldown) {
return JS_CREATE_ERROR(TYPE,
"Bad arguments - DIRECTION.IN only supports "
"MODE.NONE, PULLUP and PULLDOWN");
} else if (gpio->direction == kGpioDirectionOut &&
gpio->mode != kGpioModeNone && gpio->mode != kGpioModeFloat &&
gpio->mode != kGpioModePushpull &&
gpio->mode != kGpioModeOpendrain) {
return JS_CREATE_ERROR(TYPE,
"Bad arguments - DIRECTION.OUT only supports "
"MODE.NONE, FLOAT, PUSHPULL and OPENDRAIN");
}
}
jerry_release_value(jmode);
// Edge
jerry_value_t jedge =
iotjs_jval_get_property(jconfigurable, IOTJS_MAGIC_STRING_EDGE);
if (jerry_value_is_undefined(jedge)) {
gpio->edge = kGpioEdgeNone;
} else {
if (jerry_value_is_number(jedge)) {
gpio->edge = (GpioEdge)iotjs_jval_as_number(jedge);
} else {
gpio->edge = __kGpioEdgeMax;
}
if (gpio->edge >= __kGpioEdgeMax) {
return JS_CREATE_ERROR(TYPE,
"Bad arguments - gpio.edge should be EDGE.NONE, "
"RISING, FALLING or BOTH");
}
}
jerry_release_value(jedge);
return jerry_create_undefined();
}
iotjs_jval_t iotjs_bufferwrap_jbuffer(iotjs_bufferwrap_t* bufferwrap) {
IOTJS_VALIDATABLE_STRUCT_METHOD_VALIDATE(iotjs_bufferwrap_t, bufferwrap);
iotjs_jval_t* jbuiltin = iotjs_bufferwrap_jbuiltin(bufferwrap);
return iotjs_jval_get_property(jbuiltin, IOTJS_MAGIC_STRING__BUFFER);
}
/* Default configuration:
*{
* mode: spi.MODE[0],
* chipSelect: spi.CHIPSELECT.NONE,
* maxSpeed: 500000,
* bitsPerWord: 8,
* bitOrder: spi.BITORDER.MSB,
* loopback: false
* }
*/
static jerry_value_t spi_set_configuration(iotjs_spi_t* spi,
jerry_value_t joptions) {
jerry_value_t jmode =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_MODE);
if (jerry_value_is_undefined(jmode)) {
spi->mode = kSpiMode_0;
} else {
if (jerry_value_is_number(jmode)) {
spi->mode = (SpiMode)iotjs_jval_as_number(jmode);
} else {
spi->mode = __kSpiModeMax;
}
if (spi->mode >= __kSpiModeMax) {
return JS_CREATE_ERROR(
TYPE, "Bad arguments - mode should be MODE[0], [1], [2] or [3]");
}
}
jerry_release_value(jmode);
jerry_value_t jchip_select =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_CHIPSELECT);
if (jerry_value_is_undefined(jchip_select)) {
spi->chip_select = kSpiCsNone;
} else {
if (jerry_value_is_number(jchip_select)) {
spi->chip_select = (SpiChipSelect)iotjs_jval_as_number(jchip_select);
} else {
spi->chip_select = __kSpiCsMax;
}
if (spi->chip_select >= __kSpiCsMax) {
return JS_CREATE_ERROR(
TYPE, "Bad arguments - chipSelect should be CHIPSELECT.NONE or HIGH");
}
}
jerry_release_value(jchip_select);
jerry_value_t jmax_speed =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_MAXSPEED);
if (jerry_value_is_undefined(jmax_speed)) {
spi->max_speed = 500000;
} else {
if (!jerry_value_is_number(jmax_speed)) {
return JS_CREATE_ERROR(TYPE, "Bad arguments - maxSpeed should be Number");
}
spi->max_speed = iotjs_jval_as_number(jmax_speed);
}
jerry_release_value(jmax_speed);
jerry_value_t jbits_per_word =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_BITSPERWORD);
if (jerry_value_is_undefined(jbits_per_word)) {
spi->bits_per_word = 8;
} else {
if (jerry_value_is_number(jbits_per_word)) {
spi->bits_per_word = iotjs_jval_as_number(jbits_per_word);
} else {
spi->bits_per_word = 0;
}
if (spi->bits_per_word != 8 && spi->bits_per_word != 9) {
return JS_CREATE_ERROR(TYPE,
"Bad arguments - bitsPerWord should be 8 or 9");
}
}
jerry_release_value(jbits_per_word);
jerry_value_t jbit_order =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_BITORDER);
if (jerry_value_is_undefined(jbit_order)) {
spi->bit_order = kSpiOrderMsb;
} else {
if (jerry_value_is_number(jbit_order)) {
spi->bit_order = (SpiOrder)iotjs_jval_as_number(jbit_order);
} else {
spi->bit_order = __kSpiOrderMax;
}
if (spi->bit_order >= __kSpiOrderMax) {
return JS_CREATE_ERROR(
TYPE, "Bad arguments - bitOrder should be BITORDER.MSB or LSB");
}
}
jerry_release_value(jbit_order);
jerry_value_t jloopback =
iotjs_jval_get_property(joptions, IOTJS_MAGIC_STRING_LOOPBACK);
if (jerry_value_is_undefined(jloopback)) {
spi->loopback = false;
} else {
if (!jerry_value_is_boolean(jloopback)) {
return JS_CREATE_ERROR(TYPE,
"Bad arguments - loopback should be Boolean");
}
spi->loopback = iotjs_jval_as_boolean(jloopback);
}
jerry_release_value(jloopback);
return jerry_create_undefined();
}
