int
main (int argc,
char **argv)
{
srand ((unsigned) jerry_port_get_current_time ());
if (argc <= 1 || (argc == 2 && (!strcmp ("-h", argv[1]) || !strcmp ("--help", argv[1]))))
{
print_help (argv[0]);
return JERRY_STANDALONE_EXIT_CODE_OK;
}
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t ret_value = jerry_create_undefined ();
for (int i = 1; i < argc; i++)
{
const char *file_name = argv[i];
size_t source_size;
const jerry_char_t *source_p = read_file (file_name, &source_size);
if (source_p == NULL)
{
ret_value = jerry_create_error (JERRY_ERROR_COMMON, (jerry_char_t *) "");
break;
}
else
{
ret_value = jerry_parse (source_p, source_size, false);
if (!jerry_value_has_error_flag (ret_value))
{
jerry_value_t func_val = ret_value;
ret_value = jerry_run (func_val);
jerry_release_value (func_val);
}
}
if (jerry_value_has_error_flag (ret_value))
{
break;
}
jerry_release_value (ret_value);
ret_value = jerry_create_undefined ();
}
int ret_code = JERRY_STANDALONE_EXIT_CODE_OK;
if (jerry_value_has_error_flag (ret_value))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Unhandled exception: Script Error!\n");
ret_code = JERRY_STANDALONE_EXIT_CODE_FAIL;
}
jerry_release_value (ret_value);
jerry_cleanup ();
return ret_code;
} /* main */
static int shell_cmd_handler (char *source_buffer)
{
jerry_value_t ret_val;
ret_val = jerry_eval ((jerry_char_t *) source_buffer,
strlen (source_buffer),
JERRY_PARSE_NO_OPTS);
if (jerry_value_is_error (ret_val))
{
/* User-friendly error messages require at least "cp" JerryScript
profile. Include a message prefix in case "cp_minimal" profile
is used. */
printf ("Error executing statement: ");
/* Clear error flag, otherwise print call below won't produce any
output. */
ret_val = jerry_get_value_from_error (ret_val, true);
}
if (!jerry_value_is_error (print_function))
{
jerry_value_t ret_val_print = jerry_call_function (print_function,
jerry_create_undefined (),
&ret_val,
1);
jerry_release_value (ret_val_print);
}
jerry_release_value (ret_val);
return 0;
} /* shell_cmd_handler */
/**
* Print error value
*/
static void
print_unhandled_exception (jerry_value_t error_value) /**< error value */
{
assert (!jerry_value_has_error_flag (error_value));
jerry_value_t err_str_val = jerry_value_to_string (error_value);
if (jerry_value_has_error_flag (err_str_val))
{
/* Avoid recursive error throws. */
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Snapshot error: [value cannot be converted to string]\n");
jerry_release_value (err_str_val);
return;
}
jerry_size_t err_str_size = jerry_get_string_size (err_str_val);
if (err_str_size >= 256)
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Snapshot error: [value cannot be converted to string]\n");
jerry_release_value (err_str_val);
return;
}
jerry_char_t err_str_buf[256];
jerry_size_t string_end = jerry_string_to_char_buffer (err_str_val, err_str_buf, err_str_size);
assert (string_end == err_str_size);
err_str_buf[string_end] = 0;
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Snapshot error: %s\n", (char *) err_str_buf);
jerry_release_value (err_str_val);
} /* print_unhandled_exception */
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;
}
void jerry_start ()
{
srand ((unsigned) jerry_port_get_current_time ());
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t global_obj_val = jerry_get_global_object ();
jerry_value_t print_func_name_val = jerry_create_string ((jerry_char_t *) "print");
print_function = jerry_get_property (global_obj_val, print_func_name_val);
jerry_release_value (print_func_name_val);
jerry_release_value (global_obj_val);
}
jerry_value_t InitProcess() {
jerry_value_t process = jerry_create_object();
iotjs_jval_set_method(process, IOTJS_MAGIC_STRING_COMPILE, Compile);
iotjs_jval_set_method(process, IOTJS_MAGIC_STRING_COMPILEMODULE,
CompileModule);
iotjs_jval_set_method(process, IOTJS_MAGIC_STRING_READSOURCE, ReadSource);
iotjs_jval_set_method(process, IOTJS_MAGIC_STRING_CWD, Cwd);
iotjs_jval_set_method(process, IOTJS_MAGIC_STRING_CHDIR, Chdir);
iotjs_jval_set_method(process, IOTJS_MAGIC_STRING_DEBUGGERGETSOURCE,
DebuggerGetSource);
iotjs_jval_set_method(process, IOTJS_MAGIC_STRING_DOEXIT, DoExit);
SetProcessEnv(process);
// process.builtin_modules
jerry_value_t builtin_modules = jerry_create_object();
SetBuiltinModules(builtin_modules);
iotjs_jval_set_property_jval(process, IOTJS_MAGIC_STRING_BUILTIN_MODULES,
builtin_modules);
jerry_release_value(builtin_modules);
// process.platform
iotjs_jval_set_property_string_raw(process, IOTJS_MAGIC_STRING_PLATFORM,
TARGET_OS);
// process.arch
iotjs_jval_set_property_string_raw(process, IOTJS_MAGIC_STRING_ARCH,
TARGET_ARCH);
// process.version
iotjs_jval_set_property_string_raw(process, IOTJS_MAGIC_STRING_VERSION,
IOTJS_VERSION);
// Set iotjs
SetProcessIotjs(process);
bool wait_source;
if (iotjs_environment_config(iotjs_environment_get())->debugger != NULL) {
wait_source = iotjs_environment_config(iotjs_environment_get())
->debugger->wait_source;
} else {
wait_source = false;
}
if (!wait_source) {
SetProcessArgv(process);
}
jerry_value_t wait_source_val = jerry_create_boolean(wait_source);
iotjs_jval_set_property_jval(process, IOTJS_MAGIC_STRING_DEBUGGERWAITSOURCE,
wait_source_val);
jerry_release_value(wait_source_val);
return process;
}
static void AfterAsync(uv_fs_t* req) {
const jerry_value_t cb = *IOTJS_UV_REQUEST_JSCALLBACK(req);
IOTJS_ASSERT(jerry_value_is_function(cb));
jerry_value_t jargs[2] = { 0 };
size_t jargc = 0;
if (req->result < 0) {
jerry_value_t jerror = iotjs_create_uv_exception(req->result, "open");
jargs[jargc++] = jerror;
} else {
jargs[jargc++] = jerry_create_null();
switch (req->fs_type) {
case UV_FS_CLOSE: {
break;
}
case UV_FS_OPEN:
case UV_FS_READ:
case UV_FS_WRITE: {
jargs[jargc++] = jerry_create_number((double)req->result);
break;
}
case UV_FS_SCANDIR: {
int r;
uv_dirent_t ent;
uint32_t idx = 0;
jargs[jargc++] = jerry_create_array(0);
while ((r = uv_fs_scandir_next(req, &ent)) != UV_EOF) {
jerry_value_t name =
jerry_create_string((const jerry_char_t*)ent.name);
iotjs_jval_set_property_by_index(jargs[1], idx, name);
jerry_release_value(name);
idx++;
}
break;
}
case UV_FS_FSTAT:
case UV_FS_STAT: {
uv_stat_t s = (req->statbuf);
jargs[jargc++] = MakeStatObject(&s);
break;
}
default: { break; }
}
}
iotjs_invoke_callback(cb, jerry_create_undefined(), jargs, jargc);
jerry_release_value(jargs[0]);
jerry_release_value(jargs[1]);
uv_fs_req_cleanup(req);
iotjs_uv_request_destroy((uv_req_t*)req);
}
jerry_value_t init_$MODULE_NAME$(void) {
jerry_value_t object = jerry_create_object();
jerry_value_t prop_name = jerry_create_string((const jerry_char_t*)"demokey");
jerry_value_t prop_value = jerry_create_number(3.4);
jerry_set_property(object, prop_name, prop_value);
jerry_release_value(prop_name);
jerry_release_value(prop_value);
return object;
}
void iotjs_jval_set_property_jval(const iotjs_jval_t* jobj, const char* name,
const iotjs_jval_t* val) {
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 value = iotjs_jval_as_raw(val);
jerry_value_t ret_val = jerry_set_property(_this->value, prop_name, value);
jerry_release_value(prop_name);
IOTJS_ASSERT(!jerry_value_has_error_flag(ret_val));
jerry_release_value(ret_val);
}
// 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);
}
/**
* Register a JavaScript value in the global object.
*/
static void
register_js_value (const char *name_p, /**< name of the function */
jerry_value_t value) /**< JS value */
{
jerry_value_t global_obj_val = jerry_get_global_object ();
jerry_value_t name_val = jerry_create_string ((const jerry_char_t *) name_p);
jerry_value_t result_val = jerry_set_property (global_obj_val, name_val, value);
TEST_ASSERT (jerry_value_is_boolean (result_val));
jerry_release_value (name_val);
jerry_release_value (global_obj_val);
jerry_release_value (result_val);
} /* register_js_value */
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);
}
/**
* The JS argument should be number, whose value is equal with the extra_info .
*/
static jerry_value_t
my_custom_transform (jerryx_arg_js_iterator_t *js_arg_iter_p, /**< available JS args */
const jerryx_arg_t *c_arg_p) /**< the native arg */
{
jerry_value_t js_arg = jerryx_arg_js_iterator_pop (js_arg_iter_p);
jerry_value_t to_number = jerry_value_to_number (js_arg);
if (jerry_value_has_error_flag (to_number))
{
jerry_release_value (to_number);
return jerry_create_error (JERRY_ERROR_TYPE,
(jerry_char_t *) "It can not be converted to a number.");
}
int expected_num = (int) c_arg_p->extra_info;
int get_num = (int) jerry_get_number_value (to_number);
if (get_num != expected_num)
{
return jerry_create_error (JERRY_ERROR_TYPE,
(jerry_char_t *) "Number value is not expected.");
}
return jerry_create_undefined ();
} /* my_custom_transform */
jerry_value_t InitTcp() {
jerry_value_t tcp = jerry_create_external_function(TCP);
jerry_value_t prototype = jerry_create_object();
iotjs_jval_set_property_jval(tcp, IOTJS_MAGIC_STRING_PROTOTYPE, prototype);
iotjs_jval_set_method(tcp, IOTJS_MAGIC_STRING_ERRNAME, ErrName);
iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_OPEN, Open);
iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_CLOSE, Close);
iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_CONNECT, Connect);
iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_BIND, Bind);
iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_LISTEN, Listen);
iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_WRITE, Write);
iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_READSTART, ReadStart);
iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_SHUTDOWN, Shutdown);
iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_SETKEEPALIVE,
SetKeepAlive);
iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_GETSOCKNAME,
GetSockeName);
jerry_release_value(prototype);
return tcp;
}
static void
print_unhandled_exception (jerry_value_t error_value)
{
assert (jerry_value_has_error_flag (error_value));
jerry_value_clear_error_flag (&error_value);
jerry_value_t err_str_val = jerry_value_to_string (error_value);
jerry_size_t err_str_size = jerry_get_string_size (err_str_val);
jerry_char_t err_str_buf[256];
if (err_str_size >= 256)
{
const char msg[] = "[Error message too long]";
err_str_size = sizeof (msg) / sizeof (char) - 1;
memcpy (err_str_buf, msg, err_str_size);
}
else
{
jerry_size_t sz = jerry_string_to_char_buffer (err_str_val, err_str_buf, err_str_size);
assert (sz == err_str_size);
}
err_str_buf[err_str_size] = 0;
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Script Error: %s\n", err_str_buf);
jerry_release_value (err_str_val);
} /* print_unhandled_exception */
/**
* Test ArrayBuffer 'read' api call with various offset values.
*/
static void
test_read_with_offset (uint8_t offset) /**< offset for buffer read. */
{
const char *eval_arraybuffer_src_p = ("var array = new Uint8Array (15);"
"for (var i = 0; i < array.length; i++) { array[i] = i * 2; };"
"array.buffer");
jerry_value_t arraybuffer = jerry_eval ((jerry_char_t *) eval_arraybuffer_src_p,
strlen (eval_arraybuffer_src_p),
true);
TEST_ASSERT (!jerry_value_is_error (arraybuffer));
TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
TEST_ASSERT (jerry_get_arraybuffer_byte_length (arraybuffer) == 15);
uint8_t buffer[20];
memset (buffer, 120, 20);
/* Try to copy more than the target buffer size. */
jerry_length_t copied = jerry_arraybuffer_read (arraybuffer, offset, buffer, 20);
TEST_ASSERT (copied == (jerry_length_t)(15 - offset));
for (uint8_t i = 0; i < copied; i++)
{
TEST_ASSERT (buffer[i] == (i + offset) * 2);
}
TEST_ASSERT (buffer[15 - offset] == 120);
jerry_release_value (arraybuffer);
} /* test_read_with_offset */
static jerry_value_t
handler_construct (const jerry_value_t func_obj_val, /**< function object */
const jerry_value_t this_val, /**< this value */
const jerry_value_t args_p[], /**< arguments list */
const jerry_length_t args_cnt) /**< arguments length */
{
printf ("ok construct %d %d %p %d\n", func_obj_val, this_val, args_p, args_cnt);
JERRY_ASSERT (jerry_value_is_object (this_val));
JERRY_ASSERT (args_cnt == 1);
JERRY_ASSERT (jerry_value_is_boolean (args_p[0]));
JERRY_ASSERT (jerry_get_boolean_value (args_p[0]) == true);
jerry_value_t field_name = jerry_create_string ((jerry_char_t *) "value_field");
jerry_set_property (this_val, field_name, args_p[0]);
jerry_release_value (field_name);
jerry_set_object_native_handle (this_val,
(uintptr_t) 0x0000000000000000ull,
handler_construct_freecb);
uintptr_t ptr;
bool is_ok = jerry_get_object_native_handle (this_val, &ptr);
JERRY_ASSERT (is_ok && ptr == (uintptr_t) 0x0000000000000000ull);
/* check if setting handle for second time is handled correctly */
jerry_set_object_native_handle (this_val,
(uintptr_t) 0x0012345678abcdefull,
handler_construct_freecb);
return jerry_create_boolean (true);
} /* handler_construct */
static void SetProcessArgv(jerry_value_t process) {
const iotjs_environment_t* env = iotjs_environment_get();
uint32_t argc = iotjs_environment_argc(env);
jerry_value_t argv = jerry_create_array(argc);
for (uint32_t i = 0; i < argc; ++i) {
const char* argvi = iotjs_environment_argv(env, i);
jerry_value_t arg = jerry_create_string((const jerry_char_t*)argvi);
iotjs_jval_set_property_by_index(argv, i, arg);
jerry_release_value(arg);
}
iotjs_jval_set_property_jval(process, IOTJS_MAGIC_STRING_ARGV, argv);
jerry_release_value(argv);
}
static jerry_value_t
test_validator_int3_handler (const jerry_value_t func_obj_val __attribute__((unused)), /**< function object */
const jerry_value_t this_val __attribute__((unused)), /**< this value */
const jerry_value_t args_p[], /**< arguments list */
const jerry_length_t args_cnt) /**< arguments length */
{
int8_t num0;
jerryx_arg_t mapping[] =
{
jerryx_arg_int8 (&num0, JERRYX_ARG_ROUND, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
};
jerry_value_t is_ok = jerryx_arg_transform_args (args_p,
args_cnt,
mapping,
ARRAY_SIZE (mapping));
TEST_ASSERT (jerry_value_has_error_flag (is_ok));
jerry_release_value (is_ok);
validator_int_count++;
return jerry_create_undefined ();
} /* test_validator_int3_handler */
static jerry_value_t
test_validator_array2_handler (const jerry_value_t func_obj_val __attribute__((unused)), /**< function object */
const jerry_value_t this_val __attribute__((unused)), /**< this value */
const jerry_value_t args_p[], /**< arguments list */
const jerry_length_t args_cnt __attribute__((unused))) /**< arguments length */
{
double native1 = 0;
bool native2 = false;
jerryx_arg_t item_mapping[] =
{
jerryx_arg_number (&native1, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_boolean (&native2, JERRYX_ARG_NO_COERCE, JERRYX_ARG_REQUIRED)
};
jerry_value_t is_ok = jerryx_arg_transform_array (args_p[0], item_mapping, ARRAY_SIZE (item_mapping));
TEST_ASSERT (jerry_value_has_error_flag (is_ok));
TEST_ASSERT (native1 == 1);
TEST_ASSERT (!native2);
validator_array_count++;
jerry_release_value (is_ok);
return jerry_create_undefined ();
} /* test_validator_array2_handler */
static void
assert_boolean_and_release (jerry_value_t result, bool expected)
{
TEST_ASSERT (jerry_value_is_boolean (result));
TEST_ASSERT (jerry_get_boolean_value (result) == expected);
jerry_release_value (result);
} /* assert_boolean_and_release */
static jerry_value_t
test_validator_prop3_handler (const jerry_value_t func_obj_val __attribute__((unused)), /**< function object */
const jerry_value_t this_val __attribute__((unused)), /**< this value */
const jerry_value_t args_p[], /**< arguments list */
const jerry_length_t args_cnt __attribute__((unused))) /**< arguments length */
{
bool native1 = false;
bool native2 = true;
const char *name_p[] = { "prop1", "prop2" };
jerryx_arg_t mapping[] =
{
jerryx_arg_boolean (&native1, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_boolean (&native2, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
};
jerry_value_t is_ok = jerryx_arg_transform_object_properties (args_p[0],
(const jerry_char_t **) name_p,
ARRAY_SIZE (name_p),
mapping,
ARRAY_SIZE (mapping));
TEST_ASSERT (jerry_value_has_error_flag (is_ok));
TEST_ASSERT (!native1);
TEST_ASSERT (native2);
validator_prop_count++;
jerry_release_value (is_ok);
return jerry_create_undefined ();
} /* test_validator_prop3_handler */
jerry_value_t InitFs(void) {
jerry_value_t fs = jerry_create_object();
iotjs_jval_set_method(fs, IOTJS_MAGIC_STRING_CLOSE, Close);
iotjs_jval_set_method(fs, IOTJS_MAGIC_STRING_OPEN, Open);
iotjs_jval_set_method(fs, IOTJS_MAGIC_STRING_READ, Read);
iotjs_jval_set_method(fs, IOTJS_MAGIC_STRING_WRITE, Write);
iotjs_jval_set_method(fs, IOTJS_MAGIC_STRING_STAT, Stat);
iotjs_jval_set_method(fs, IOTJS_MAGIC_STRING_FSTAT, Fstat);
iotjs_jval_set_method(fs, IOTJS_MAGIC_STRING_MKDIR, MkDir);
iotjs_jval_set_method(fs, IOTJS_MAGIC_STRING_RMDIR, RmDir);
iotjs_jval_set_method(fs, IOTJS_MAGIC_STRING_UNLINK, Unlink);
iotjs_jval_set_method(fs, IOTJS_MAGIC_STRING_RENAME, Rename);
iotjs_jval_set_method(fs, IOTJS_MAGIC_STRING_READDIR, ReadDir);
jerry_value_t stats_prototype = jerry_create_object();
iotjs_jval_set_method(stats_prototype, IOTJS_MAGIC_STRING_ISDIRECTORY,
StatsIsDirectory);
iotjs_jval_set_method(stats_prototype, IOTJS_MAGIC_STRING_ISFILE,
StatsIsFile);
iotjs_jval_set_property_jval(fs, IOTJS_MAGIC_STRING_STATS, stats_prototype);
jerry_release_value(stats_prototype);
return fs;
}
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);
}
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;
}
// Callback function for DebuggerGetSource
static jerry_value_t wait_for_source_callback(
const jerry_char_t* resource_name_p, size_t resource_name_size,
const jerry_char_t* source_p, size_t size, void* data) {
IOTJS_UNUSED(data);
jerry_value_t ret_val = jerry_create_array(2);
jerry_value_t jname =
jerry_create_string_sz(resource_name_p, resource_name_size);
jerry_value_t jsource = jerry_create_string_sz(source_p, size);
jerry_set_property_by_index(ret_val, 0, jname);
jerry_set_property_by_index(ret_val, 1, jsource);
jerry_release_value(jname);
jerry_release_value(jsource);
return ret_val;
}
napi_status napi_set_element(napi_env env, napi_value object, uint32_t index,
napi_value value) {
NAPI_TRY_ENV(env);
jerry_value_t jval_object = AS_JERRY_VALUE(object);
jerry_value_t jval_val = AS_JERRY_VALUE(value);
NAPI_TRY_TYPE(object, jval_object);
jerry_value_t res = jerry_set_property_by_index(jval_object, index, jval_val);
if (jerry_value_is_error(res)) {
jerry_release_value(res);
NAPI_RETURN(napi_invalid_arg, NULL);
}
jerry_release_value(res);
NAPI_RETURN(napi_ok);
}
void iotjs_module_list_cleanup(void) {
for (unsigned i = 0; i < iotjs_module_count; i++) {
if (iotjs_module_rw_data[i].jmodule != 0) {
jerry_release_value(iotjs_module_rw_data[i].jmodule);
iotjs_module_rw_data[i].jmodule = 0;
}
}
}
/*
* Init available js functions
*/
static void
init_jerry ()
{
jerry_init (JERRY_INIT_EMPTY);
/* Create an empty JS object */
jerry_value_t object = jerry_create_object ();
jerry_value_t func_obj;
jerry_value_t prop_name;
func_obj = jerry_create_external_function (set_led);
prop_name = jerry_create_string ((const jerry_char_t *) "setLed");
jerry_set_property (object, prop_name, func_obj);
jerry_release_value (prop_name);
jerry_release_value (func_obj);
func_obj = jerry_create_external_function (js_delay);
prop_name = jerry_create_string ((const jerry_char_t *) "delay");
jerry_set_property (object, prop_name, func_obj);
jerry_release_value (prop_name);
jerry_release_value (func_obj);
/* Wrap the JS object (not empty anymore) into a jerry api value */
jerry_value_t global_object = jerry_get_global_object ();
/* Add the JS object to the global context */
prop_name = jerry_create_string ((const jerry_char_t *) "test");
jerry_set_property (global_object, prop_name, object);
jerry_release_value (prop_name);
jerry_release_value (object);
jerry_release_value (global_object);
} /* init_jerry */
