size_t BufferWrap::length() {
#ifndef NDEBUG
int length = jbuffer().GetProperty("length").GetInt32();
IOTJS_ASSERT(static_cast<size_t>(length) == _length);
#endif
return _length;
}
JResult JObject::Call(JObject& this_, JArgList& arg) {
IOTJS_ASSERT(IsFunction());
JRawObjectType* this_obj_p = this_.IsNull() ? NULL
: this_.raw_value().u.v_object;
JRawValueType res;
JRawValueType* val_args = NULL;
uint16_t val_argv = 0;
if (arg.GetLength() > 0) {
val_argv = arg.GetLength();
val_args = new JRawValueType[val_argv];
for (int i = 0; i < val_argv; ++i) {
val_args[i] = arg.Get(i)->raw_value();
}
}
bool is_ok = jerry_api_call_function(_obj_val.u.v_object,
this_obj_p,
&res,
val_args,
val_argv);
if (val_args) {
delete [] val_args;
}
JResultType type = is_ok ? JRESULT_OK : JRESULT_EXCEPTION;
return JResult(&res, type);
}
static bool RunIoTjs(JObject* process) {
// Evaluating 'iotjs.js' returns a function.
#ifndef ENABLE_SNAPSHOT
JResult jmain = JObject::Eval(String(iotjs_s, iotjs_l), false, false);
#else
JResult jmain = JObject::ExecSnapshot(iotjs_s, iotjs_l);
#endif
IOTJS_ASSERT(jmain.IsOk());
// Run the entry function passing process builtin.
// The entry function will continue initializing process module, global, and
// other native modules, and finally load and run application.
JArgList args(1);
args.Add(*process);
JObject global(JObject::Global());
JResult jmain_res = jmain.value().Call(global, args);
if (jmain_res.IsException()) {
UncaughtException(jmain_res.value());
return false;
} else {
return true;
}
}
JObject CreateBuffer(size_t len) {
JObject jglobal(JObject::Global());
IOTJS_ASSERT(jglobal.IsObject());
JObject jBuffer(jglobal.GetProperty("Buffer"));
IOTJS_ASSERT(jBuffer.IsFunction());
JArgList jargs(1);
jargs.Add(JVal::Number((int)len));
JResult jres(jBuffer.Call(JObject::Null(), jargs));
IOTJS_ASSERT(jres.IsOk());
IOTJS_ASSERT(jres.value().IsObject());
return jres.value();
}
void iotjs_uart_destroy_platform_data(
iotjs_uart_platform_data_t* platform_data) {
IOTJS_ASSERT(platform_data);
iotjs_string_destroy(&platform_data->device_path);
IOTJS_RELEASE(platform_data);
}
bool iotjs_i2c_open(iotjs_i2c_t* i2c) {
IOTJS_VALIDATED_STRUCT_METHOD(iotjs_i2c_t, i2c)
iotjs_i2c_platform_data_t* platform_data = _this->platform_data;
IOTJS_ASSERT(platform_data);
// Init i2c context
platform_data->i2c_context = iotbus_i2c_init(platform_data->bus);
if (!platform_data->i2c_context) {
DLOG("%s: cannot open I2C", __func__);
return false;
}
// Set i2c frequency
int ret =
iotbus_i2c_set_frequency(platform_data->i2c_context, IOTBUS_I2C_STD);
if (ret < 0) {
DLOG("%s: cannot set frequency", __func__);
return false;
}
if (iotbus_i2c_set_address(platform_data->i2c_context, _this->address) < 0) {
DLOG("%s: cannot set address", __func__);
return false;
}
return true;
}
// 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;
}
JObject::JObject(const char* v) {
IOTJS_ASSERT(v != NULL);
_obj_val.type = JERRY_API_DATA_TYPE_STRING;
_obj_val.u.v_string = jerry_api_create_string(
reinterpret_cast<const jerry_api_char_t*>(v));
_unref_at_close = true;
}
JObject::JObject(const String& v) {
IOTJS_ASSERT(!v.IsEmpty());
_obj_val.type = JERRY_API_DATA_TYPE_STRING;
_obj_val.v_string = jerry_api_create_string(
reinterpret_cast<const jerry_api_char_t*>(v.data()));
_unref_at_close = true;
}
void JArgList::Set(uint16_t i, JObject& x) {
IOTJS_ASSERT(i < _argc);
if (_argv[i] != NULL) {
delete _argv[i];
}
_argv[i] = new JObject(x);
}
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;
}
void iotjs_uart_handlewrap_close_cb(uv_handle_t* handle) {
iotjs_uart_t* uart = (iotjs_uart_t*)handle->data;
if (close(uart->device_fd) < 0) {
DLOG(iotjs_periph_error_str(kUartOpClose));
IOTJS_ASSERT(0);
}
}
BufferWrap::BufferWrap(JObject& jbuiltin,
size_t length)
: JObjectWrap(jbuiltin)
, _buffer(NULL)
, _length(length) {
_buffer = AllocBuffer(length);
IOTJS_ASSERT(_buffer != NULL);
}
void JHandlerInfo::Throw(JObject& ret) {
IOTJS_ASSERT(_thrown == false);
ret.Ref();
*_ret_val_p = ret.raw_value();
_thrown = true;
}
static void iotjs_spi_set_buffer(iotjs_spi_t* spi, const iotjs_jval_t* jtx_buf,
const iotjs_jval_t* jrx_buf) {
IOTJS_VALIDATED_STRUCT_METHOD(iotjs_spi_t, spi);
iotjs_bufferwrap_t* tx_buf = iotjs_bufferwrap_from_jbuffer(jtx_buf);
iotjs_bufferwrap_t* rx_buf = iotjs_bufferwrap_from_jbuffer(jrx_buf);
_this->tx_buf_data = iotjs_bufferwrap_buffer(tx_buf);
uint8_t tx_buf_len = iotjs_bufferwrap_length(tx_buf);
_this->rx_buf_data = iotjs_bufferwrap_buffer(rx_buf);
uint8_t rx_buf_len = iotjs_bufferwrap_length(rx_buf);
IOTJS_ASSERT(_this->tx_buf_data != NULL && _this->rx_buf_data != NULL);
IOTJS_ASSERT(tx_buf_len > 0 && rx_buf_len > 0 && tx_buf_len == rx_buf_len);
_this->buf_len = tx_buf_len;
}
String JObject::GetString() {
IOTJS_ASSERT(IsString());
size_t size = -jerry_api_string_to_char_buffer(_obj_val.v_string, NULL, 0);
String res("", size);
jerry_api_char_t* buffer = reinterpret_cast<jerry_api_char_t*>(res.data());
size_t check = jerry_api_string_to_char_buffer(_obj_val.v_string,
buffer,
size);
IOTJS_ASSERT(check == size);
return res;
}
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;
}
JObjectWrap::JObjectWrap(JObject& jobject, JObject& jholder)
: JObjectWrap(jobject) {
IOTJS_ASSERT(jholder.IsObject() || jholder.IsNull() || jholder.IsUndefined());
if (jholder.IsObject()) {
set_jholder(jholder);
}
}
JHANDLER_FUNCTION(Close, handler) {
IOTJS_ASSERT(handler.GetThis()->IsObject());
IOTJS_ASSERT(handler.GetArgLength() >= 1);
IOTJS_ASSERT(handler.GetArg(0)->IsNumber());
Environment* env = Environment::GetEnv();
int fd = handler.GetArg(0)->GetInt32();
if (handler.GetArgLength() > 1 && handler.GetArg(1)->IsFunction()) {
FS_ASYNC(env, close, handler.GetArg(1), fd);
} else {
FS_SYNC(env, close, fd);
}
return !handler.HasThrown();
}
static void AfterShutdown(uv_shutdown_t* req, int status) {
ShutdownReqWrap* req_wrap = reinterpret_cast<ShutdownReqWrap*>(req->data);
TcpWrap* tcp_wrap = reinterpret_cast<TcpWrap*>(req->handle->data);
IOTJS_ASSERT(req_wrap != NULL);
IOTJS_ASSERT(tcp_wrap != NULL);
// function onShutdown(status)
JObject jonshutdown(req_wrap->jcallback());
IOTJS_ASSERT(jonshutdown.IsFunction());
JArgList args(1);
args.Add(JVal::Number(status));
MakeCallback(jonshutdown, JObject::Null(), args);
delete req_wrap;
}
iotjs_jval_t iotjs_jhelper_call_ok(const iotjs_jval_t* jfunc,
const iotjs_jval_t* jthis,
const iotjs_jargs_t* jargs) {
bool throws;
iotjs_jval_t jres = iotjs_jhelper_call(jfunc, jthis, jargs, &throws);
IOTJS_ASSERT(!throws);
return jres;
}
uintptr_t iotjs_jval_get_object_native_handle(const iotjs_jval_t* jobj) {
const IOTJS_VALIDATED_STRUCT_METHOD(iotjs_jval_t, jobj);
IOTJS_ASSERT(iotjs_jval_is_object(jobj));
uintptr_t ptr;
jerry_get_object_native_handle(_this->value, &ptr);
return ptr;
}
void iotjs_jval_set_object_native_handle(const iotjs_jval_t* jobj,
uintptr_t ptr,
JFreeHandlerType free_handler) {
const IOTJS_VALIDATED_STRUCT_METHOD(iotjs_jval_t, jobj);
IOTJS_ASSERT(iotjs_jval_is_object(jobj));
jerry_set_object_native_handle(_this->value, ptr, free_handler);
}
iotjs_jval_t iotjs_jval_create_function(JHandlerType handler) {
iotjs_jval_t jval;
IOTJS_VALIDATED_STRUCT_CONSTRUCTOR(iotjs_jval_t, &jval);
_this->value = jerry_create_external_function(handler);
IOTJS_ASSERT(jerry_value_is_constructor(_this->value));
return jval;
}
void iotjs_jargs_replace(iotjs_jargs_t* jargs, uint16_t index,
const iotjs_jval_t* x) {
IOTJS_VALIDATED_STRUCT_METHOD(iotjs_jargs_t, jargs);
IOTJS_ASSERT(index < _this->argc);
iotjs_jval_destroy(&_this->argv[index]);
_this->argv[index] = iotjs_jval_create_copied(x);
}
void iotjs_jval_set_method(const iotjs_jval_t* jobj, const char* name,
JHandlerType handler) {
const IOTJS_VALIDATED_STRUCT_METHOD(iotjs_jval_t, jobj);
IOTJS_ASSERT(iotjs_jval_is_object(jobj));
iotjs_jval_t jfunc = iotjs_jval_create_function(handler);
iotjs_jval_set_property_jval(jobj, name, &jfunc);
iotjs_jval_destroy(&jfunc);
}
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;
}
void OnRead(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) {
TcpWrap* tcp_wrap = reinterpret_cast<TcpWrap*>(handle->data);
IOTJS_ASSERT(tcp_wrap != NULL);
// tcp handle
JObject jtcp = tcp_wrap->jobject();
IOTJS_ASSERT(jtcp.IsObject());
// socket object
JObject jsocket = jtcp.GetProperty("owner");
IOTJS_ASSERT(jsocket.IsObject());
// onread callback
JObject jonread = jtcp.GetProperty("onread");
IOTJS_ASSERT(jonread.IsFunction());
JArgList jargs(4);
jargs.Add(jsocket);
jargs.Add(JVal::Number((int)nread));
jargs.Add(JVal::Bool(false));
if (nread <= 0) {
if (buf->base != NULL) {
ReleaseBuffer(buf->base);
}
if (nread < 0) {
if (nread == UV__EOF) {
jargs.Set(2, JVal::Bool(true));
}
MakeCallback(jonread, JObject::Null(), jargs);
}
return;
}
JObject jbuffer(CreateBuffer(static_cast<size_t>(nread)));
BufferWrap* buffer_wrap = BufferWrap::FromJBuffer(jbuffer);
buffer_wrap->Copy(buf->base, nread);
jargs.Add(jbuffer);
MakeCallback(jonread, JObject::Null(), jargs);
ReleaseBuffer(buf->base);
}
static void After(uv_fs_t* req) {
FsReqWrap* req_wrap = static_cast<FsReqWrap*>(req->data);
IOTJS_ASSERT(req_wrap != NULL);
IOTJS_ASSERT(req_wrap->data() == req);
JObject cb = req_wrap->jcallback();
IOTJS_ASSERT(cb.IsFunction());
JArgList jarg(2);
if (req->result < 0) {
JObject jerror(CreateUVException(req->result, "open"));
jarg.Add(jerror);
} else {
jarg.Add(JObject::Null());
switch (req->fs_type) {
case UV_FS_CLOSE:
{
break;
}
case UV_FS_OPEN:
case UV_FS_READ:
case UV_FS_WRITE:
{
JObject arg1(static_cast<int>(req->result));
jarg.Add(arg1);
break;
}
case UV_FS_STAT: {
uv_stat_t s = (req->statbuf);
JObject ret(MakeStatObject(&s));
jarg.Add(ret);
break;
}
default:
jarg.Add(JObject::Null());
}
}
JObject res = MakeCallback(cb, JObject::Null(), jarg);
uv_fs_req_cleanup(req);
delete req_wrap;
}
JObject MakeStatObject(uv_stat_t* statbuf) {
Module* module = GetBuiltinModule(MODULE_FS);
IOTJS_ASSERT(module != NULL);
JObject* fs = module->module;
IOTJS_ASSERT(fs != NULL);
JObject createStat = fs->GetProperty("_createStat");
IOTJS_ASSERT(createStat.IsFunction());
JObject jstat;
#define X(statobj, name) \
JObject name((int32_t)statbuf->st_##name); \
statobj.SetProperty(#name, name); \
X(jstat, dev)
X(jstat, mode)
X(jstat, nlink)
X(jstat, uid)
X(jstat, gid)
X(jstat, rdev)
#undef X
#define X(statobj, name) \
JObject name((double)statbuf->st_##name); \
statobj.SetProperty(#name, name); \
X(jstat, blksize)
X(jstat, ino)
X(jstat, size)
X(jstat, blocks)
#undef X
JArgList jargs(1);
jargs.Add(jstat);
JResult jstat_res(createStat.Call(JObject::Null(), jargs));
IOTJS_ASSERT(jstat_res.IsOk());
return jstat_res.value();
}
