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; }
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; }
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 jerry_value_t create_object (void) { jerry_value_t obj = jerry_create_object (); jerry_set_object_native_pointer (obj, NULL, &native_info); return obj; } /* create_object */
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; }
/* * 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 */
iotjs_jval_t iotjs_jval_create_object() { iotjs_jval_t jval; IOTJS_VALIDATED_STRUCT_CONSTRUCTOR(iotjs_jval_t, &jval); _this->value = jerry_create_object(); return jval; }
jerry_value_t InitConsole() { jerry_value_t console = jerry_create_object(); iotjs_jval_set_method(console, IOTJS_MAGIC_STRING_STDOUT, Stdout); iotjs_jval_set_method(console, IOTJS_MAGIC_STRING_STDERR, Stderr); return console; }
static void SetProcessIotjs(jerry_value_t process) { // IoT.js specific jerry_value_t iotjs = jerry_create_object(); iotjs_jval_set_property_jval(process, IOTJS_MAGIC_STRING_IOTJS, iotjs); iotjs_jval_set_property_string_raw(iotjs, IOTJS_MAGIC_STRING_BOARD, TOSTRING(TARGET_BOARD)); jerry_release_value(iotjs); }
int main (void) { TEST_INIT (); jerry_init (JERRY_INIT_EMPTY); jerry_value_t object = jerry_create_object (); jerry_value_t prop_name = jerry_create_string_from_utf8 ((jerry_char_t *) "something"); jerry_value_t prop_value = jerry_create_boolean (true); jerry_value_t proto_object = jerry_create_object (); /* Assert that an empty object does not have the property in question */ assert_boolean_and_release (jerry_has_property (object, prop_name), false); assert_boolean_and_release (jerry_has_own_property (object, prop_name), false); assert_boolean_and_release (jerry_set_prototype (object, proto_object), true); /* If the object has a prototype, that still means it doesn't have the property */ assert_boolean_and_release (jerry_has_property (object, prop_name), false); assert_boolean_and_release (jerry_has_own_property (object, prop_name), false); assert_boolean_and_release (jerry_set_property (proto_object, prop_name, prop_value), true); /* After setting the property on the prototype, it must be there, but not on the object */ assert_boolean_and_release (jerry_has_property (object, prop_name), true); assert_boolean_and_release (jerry_has_own_property (object, prop_name), false); TEST_ASSERT (jerry_delete_property (proto_object, prop_name)); assert_boolean_and_release (jerry_set_property (object, prop_name, prop_value), true); /* After relocating the property onto the object, it must be there */ assert_boolean_and_release (jerry_has_property (object, prop_name), true); assert_boolean_and_release (jerry_has_own_property (object, prop_name), true); jerry_release_value (object); jerry_release_value (prop_name); jerry_release_value (prop_value); jerry_release_value (proto_object); jerry_cleanup (); return 0; } /* main */
jerry_value_t InitSpi() { jerry_value_t jspi_cons = jerry_create_external_function(SpiCons); jerry_value_t prototype = jerry_create_object(); iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_CLOSE, Close); iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_CLOSESYNC, CloseSync); iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_TRANSFER, Transfer); iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_TRANSFERSYNC, TransferSync); iotjs_jval_set_property_jval(jspi_cons, IOTJS_MAGIC_STRING_PROTOTYPE, prototype); jerry_release_value(prototype); // SPI mode properties jerry_value_t jmode = jerry_create_object(); iotjs_jval_set_property_number(jmode, IOTJS_MAGIC_STRING_0, kSpiMode_0); iotjs_jval_set_property_number(jmode, IOTJS_MAGIC_STRING_1, kSpiMode_1); iotjs_jval_set_property_number(jmode, IOTJS_MAGIC_STRING_2, kSpiMode_2); iotjs_jval_set_property_number(jmode, IOTJS_MAGIC_STRING_3, kSpiMode_3); iotjs_jval_set_property_jval(jspi_cons, IOTJS_MAGIC_STRING_MODE_U, jmode); jerry_release_value(jmode); // SPI mode properties jerry_value_t jcs = jerry_create_object(); iotjs_jval_set_property_number(jcs, IOTJS_MAGIC_STRING_NONE_U, kSpiCsNone); iotjs_jval_set_property_number(jcs, IOTJS_MAGIC_STRING_HIGH_U, kSpiCsHigh); iotjs_jval_set_property_jval(jspi_cons, IOTJS_MAGIC_STRING_CHIPSELECT_U, jcs); jerry_release_value(jcs); // SPI order properties jerry_value_t jbit_order = jerry_create_object(); iotjs_jval_set_property_number(jbit_order, IOTJS_MAGIC_STRING_MSB, kSpiOrderMsb); iotjs_jval_set_property_number(jbit_order, IOTJS_MAGIC_STRING_LSB, kSpiOrderLsb); iotjs_jval_set_property_jval(jspi_cons, IOTJS_MAGIC_STRING_BITORDER_U, jbit_order); jerry_release_value(jbit_order); return jspi_cons; }
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; }
jerry_value_t InitAdc() { jerry_value_t jadc_cons = jerry_create_external_function(AdcCons); jerry_value_t jprototype = jerry_create_object(); iotjs_jval_set_method(jprototype, IOTJS_MAGIC_STRING_READ, Read); iotjs_jval_set_method(jprototype, IOTJS_MAGIC_STRING_READSYNC, ReadSync); iotjs_jval_set_method(jprototype, IOTJS_MAGIC_STRING_CLOSE, Close); iotjs_jval_set_method(jprototype, IOTJS_MAGIC_STRING_CLOSESYNC, CloseSync); iotjs_jval_set_property_jval(jadc_cons, IOTJS_MAGIC_STRING_PROTOTYPE, jprototype); jerry_release_value(jprototype); return jadc_cons; }
void iotjs_stm32f4dis_pin_initialize(jerry_value_t jobj) { jerry_value_t jpin = jerry_create_object(); iotjs_jval_set_property_jval(jobj, "pin", jpin); #if ENABLE_MODULE_ADC iotjs_pin_initialize_adc(jpin); #endif /* ENABLE_MODULE_ADC */ #if ENABLE_MODULE_GPIO iotjs_pin_initialize_gpio(jpin); #endif /* ENABLE_MODULE_GPIO */ #if ENABLE_MODULE_PWM iotjs_pin_initialize_pwm(jpin); #endif /* ENABLE_MODULE_PWM */ jerry_release_value(jpin); }
static void SetProcessEnv(jerry_value_t process) { const char *homedir, *iotjspath, *iotjsenv, *extra_module_path; homedir = getenv(IOTJS_MAGIC_STRING_HOME_U); if (homedir == NULL) { homedir = ""; } iotjspath = getenv(IOTJS_MAGIC_STRING_IOTJS_PATH_U); if (iotjspath == NULL) { #if defined(__NUTTX__) || defined(__TIZENRT__) iotjspath = "/mnt/sdcard"; #else iotjspath = ""; #endif } #if defined(EXPERIMENTAL) iotjsenv = "experimental"; #else iotjsenv = ""; #endif extra_module_path = getenv(IOTJS_MAGIC_STRING_IOTJS_EXTRA_MODULE_PATH_U); jerry_value_t env = jerry_create_object(); iotjs_jval_set_property_string_raw(env, IOTJS_MAGIC_STRING_HOME_U, homedir); iotjs_jval_set_property_string_raw(env, IOTJS_MAGIC_STRING_IOTJS_PATH_U, iotjspath); iotjs_jval_set_property_string_raw(env, IOTJS_MAGIC_STRING_IOTJS_ENV_U, iotjsenv); iotjs_jval_set_property_string_raw( env, IOTJS_MAGIC_STRING_IOTJS_EXTRA_MODULE_PATH_U, extra_module_path ? extra_module_path : ""); iotjs_jval_set_property_jval(process, IOTJS_MAGIC_STRING_ENV, env); jerry_release_value(env); }
jerry_value_t InitBlehcisocket() { jerry_value_t jblehcisocketCons = jerry_create_external_function(BleHciSocketCons); jerry_value_t prototype = jerry_create_object(); iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_START, Start); iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_BINDRAW, BindRaw); iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_BINDUSER, BindUser); iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_BINDCONTROL, BindControl); iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_ISDEVUP, IsDevUp); iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_SETFILTER, SetFilter); iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_STOP, Stop); iotjs_jval_set_method(prototype, IOTJS_MAGIC_STRING_WRITE, Write); iotjs_jval_set_property_jval(jblehcisocketCons, IOTJS_MAGIC_STRING_PROTOTYPE, prototype); jerry_release_value(prototype); return jblehcisocketCons; }
int main (void) { TEST_INIT (); jerry_init (JERRY_INIT_EMPTY); const jerry_char_t test_eval_function[] = "function demo(a) { return a + 1; }; demo"; test_entry_t entries[] = { ENTRY (JERRY_TYPE_NUMBER, jerry_create_number (-33.0)), ENTRY (JERRY_TYPE_NUMBER, jerry_create_number (3)), ENTRY (JERRY_TYPE_NUMBER, jerry_create_number_nan ()), ENTRY (JERRY_TYPE_NUMBER, jerry_create_number_infinity (false)), ENTRY (JERRY_TYPE_NUMBER, jerry_create_number_infinity (true)), ENTRY (JERRY_TYPE_BOOLEAN, jerry_create_boolean (true)), ENTRY (JERRY_TYPE_BOOLEAN, jerry_create_boolean (false)), ENTRY (JERRY_TYPE_UNDEFINED, jerry_create_undefined ()), ENTRY (JERRY_TYPE_OBJECT, jerry_create_object ()), ENTRY (JERRY_TYPE_OBJECT, jerry_create_array (10)), ENTRY (JERRY_TYPE_ERROR, jerry_create_error (JERRY_ERROR_TYPE, (const jerry_char_t *) "error")), ENTRY (JERRY_TYPE_NULL, jerry_create_null ()), ENTRY (JERRY_TYPE_FUNCTION, jerry_eval (test_eval_function, sizeof (test_eval_function) - 1, JERRY_PARSE_NO_OPTS)), ENTRY (JERRY_TYPE_FUNCTION, jerry_create_external_function (test_ext_function)), ENTRY (JERRY_TYPE_STRING, jerry_create_string (test_eval_function)), ENTRY (JERRY_TYPE_STRING, jerry_create_string ((jerry_char_t *) "")), }; for (size_t idx = 0; idx < sizeof (entries) / sizeof (entries[0]); idx++) { jerry_type_t type_info = jerry_value_get_type (entries[idx].value); TEST_ASSERT (type_info != JERRY_TYPE_NONE); TEST_ASSERT (type_info == entries[idx].type_info); jerry_release_value (entries[idx].value); } if (jerry_is_feature_enabled (JERRY_FEATURE_SYMBOL)) { jerry_value_t symbol_desc_value = jerry_create_string ((jerry_char_t *) "foo"); jerry_value_t symbol_value = jerry_create_symbol (symbol_desc_value); jerry_type_t type_info = jerry_value_get_type (symbol_value); TEST_ASSERT (type_info != JERRY_TYPE_NONE); TEST_ASSERT (type_info == JERRY_TYPE_SYMBOL); jerry_release_value (symbol_value); jerry_release_value (symbol_desc_value); } jerry_cleanup (); return 0; } /* main */
int main (void) { jerry_init (JERRY_INIT_EMPTY); /* Render strict-equal as a function. */ jerry_value_t parse_result = jerry_parse (NULL, 0, strict_equal_source, sizeof (strict_equal_source) - 1, JERRY_PARSE_STRICT_MODE); TEST_ASSERT (!jerry_value_is_error (parse_result)); jerry_value_t strict_equal = jerry_run (parse_result); TEST_ASSERT (!jerry_value_is_error (strict_equal)); jerry_release_value (parse_result); /* Create an object and associate some native data with it. */ jerry_value_t object = jerry_create_object (); jerry_set_object_native_pointer (object, &test_data, &test_info); /* Retrieve the object by its native pointer. */ jerry_value_t found_object; TEST_ASSERT (jerry_objects_foreach_by_native_info (&test_info, find_test_object_by_data, &found_object)); jerry_value_t args[2] = {object, found_object}; /* Assert that the correct object was retrieved. */ jerry_value_t undefined = jerry_create_undefined (); jerry_value_t strict_equal_result = jerry_call_function (strict_equal, undefined, args, 2); TEST_ASSERT (jerry_value_is_boolean (strict_equal_result) && jerry_get_boolean_value (strict_equal_result)); jerry_release_value (strict_equal_result); jerry_release_value (found_object); jerry_release_value (object); /* Collect garbage. */ jerry_gc (JERRY_GC_SEVERITY_LOW); /* Attempt to retrieve the object by its native pointer again. */ TEST_ASSERT (!jerry_objects_foreach_by_native_info (&test_info, find_test_object_by_data, &found_object)); /* Create an object and set a property on it. */ object = jerry_create_object (); jerry_value_t property_name = jerry_create_string ((jerry_char_t *) "xyzzy"); jerry_value_t property_value = jerry_create_number (42); jerry_release_value (jerry_set_property (object, property_name, property_value)); jerry_release_value (property_value); /* Retrieve the object by the presence of its property, placing it at args[1]. */ args[0] = property_name; TEST_ASSERT (jerry_objects_foreach (find_test_object_by_property, args)); /* Assert that the right object was retrieved and release both the original reference to it and the retrieved one. */ args[0] = object; strict_equal_result = jerry_call_function (strict_equal, undefined, args, 2); TEST_ASSERT (jerry_value_is_boolean (strict_equal_result) && jerry_get_boolean_value (strict_equal_result)); jerry_release_value (strict_equal_result); jerry_release_value (args[0]); jerry_release_value (args[1]); /* Collect garbage. */ jerry_gc (JERRY_GC_SEVERITY_LOW); /* Attempt to retrieve the object by the presence of its property again. */ args[0] = property_name; TEST_ASSERT (!jerry_objects_foreach (find_test_object_by_property, args)); jerry_release_value (property_name); jerry_release_value (undefined); jerry_release_value (strict_equal); jerry_cleanup (); } /* main */
int main (void) { TEST_INIT (); bool is_ok; jerry_size_t sz; jerry_value_t val_t, val_foo, val_bar, val_A, val_A_prototype, val_a, val_a_foo, val_value_field, val_p, val_np; jerry_value_t val_call_external; jerry_value_t global_obj_val, obj_val; jerry_value_t external_func_val, external_construct_val; jerry_value_t throw_test_handler_val; jerry_value_t parsed_code_val, proto_val, prim_val; jerry_value_t res, args[2]; char buffer[32]; is_ok = test_run_simple ("print ('Hello, World!');"); JERRY_ASSERT (is_ok); is_ok = test_run_simple ("throw 'Hello World';"); JERRY_ASSERT (!is_ok); jerry_init (JERRY_INIT_EMPTY); parsed_code_val = jerry_parse ((jerry_char_t *) test_source, strlen (test_source), false); JERRY_ASSERT (!jerry_value_has_error_flag (parsed_code_val)); res = jerry_run (parsed_code_val); JERRY_ASSERT (!jerry_value_has_error_flag (res)); jerry_release_value (res); jerry_release_value (parsed_code_val); global_obj_val = jerry_get_global_object (); // Test corner case for jerry_string_to_char_buffer args[0] = jerry_create_string ((jerry_char_t *) ""); sz = jerry_get_string_size (args[0]); JERRY_ASSERT (sz == 0); jerry_release_value (args[0]); // Get global.boo (non-existing field) val_t = get_property (global_obj_val, "boo"); JERRY_ASSERT (!jerry_value_has_error_flag (val_t)); JERRY_ASSERT (jerry_value_is_undefined (val_t)); // Get global.t val_t = get_property (global_obj_val, "t"); JERRY_ASSERT (!jerry_value_has_error_flag (val_t)); JERRY_ASSERT (jerry_value_is_number (val_t) && jerry_get_number_value (val_t) == 1.0); jerry_release_value (val_t); // Get global.foo val_foo = get_property (global_obj_val, "foo"); JERRY_ASSERT (!jerry_value_has_error_flag (val_foo)); JERRY_ASSERT (jerry_value_is_object (val_foo)); // Call foo (4, 2) args[0] = jerry_create_number (4); args[1] = jerry_create_number (2); res = jerry_call_function (val_foo, jerry_create_undefined (), args, 2); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_value_is_number (res) && jerry_get_number_value (res) == 1.0); jerry_release_value (res); // Get global.bar val_bar = get_property (global_obj_val, "bar"); JERRY_ASSERT (!jerry_value_has_error_flag (val_bar)); JERRY_ASSERT (jerry_value_is_object (val_bar)); // Call bar (4, 2) res = jerry_call_function (val_bar, jerry_create_undefined (), args, 2); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_value_is_number (res) && jerry_get_number_value (res) == 5.0); jerry_release_value (res); jerry_release_value (val_bar); // Set global.t = "abcd" jerry_release_value (args[0]); args[0] = jerry_create_string ((jerry_char_t *) "abcd"); res = set_property (global_obj_val, "t", args[0]); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_get_boolean_value (res)); jerry_release_value (res); // Call foo (4, 2) res = jerry_call_function (val_foo, jerry_create_undefined (), args, 2); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_value_is_string (res)); sz = jerry_get_string_size (res); JERRY_ASSERT (sz == 4); sz = jerry_string_to_char_buffer (res, (jerry_char_t *) buffer, sz); JERRY_ASSERT (sz == 4); jerry_release_value (res); JERRY_ASSERT (!strncmp (buffer, "abcd", (size_t) sz)); jerry_release_value (args[0]); jerry_release_value (args[1]); // Get global.A val_A = get_property (global_obj_val, "A"); JERRY_ASSERT (!jerry_value_has_error_flag (val_A)); JERRY_ASSERT (jerry_value_is_object (val_A)); // Get A.prototype is_ok = jerry_value_is_constructor (val_A); JERRY_ASSERT (is_ok); val_A_prototype = get_property (val_A, "prototype"); JERRY_ASSERT (!jerry_value_has_error_flag (val_A_prototype)); JERRY_ASSERT (jerry_value_is_object (val_A_prototype)); jerry_release_value (val_A); // Set A.prototype.foo = global.foo res = set_property (val_A_prototype, "foo", val_foo); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_get_boolean_value (res)); jerry_release_value (res); jerry_release_value (val_A_prototype); jerry_release_value (val_foo); // Get global.a val_a = get_property (global_obj_val, "a"); JERRY_ASSERT (!jerry_value_has_error_flag (val_a)); JERRY_ASSERT (jerry_value_is_object (val_a)); // Get a.t res = get_property (val_a, "t"); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_value_is_number (res) && jerry_get_number_value (res) == 12.0); jerry_release_value (res); // foreach properties val_p = get_property (global_obj_val, "p"); is_ok = jerry_foreach_object_property (val_p, foreach, (void *) "user_data"); JERRY_ASSERT (is_ok); // break foreach at third element int count = 0; is_ok = jerry_foreach_object_property (val_p, foreach_subset, &count); JERRY_ASSERT (is_ok); JERRY_ASSERT (count == 3); jerry_release_value (val_p); // foreach with throw test val_np = get_property (global_obj_val, "np"); is_ok = !jerry_foreach_object_property (val_np, foreach_exception, NULL); JERRY_ASSERT (is_ok); jerry_release_value (val_np); // Get a.foo val_a_foo = get_property (val_a, "foo"); JERRY_ASSERT (!jerry_value_has_error_flag (val_a_foo)); JERRY_ASSERT (jerry_value_is_object (val_a_foo)); // Call a.foo () res = jerry_call_function (val_a_foo, val_a, NULL, 0); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_value_is_number (res) && jerry_get_number_value (res) == 12.0); jerry_release_value (res); jerry_release_value (val_a_foo); jerry_release_value (val_a); // Create native handler bound function object and set it to 'external' variable external_func_val = jerry_create_external_function (handler); JERRY_ASSERT (jerry_value_is_function (external_func_val) && jerry_value_is_constructor (external_func_val)); res = set_property (global_obj_val, "external", external_func_val); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_get_boolean_value (res)); jerry_release_value (external_func_val); // Call 'call_external' function that should call external function created above val_call_external = get_property (global_obj_val, "call_external"); JERRY_ASSERT (!jerry_value_has_error_flag (val_call_external)); JERRY_ASSERT (jerry_value_is_object (val_call_external)); res = jerry_call_function (val_call_external, global_obj_val, NULL, 0); jerry_release_value (val_call_external); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_value_is_string (res)); sz = jerry_get_string_size (res); JERRY_ASSERT (sz == 19); sz = jerry_string_to_char_buffer (res, (jerry_char_t *) buffer, sz); JERRY_ASSERT (sz == 19); jerry_release_value (res); JERRY_ASSERT (!strncmp (buffer, "string from handler", (size_t) sz)); // Create native handler bound function object and set it to 'external_construct' variable external_construct_val = jerry_create_external_function (handler_construct); JERRY_ASSERT (jerry_value_is_function (external_construct_val) && jerry_value_is_constructor (external_construct_val)); res = set_property (global_obj_val, "external_construct", external_construct_val); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_get_boolean_value (res)); jerry_release_value (res); // Call external function created above, as constructor args[0] = jerry_create_boolean (true); res = jerry_construct_object (external_construct_val, args, 1); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_value_is_object (res)); val_value_field = get_property (res, "value_field"); // Get 'value_field' of constructed object JERRY_ASSERT (!jerry_value_has_error_flag (val_value_field)); JERRY_ASSERT (jerry_value_is_boolean (val_value_field) && jerry_get_boolean_value (val_value_field)); jerry_release_value (val_value_field); jerry_release_value (external_construct_val); uintptr_t ptr; is_ok = jerry_get_object_native_handle (res, &ptr); JERRY_ASSERT (is_ok && ptr == (uintptr_t) 0x0012345678abcdefull); jerry_release_value (res); // Test: Throwing exception from native handler. throw_test_handler_val = jerry_create_external_function (handler_throw_test); JERRY_ASSERT (jerry_value_is_function (throw_test_handler_val)); res = set_property (global_obj_val, "throw_test", throw_test_handler_val); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_get_boolean_value (res)); jerry_release_value (res); jerry_release_value (throw_test_handler_val); val_t = get_property (global_obj_val, "call_throw_test"); JERRY_ASSERT (!jerry_value_has_error_flag (val_t)); JERRY_ASSERT (jerry_value_is_object (val_t)); res = jerry_call_function (val_t, global_obj_val, NULL, 0); JERRY_ASSERT (!jerry_value_has_error_flag (res)); jerry_release_value (val_t); jerry_release_value (res); // Test: Unhandled exception in called function val_t = get_property (global_obj_val, "throw_reference_error"); JERRY_ASSERT (!jerry_value_has_error_flag (val_t)); JERRY_ASSERT (jerry_value_is_object (val_t)); res = jerry_call_function (val_t, global_obj_val, NULL, 0); JERRY_ASSERT (jerry_value_has_error_flag (res)); jerry_release_value (val_t); // 'res' should contain exception object JERRY_ASSERT (jerry_value_is_object (res)); jerry_release_value (res); // Test: Call of non-function obj_val = jerry_create_object (); res = jerry_call_function (obj_val, global_obj_val, NULL, 0); JERRY_ASSERT (jerry_value_has_error_flag (res)); // 'res' should contain exception object JERRY_ASSERT (jerry_value_is_object (res)); jerry_release_value (res); jerry_release_value (obj_val); // Test: Unhandled exception in function called, as constructor val_t = get_property (global_obj_val, "throw_reference_error"); JERRY_ASSERT (!jerry_value_has_error_flag (val_t)); JERRY_ASSERT (jerry_value_is_object (val_t)); res = jerry_construct_object (val_t, NULL, 0); JERRY_ASSERT (jerry_value_has_error_flag (res)); jerry_release_value (val_t); // 'res' should contain exception object JERRY_ASSERT (jerry_value_is_object (res)); jerry_release_value (res); // Test: Call of non-function as constructor obj_val = jerry_create_object (); res = jerry_construct_object (obj_val, NULL, 0); JERRY_ASSERT (jerry_value_has_error_flag (res)); // 'res' should contain exception object JERRY_ASSERT (jerry_value_is_object (res)); jerry_release_value (res); jerry_release_value (obj_val); // Test: Array Object API jerry_value_t array_obj_val = jerry_create_array (10); JERRY_ASSERT (jerry_value_is_array (array_obj_val)); JERRY_ASSERT (jerry_get_array_length (array_obj_val) == 10); jerry_value_t v_in = jerry_create_number (10.5); jerry_set_property_by_index (array_obj_val, 5, v_in); jerry_value_t v_out = jerry_get_property_by_index (array_obj_val, 5); JERRY_ASSERT (jerry_value_is_number (v_out) && jerry_get_number_value (v_out) == 10.5); jerry_release_value (v_in); jerry_release_value (v_out); jerry_release_value (array_obj_val); // Test: init property descriptor jerry_property_descriptor_t prop_desc; jerry_init_property_descriptor_fields (&prop_desc); JERRY_ASSERT (prop_desc.is_value_defined == false); JERRY_ASSERT (jerry_value_is_undefined (prop_desc.value)); JERRY_ASSERT (prop_desc.is_writable_defined == false); JERRY_ASSERT (prop_desc.is_writable == false); JERRY_ASSERT (prop_desc.is_enumerable_defined == false); JERRY_ASSERT (prop_desc.is_enumerable == false); JERRY_ASSERT (prop_desc.is_configurable_defined == false); JERRY_ASSERT (prop_desc.is_configurable == false); JERRY_ASSERT (prop_desc.is_get_defined == false); JERRY_ASSERT (jerry_value_is_undefined (prop_desc.getter)); JERRY_ASSERT (prop_desc.is_set_defined == false); JERRY_ASSERT (jerry_value_is_undefined (prop_desc.setter)); // Test: define own properties jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "my_defined_property"); prop_desc.is_value_defined = true; prop_desc.value = jerry_acquire_value (prop_name); res = jerry_define_own_property (global_obj_val, prop_name, &prop_desc); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_value_is_boolean (res)); JERRY_ASSERT (jerry_get_boolean_value (res)); jerry_release_value (res); jerry_free_property_descriptor_fields (&prop_desc); // Test: get own property descriptor is_ok = jerry_get_own_property_descriptor (global_obj_val, prop_name, &prop_desc); JERRY_ASSERT (is_ok); JERRY_ASSERT (prop_desc.is_value_defined == true); JERRY_ASSERT (jerry_value_is_string (prop_desc.value)); JERRY_ASSERT (prop_desc.is_writable == false); JERRY_ASSERT (prop_desc.is_enumerable == false); JERRY_ASSERT (prop_desc.is_configurable == false); JERRY_ASSERT (prop_desc.is_get_defined == false); JERRY_ASSERT (jerry_value_is_undefined (prop_desc.getter)); JERRY_ASSERT (prop_desc.is_set_defined == false); JERRY_ASSERT (jerry_value_is_undefined (prop_desc.setter)); jerry_release_value (prop_name); jerry_free_property_descriptor_fields (&prop_desc); // Test: object keys res = jerry_get_object_keys (global_obj_val); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_value_is_array (res)); jerry_release_value (res); // Test: jerry_value_to_primitive obj_val = jerry_eval ((jerry_char_t *) "new String ('hello')", 20, false); JERRY_ASSERT (!jerry_value_has_error_flag (obj_val)); JERRY_ASSERT (jerry_value_is_object (obj_val)); JERRY_ASSERT (!jerry_value_is_string (obj_val)); prim_val = jerry_value_to_primitive (obj_val); JERRY_ASSERT (!jerry_value_has_error_flag (prim_val)); JERRY_ASSERT (jerry_value_is_string (prim_val)); jerry_release_value (prim_val); // Test: jerry_get_prototype proto_val = jerry_get_prototype (obj_val); JERRY_ASSERT (!jerry_value_has_error_flag (proto_val)); JERRY_ASSERT (jerry_value_is_object (proto_val)); jerry_release_value (obj_val); // Test: jerry_set_prototype obj_val = jerry_create_object (); res = jerry_set_prototype (obj_val, jerry_create_null ()); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_value_is_boolean (res)); JERRY_ASSERT (jerry_get_boolean_value (res)); res = jerry_set_prototype (obj_val, jerry_create_object ()); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_value_is_boolean (res)); JERRY_ASSERT (jerry_get_boolean_value (res)); proto_val = jerry_get_prototype (obj_val); JERRY_ASSERT (!jerry_value_has_error_flag (proto_val)); JERRY_ASSERT (jerry_value_is_object (proto_val)); jerry_release_value (proto_val); jerry_release_value (obj_val); // Test: eval const char *eval_code_src_p = "(function () { return 123; })"; val_t = jerry_eval ((jerry_char_t *) eval_code_src_p, strlen (eval_code_src_p), true); JERRY_ASSERT (!jerry_value_has_error_flag (val_t)); JERRY_ASSERT (jerry_value_is_object (val_t)); JERRY_ASSERT (jerry_value_is_function (val_t)); res = jerry_call_function (val_t, jerry_create_undefined (), NULL, 0); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_value_is_number (res) && jerry_get_number_value (res) == 123.0); jerry_release_value (res); jerry_release_value (val_t); // cleanup. jerry_release_value (global_obj_val); // TEST: run gc. jerry_gc (); jerry_cleanup (); JERRY_ASSERT (test_api_is_free_callback_was_called); // External Magic String jerry_init (JERRY_INIT_SHOW_OPCODES); uint32_t num_magic_string_items = (uint32_t) (sizeof (magic_string_items) / sizeof (jerry_char_ptr_t)); jerry_register_magic_strings (magic_string_items, num_magic_string_items, magic_string_lengths); const char *ms_code_src_p = "var global = {}; var console = [1]; var process = 1;"; parsed_code_val = jerry_parse ((jerry_char_t *) ms_code_src_p, strlen (ms_code_src_p), false); JERRY_ASSERT (!jerry_value_has_error_flag (parsed_code_val)); res = jerry_run (parsed_code_val); JERRY_ASSERT (!jerry_value_has_error_flag (res)); jerry_release_value (res); jerry_release_value (parsed_code_val); jerry_cleanup (); // Dump / execute snapshot // FIXME: support save/load snapshot for optimized parser if (false) { static uint8_t global_mode_snapshot_buffer[1024]; static uint8_t eval_mode_snapshot_buffer[1024]; const char *code_to_snapshot_p = "(function () { return 'string from snapshot'; }) ();"; jerry_init (JERRY_INIT_SHOW_OPCODES); size_t global_mode_snapshot_size = jerry_parse_and_save_snapshot ((jerry_char_t *) code_to_snapshot_p, strlen (code_to_snapshot_p), true, false, global_mode_snapshot_buffer, sizeof (global_mode_snapshot_buffer)); JERRY_ASSERT (global_mode_snapshot_size != 0); jerry_cleanup (); jerry_init (JERRY_INIT_SHOW_OPCODES); size_t eval_mode_snapshot_size = jerry_parse_and_save_snapshot ((jerry_char_t *) code_to_snapshot_p, strlen (code_to_snapshot_p), false, false, eval_mode_snapshot_buffer, sizeof (eval_mode_snapshot_buffer)); JERRY_ASSERT (eval_mode_snapshot_size != 0); jerry_cleanup (); jerry_init (JERRY_INIT_SHOW_OPCODES); res = jerry_exec_snapshot (global_mode_snapshot_buffer, global_mode_snapshot_size, false); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_value_is_undefined (res)); jerry_release_value (res); res = jerry_exec_snapshot (eval_mode_snapshot_buffer, eval_mode_snapshot_size, false); JERRY_ASSERT (!jerry_value_has_error_flag (res)); JERRY_ASSERT (jerry_value_is_string (res)); sz = jerry_get_string_size (res); JERRY_ASSERT (sz == 20); sz = jerry_string_to_char_buffer (res, (jerry_char_t *) buffer, sz); JERRY_ASSERT (sz == 20); jerry_release_value (res); JERRY_ASSERT (!strncmp (buffer, "string from snapshot", (size_t) sz)); jerry_cleanup (); } return 0; } /* main */
jerry_value_t InitGpio() { jerry_value_t jgpioConstructor = jerry_create_external_function(GpioCons); jerry_value_t jprototype = jerry_create_object(); iotjs_jval_set_method(jprototype, IOTJS_MAGIC_STRING_CLOSE, Close); iotjs_jval_set_method(jprototype, IOTJS_MAGIC_STRING_CLOSESYNC, CloseSync); iotjs_jval_set_method(jprototype, IOTJS_MAGIC_STRING_WRITE, Write); iotjs_jval_set_method(jprototype, IOTJS_MAGIC_STRING_WRITESYNC, WriteSync); iotjs_jval_set_method(jprototype, IOTJS_MAGIC_STRING_READ, Read); iotjs_jval_set_method(jprototype, IOTJS_MAGIC_STRING_READSYNC, ReadSync); iotjs_jval_set_property_jval(jgpioConstructor, IOTJS_MAGIC_STRING_PROTOTYPE, jprototype); jerry_release_value(jprototype); // GPIO direction properties jerry_value_t jdirection = jerry_create_object(); iotjs_jval_set_property_number(jdirection, IOTJS_MAGIC_STRING_IN, kGpioDirectionIn); iotjs_jval_set_property_number(jdirection, IOTJS_MAGIC_STRING_OUT_U, kGpioDirectionOut); iotjs_jval_set_property_jval(jgpioConstructor, IOTJS_MAGIC_STRING_DIRECTION_U, jdirection); jerry_release_value(jdirection); // GPIO mode properties jerry_value_t jmode = jerry_create_object(); iotjs_jval_set_property_number(jmode, IOTJS_MAGIC_STRING_NONE_U, kGpioModeNone); #if defined(__NUTTX__) iotjs_jval_set_property_number(jmode, IOTJS_MAGIC_STRING_PULLUP_U, kGpioModePullup); iotjs_jval_set_property_number(jmode, IOTJS_MAGIC_STRING_PULLDOWN_U, kGpioModePulldown); iotjs_jval_set_property_number(jmode, IOTJS_MAGIC_STRING_FLOAT_U, kGpioModeFloat); iotjs_jval_set_property_number(jmode, IOTJS_MAGIC_STRING_PUSHPULL_U, kGpioModePushpull); iotjs_jval_set_property_number(jmode, IOTJS_MAGIC_STRING_OPENDRAIN_U, kGpioModeOpendrain); #endif iotjs_jval_set_property_jval(jgpioConstructor, IOTJS_MAGIC_STRING_MODE_U, jmode); jerry_release_value(jmode); // GPIO edge properties jerry_value_t jedge = jerry_create_object(); iotjs_jval_set_property_number(jedge, IOTJS_MAGIC_STRING_NONE_U, kGpioEdgeNone); iotjs_jval_set_property_number(jedge, IOTJS_MAGIC_STRING_RISING_U, kGpioEdgeRising); iotjs_jval_set_property_number(jedge, IOTJS_MAGIC_STRING_FALLING_U, kGpioEdgeFalling); iotjs_jval_set_property_number(jedge, IOTJS_MAGIC_STRING_BOTH_U, kGpioEdgeBoth); iotjs_jval_set_property_jval(jgpioConstructor, IOTJS_MAGIC_STRING_EDGE_U, jedge); jerry_release_value(jedge); return jgpioConstructor; }