/* * 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 */
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 */
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 */
static jerry_value_t set_property (const jerry_value_t obj_val, /**< object value */ const char *str_p, /**< property name */ const jerry_value_t val) /**< value to set */ { jerry_value_t prop_name_val = jerry_create_string ((const jerry_char_t *) str_p); jerry_value_t ret_val = jerry_set_property (obj_val, prop_name_val, val); jerry_release_value (prop_name_val); return ret_val; } /* set_property */
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); }
/** * 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 */
static bool register_native_function (const char* name, jerry_external_handler_t handler) { jerry_value_t global_object_val = jerry_get_global_object (); jerry_value_t reg_function = jerry_create_external_function (handler); bool is_ok = true; if (!(jerry_value_is_function (reg_function) && jerry_value_is_constructor (reg_function))) { is_ok = false; printf ("Error: create_external_function failed !!!\r\n"); jerry_release_value (global_object_val); jerry_release_value (reg_function); return is_ok; } if (jerry_value_has_error_flag (reg_function)) { is_ok = false; printf ("Error: create_external_function has error flag! \n\r"); jerry_release_value (global_object_val); jerry_release_value (reg_function); return is_ok; } jerry_value_t jerry_name = jerry_create_string ((jerry_char_t *) name); jerry_value_t set_result = jerry_set_property (global_object_val, jerry_name, reg_function); if (jerry_value_has_error_flag (set_result)) { is_ok = false; printf ("Error: register_native_function failed: [%s]\r\n", name); } jerry_release_value (jerry_name); jerry_release_value (global_object_val); jerry_release_value (reg_function); jerry_release_value (set_result); return is_ok; }
napi_status napi_set_property(napi_env env, napi_value object, napi_value key, napi_value value) { NAPI_TRY_ENV(env); jerry_value_t jval_object = AS_JERRY_VALUE(object); jerry_value_t jval_key = AS_JERRY_VALUE(key); jerry_value_t jval_val = AS_JERRY_VALUE(value); NAPI_TRY_TYPE(object, jval_object); NAPI_TRY_TYPE(string, jval_key); jerry_value_t ret = jerry_set_property(jval_object, jval_key, jval_val); if (jerry_value_is_error(ret)) { jerry_release_value(ret); NAPI_RETURN(napi_invalid_arg, NULL); } jerry_release_value(ret); NAPI_RETURN(napi_ok); }
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 (int argc, char **argv) { if (argc > JERRY_MAX_COMMAND_LINE_ARGS) { jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: too many command line arguments: %d (JERRY_MAX_COMMAND_LINE_ARGS=%d)\n", argc, JERRY_MAX_COMMAND_LINE_ARGS); return JERRY_STANDALONE_EXIT_CODE_FAIL; } const char *file_names[JERRY_MAX_COMMAND_LINE_ARGS]; int i; int files_counter = 0; size_t max_data_bss_size, max_stack_size; jerry_get_memory_limits (&max_data_bss_size, &max_stack_size); // FIXME: // jrt_set_mem_limits (max_data_bss_size, max_stack_size); jerry_init_flag_t flags = JERRY_INIT_EMPTY; const char *exec_snapshot_file_names[JERRY_MAX_COMMAND_LINE_ARGS]; int exec_snapshots_count = 0; bool is_parse_only = false; bool is_save_snapshot_mode = false; bool is_save_snapshot_mode_for_global_or_eval = false; const char *save_snapshot_file_name_p = NULL; bool is_repl_mode = false; for (i = 1; i < argc; i++) { if (!strcmp ("-h", argv[i]) || !strcmp ("--help", argv[i])) { print_help (argv[0]); return JERRY_STANDALONE_EXIT_CODE_OK; } else if (!strcmp ("-v", argv[i]) || !strcmp ("--version", argv[i])) { jerry_port_console ("Version: \t%d.%d\n\n", JERRY_API_MAJOR_VERSION, JERRY_API_MINOR_VERSION); return JERRY_STANDALONE_EXIT_CODE_OK; } else if (!strcmp ("--mem-stats", argv[i])) { flags |= JERRY_INIT_MEM_STATS; jerry_port_default_set_log_level (JERRY_LOG_LEVEL_DEBUG); } else if (!strcmp ("--mem-stats-separate", argv[i])) { flags |= JERRY_INIT_MEM_STATS_SEPARATE; jerry_port_default_set_log_level (JERRY_LOG_LEVEL_DEBUG); } else if (!strcmp ("--parse-only", argv[i])) { is_parse_only = true; } else if (!strcmp ("--show-opcodes", argv[i])) { flags |= JERRY_INIT_SHOW_OPCODES; jerry_port_default_set_log_level (JERRY_LOG_LEVEL_DEBUG); } else if (!strcmp ("--show-regexp-opcodes", argv[i])) { flags |= JERRY_INIT_SHOW_REGEXP_OPCODES; jerry_port_default_set_log_level (JERRY_LOG_LEVEL_DEBUG); } else if (!strcmp ("--save-snapshot-for-global", argv[i]) || !strcmp ("--save-snapshot-for-eval", argv[i])) { is_save_snapshot_mode = true; is_save_snapshot_mode_for_global_or_eval = !strcmp ("--save-snapshot-for-global", argv[i]); if (save_snapshot_file_name_p != NULL) { jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: snapshot file name already specified\n"); print_usage (argv[0]); return JERRY_STANDALONE_EXIT_CODE_FAIL; } if (++i >= argc) { jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: no file specified for %s\n", argv[i - 1]); print_usage (argv[0]); return JERRY_STANDALONE_EXIT_CODE_FAIL; } save_snapshot_file_name_p = argv[i]; } else if (!strcmp ("--exec-snapshot", argv[i])) { if (++i >= argc) { jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: no file specified for %s\n", argv[i - 1]); print_usage (argv[0]); return JERRY_STANDALONE_EXIT_CODE_FAIL; } assert (exec_snapshots_count < JERRY_MAX_COMMAND_LINE_ARGS); exec_snapshot_file_names[exec_snapshots_count++] = argv[i]; } else if (!strcmp ("--log-level", argv[i])) { if (++i >= argc) { jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: no level specified for %s\n", argv[i - 1]); print_usage (argv[0]); return JERRY_STANDALONE_EXIT_CODE_FAIL; } if (strlen (argv[i]) != 1 || argv[i][0] < '0' || argv[i][0] > '3') { jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: wrong format for %s\n", argv[i - 1]); print_usage (argv[0]); return JERRY_STANDALONE_EXIT_CODE_FAIL; } jerry_port_default_set_log_level (argv[i][0] - '0'); } else if (!strcmp ("--abort-on-fail", argv[i])) { jerry_port_default_set_abort_on_fail (true); } else if (!strncmp ("-", argv[i], 1)) { jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: unrecognized option: %s\n", argv[i]); print_usage (argv[0]); return JERRY_STANDALONE_EXIT_CODE_FAIL; } else { file_names[files_counter++] = argv[i]; } } if (is_save_snapshot_mode) { if (files_counter != 1) { jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: --save-snapshot argument works with exactly one script\n"); return JERRY_STANDALONE_EXIT_CODE_FAIL; } if (exec_snapshots_count != 0) { jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: --save-snapshot and --exec-snapshot options can't be passed simultaneously\n"); return JERRY_STANDALONE_EXIT_CODE_FAIL; } } if (files_counter == 0 && exec_snapshots_count == 0) { is_repl_mode = true; } jerry_init (flags); jerry_value_t global_obj_val = jerry_get_global_object (); jerry_value_t assert_value = jerry_create_external_function (assert_handler); jerry_value_t assert_func_name_val = jerry_create_string ((jerry_char_t *) "assert"); bool is_assert_added = jerry_set_property (global_obj_val, assert_func_name_val, assert_value); jerry_release_value (assert_func_name_val); jerry_release_value (assert_value); jerry_release_value (global_obj_val); if (!is_assert_added) { jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Warning: failed to register 'assert' method."); } jerry_value_t ret_value = jerry_create_undefined (); for (int i = 0; i < exec_snapshots_count; i++) { size_t snapshot_size; const uint8_t *snapshot_p = read_file (exec_snapshot_file_names[i], &snapshot_size); if (snapshot_p == NULL) { ret_value = jerry_create_error (JERRY_ERROR_COMMON, (jerry_char_t *) ""); } else { ret_value = jerry_exec_snapshot ((void *) snapshot_p, snapshot_size, true); } if (jerry_value_has_error_flag (ret_value)) { break; } } if (!jerry_value_has_error_flag (ret_value)) { for (int i = 0; i < files_counter; i++) { size_t source_size; const jerry_char_t *source_p = read_file (file_names[i], &source_size); if (source_p == NULL) { ret_value = jerry_create_error (JERRY_ERROR_COMMON, (jerry_char_t *) ""); } if (is_save_snapshot_mode) { static uint8_t snapshot_save_buffer[ JERRY_BUFFER_SIZE ]; size_t snapshot_size = jerry_parse_and_save_snapshot ((jerry_char_t *) source_p, source_size, is_save_snapshot_mode_for_global_or_eval, false, snapshot_save_buffer, JERRY_BUFFER_SIZE); if (snapshot_size == 0) { ret_value = jerry_create_error (JERRY_ERROR_COMMON, (jerry_char_t *) ""); } else { FILE *snapshot_file_p = fopen (save_snapshot_file_name_p, "w"); fwrite (snapshot_save_buffer, sizeof (uint8_t), snapshot_size, snapshot_file_p); fclose (snapshot_file_p); } } else { ret_value = jerry_parse (source_p, source_size, false); if (!jerry_value_has_error_flag (ret_value) && !is_parse_only) { 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; } } } if (is_repl_mode) { const char *prompt = "jerry> "; bool is_done = false; jerry_value_t global_obj_val = jerry_get_global_object (); jerry_value_t print_func_name_val = jerry_create_string ((jerry_char_t *) "print"); jerry_value_t print_function = jerry_get_property (global_obj_val, print_func_name_val); jerry_release_value (print_func_name_val); if (jerry_value_has_error_flag (print_function)) { return JERRY_STANDALONE_EXIT_CODE_FAIL; } if (!jerry_value_is_function (print_function)) { return JERRY_STANDALONE_EXIT_CODE_FAIL; } while (!is_done) { uint8_t *source_buffer_tail = buffer; size_t len = 0; jerry_port_console ("%s", prompt); /* Read a line */ while (true) { if (fread (source_buffer_tail, 1, 1, stdin) != 1 && len == 0) { is_done = true; break; } if (*source_buffer_tail == '\n') { break; } source_buffer_tail ++; len ++; } *source_buffer_tail = 0; if (len > 0) { /* Evaluate the line */ jerry_value_t ret_val_eval = jerry_eval (buffer, len, false); /* Print return value */ const jerry_value_t args[] = { ret_val_eval }; jerry_value_t ret_val_print = jerry_call_function (print_function, jerry_create_undefined (), args, 1); jerry_release_value (ret_val_print); jerry_release_value (ret_val_eval); } } jerry_release_value (global_obj_val); jerry_release_value (print_function); } int ret_code = JERRY_STANDALONE_EXIT_CODE_OK; if (jerry_value_has_error_flag (ret_value)) { jerry_value_clear_error_flag (&ret_value); jerry_value_t err_str_val = jerry_value_to_string (ret_value); jerry_char_t err_str_buf[256]; jerry_size_t err_str_size = jerry_get_string_size (err_str_val); assert (err_str_size < 256); 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: unhandled exception: %s\n", err_str_buf); jerry_release_value (err_str_val); ret_code = JERRY_STANDALONE_EXIT_CODE_FAIL; } jerry_release_value (ret_value); jerry_cleanup (); return ret_code; } /* main */
int main (void) { TEST_INIT (); jerry_init (JERRY_INIT_EMPTY); jerry_value_t global = jerry_get_global_object (); jerry_value_t callback_name = jerry_create_string ((jerry_char_t *) "callback"); jerry_value_t func = jerry_create_external_function (callback_func); jerry_value_t res = jerry_set_property (global, callback_name, func); TEST_ASSERT (!jerry_value_is_error (res)); jerry_release_value (res); jerry_release_value (func); jerry_release_value (callback_name); jerry_release_value (global); const char *inf_loop_code_src_p = ("while(true) {\n" " with ({}) {\n" " try {\n" " callback();\n" " } catch (e) {\n" " } finally {\n" " }\n" " }\n" "}"); jerry_value_t parsed_code_val = jerry_parse (NULL, 0, (jerry_char_t *) inf_loop_code_src_p, strlen (inf_loop_code_src_p), JERRY_PARSE_NO_OPTS); TEST_ASSERT (!jerry_value_is_error (parsed_code_val)); res = jerry_run (parsed_code_val); TEST_ASSERT (jerry_value_is_abort (res)); jerry_release_value (res); jerry_release_value (parsed_code_val); inf_loop_code_src_p = ("function f() {" " while(true) {\n" " with ({}) {\n" " try {\n" " callback();\n" " } catch (e) {\n" " } finally {\n" " }\n" " }\n" " }" "}\n" "function g() {\n" " for (a in { x:5 })\n" " f();\n" "}\n" "\n" "with({})\n" " f();\n"); parsed_code_val = jerry_parse (NULL, 0, (jerry_char_t *) inf_loop_code_src_p, strlen (inf_loop_code_src_p), JERRY_PARSE_NO_OPTS); TEST_ASSERT (!jerry_value_is_error (parsed_code_val)); res = jerry_run (parsed_code_val); TEST_ASSERT (jerry_value_is_abort (res)); jerry_release_value (res); jerry_release_value (parsed_code_val); /* Test flag overwrites. */ jerry_value_t value = jerry_create_string ((jerry_char_t *) "Error description"); TEST_ASSERT (!jerry_value_is_abort (value)); TEST_ASSERT (!jerry_value_is_error (value)); jerry_value_set_abort_flag (&value); TEST_ASSERT (jerry_value_is_abort (value)); TEST_ASSERT (jerry_value_is_error (value)); jerry_value_set_error_flag (&value); TEST_ASSERT (!jerry_value_is_abort (value)); TEST_ASSERT (jerry_value_is_error (value)); jerry_value_set_abort_flag (&value); TEST_ASSERT (jerry_value_is_abort (value)); TEST_ASSERT (jerry_value_is_error (value)); jerry_release_value (value); jerry_cleanup (); return 0; } /* main */