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 */