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 */
/**
* 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 int shell_cmd_handler (char *source_buffer)
{
jerry_value_t ret_val;
ret_val = jerry_eval ((jerry_char_t *) source_buffer,
strlen (source_buffer),
false);
if (jerry_value_has_error_flag (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. */
jerry_value_clear_error_flag (&ret_val);
}
if (!jerry_value_has_error_flag (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 */
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;
}
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 */
/**
* 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 */
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 */
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 */
iotjs_jval_t iotjs_jhelper_eval(const char* data, size_t size, bool strict_mode,
bool* throws) {
jerry_value_t res = jerry_eval((const jerry_char_t*)data, size, strict_mode);
*throws = jerry_value_has_error_flag(res);
jerry_value_clear_error_flag(&res);
return iotjs_jval_create_raw(res);
}
void iotjs_jval_set_property_by_index(const iotjs_jval_t* jarr, uint32_t idx,
const iotjs_jval_t* jval) {
const IOTJS_VALIDATED_STRUCT_METHOD(iotjs_jval_t, jarr);
IOTJS_ASSERT(iotjs_jval_is_object(jarr));
jerry_value_t value = iotjs_jval_as_raw(jval);
jerry_value_t ret_val = jerry_set_property_by_index(_this->value, idx, value);
IOTJS_ASSERT(!jerry_value_has_error_flag(ret_val));
jerry_release_value(ret_val);
}
iotjs_jval_t iotjs_jhelper_exec_snapshot(const void* snapshot_p,
size_t snapshot_size, bool* throws) {
jerry_value_t res = jerry_exec_snapshot(snapshot_p, snapshot_size, false);
/* the snapshot buffer can be referenced
* until jerry_cleanup is not called */
*throws = jerry_value_has_error_flag(res);
jerry_value_clear_error_flag(&res);
return iotjs_jval_create_raw(res);
}
int
main (int argc, char **argv)
{
(void) argc;
(void) argv;
jerry_char_t buffer[256];
jerry_size_t bytes_copied;
const jerryx_module_resolver_t *resolver = &jerryx_module_native_resolver;
jerry_value_t module_name;
jerry_init (JERRY_INIT_EMPTY);
/* Attempt to load a non-existing module. */
module_name = jerry_create_string ((jerry_char_t *) "some-unknown-module-name");
jerry_value_t module = jerryx_module_resolve (module_name, &resolver, 1);
jerry_release_value (module_name);
TEST_ASSERT (jerry_value_has_error_flag (module));
/* Retrieve the error message. */
jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "message");
jerry_value_t prop = jerry_get_property (module, prop_name);
/* Assert that the error message is a string with specific contents. */
TEST_ASSERT (jerry_value_is_string (prop));
bytes_copied = jerry_substring_to_utf8_char_buffer (prop, 0, 254, buffer, 256);
buffer[bytes_copied] = 0;
TEST_ASSERT (!strcmp ((const char *) buffer, "Module not found"));
/* Release the error message property name and value. */
jerry_release_value (prop);
jerry_release_value (prop_name);
/* Retrieve the moduleName property. */
prop_name = jerry_create_string ((const jerry_char_t *) "moduleName");
prop = jerry_get_property (module, prop_name);
/* Assert that the moduleName property is a string containing the requested module name. */
TEST_ASSERT (jerry_value_is_string (prop));
bytes_copied = jerry_substring_to_utf8_char_buffer (prop, 0, 254, buffer, 256);
buffer[bytes_copied] = 0;
TEST_ASSERT (!strcmp ((const char *) buffer, "some-unknown-module-name"));
/* Release everything. */
jerry_release_value (prop);
jerry_release_value (prop_name);
jerry_release_value (module);
return 0;
} /* main */
/**
* Register a JavaScript function in the global object.
*/
static void
register_js_function (const char *name_p, /**< name of the function */
jerry_external_handler_t handler_p) /**< function callback */
{
jerry_value_t result_val = jerryx_handler_register_global ((const jerry_char_t *) name_p, handler_p);
if (jerry_value_has_error_flag (result_val))
{
jerry_port_log (JERRY_LOG_LEVEL_WARNING, "Warning: failed to register '%s' method.", name_p);
}
jerry_release_value (result_val);
} /* register_js_function */
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);
}
/*
* args_p[0-2] are uint8, args_p[3-5] are int8, args_p[6-8] are uint32, args_p[9-11] are int32.
*/
static jerry_value_t
test_validator_int1_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 */
{
uint8_t num0, num1, num2;
int8_t num3, num4, num5;
uint32_t num6, num7, num8;
int32_t num9, num10, num11;
jerryx_arg_t mapping[] =
{
jerryx_arg_uint8 (&num0, JERRYX_ARG_ROUND, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_uint8 (&num1, JERRYX_ARG_ROUND, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_uint8 (&num2, JERRYX_ARG_ROUND, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_int8 (&num3, JERRYX_ARG_ROUND, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_int8 (&num4, JERRYX_ARG_ROUND, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_int8 (&num5, JERRYX_ARG_ROUND, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_uint32 (&num6, JERRYX_ARG_ROUND, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_uint32 (&num7, JERRYX_ARG_ROUND, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_uint32 (&num8, JERRYX_ARG_ROUND, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_int32 (&num9, JERRYX_ARG_ROUND, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_int32 (&num10, JERRYX_ARG_ROUND, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_int32 (&num11, 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));
TEST_ASSERT (num0 == 0);
TEST_ASSERT (num1 == 255);
TEST_ASSERT (num2 == 128);
TEST_ASSERT (num3 == -128);
TEST_ASSERT (num4 == 127);
TEST_ASSERT (num5 == -127);
TEST_ASSERT (num6 == 0);
TEST_ASSERT (num7 == 4294967295);
TEST_ASSERT (num8 == 65536);
TEST_ASSERT (num9 == -2147483648);
TEST_ASSERT (num10 == 2147483647);
TEST_ASSERT (num11 == -2147483647);
jerry_release_value (is_ok);
validator_int_count++;
return jerry_create_undefined ();
} /* test_validator_int1_handler */
/**
* The handler should have following arguments:
* this: with native pointer whose type is bind_a_info.
* arg1: should pass the custom tranform function.
*/
static jerry_value_t
test_validator2_handler (const jerry_value_t func_obj_val __attribute__((unused)), /**< 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 */
{
my_type_a_t *thing_p;
jerryx_arg_t mapping[] =
{
/* this should has native pointer, whose type is thing_a_info */
jerryx_arg_native_pointer ((void **) &thing_p, &thing_a_info, JERRYX_ARG_REQUIRED),
/* custom tranform function */
jerryx_arg_custom (NULL, 5, my_custom_transform)
};
jerry_value_t is_ok = jerryx_arg_transform_this_and_args (this_val,
args_p,
args_cnt,
mapping,
ARRAY_SIZE (mapping));
if (validator2_count == 0)
{
TEST_ASSERT (!jerry_value_has_error_flag (is_ok));
TEST_ASSERT (thing_p == &my_thing_a);
TEST_ASSERT (thing_p->x == 1);
}
else
{
TEST_ASSERT (jerry_value_has_error_flag (is_ok));
}
jerry_release_value (is_ok);
validator2_count++;
return jerry_create_undefined ();
} /* test_validator2_handler */
iotjs_jval_t iotjs_jval_get_property_by_index(const iotjs_jval_t* jarr,
uint32_t idx) {
const IOTJS_VALIDATED_STRUCT_METHOD(iotjs_jval_t, jarr);
IOTJS_ASSERT(iotjs_jval_is_object(jarr));
jerry_value_t res = jerry_get_property_by_index(_this->value, idx);
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);
}
void jerry_resolve_error (jerry_value_t ret_value)
{
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_size_t err_str_size = jerry_get_string_size (err_str_val);
jerry_char_t *err_str_buf = (jerry_char_t *) balloc (err_str_size, NULL);
jerry_size_t sz = jerry_string_to_char_buffer (err_str_val, err_str_buf, err_str_size);
err_str_buf[sz] = 0;
printk ("Script Error: unhandled exception: %s\n", err_str_buf);
bfree(err_str_buf);
jerry_release_value (err_str_val);
}
}
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);
}
/**
* Jerryscript simple test loop
*/
int jerryscript_test ()
{
jerry_value_t ret_val;
const char script[] =
"var test=0; " \
"for (var t=100; t<1000; t++) test+=t; " \
"print ('Hi JS World! '+test);";
printf ("Script [%s]\n", script);
ret_val = jerry_eval ((jerry_char_t *) script,
strlen (script),
false);
return jerry_value_has_error_flag (ret_val) ? -1 : 0;
} /* jerryscript_test */
/**
* Calling jerryx_arg_transform_object_properties indirectly by
* using jerryx_arg_object_properties.
*/
static jerry_value_t
test_validator_prop2_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 */
{
bool native1 = false;
double native2 = 0;
double native3 = 3;
jerryx_arg_object_props_t prop_info;
const char *name_p[] = { "prop1", "prop2", "prop3" };
jerryx_arg_t prop_mapping[] =
{
jerryx_arg_boolean (&native1, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_number (&native2, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_number (&native3, JERRYX_ARG_COERCE, JERRYX_ARG_OPTIONAL)
};
prop_info.name_p = (const jerry_char_t **) name_p;
prop_info.name_cnt = 3;
prop_info.c_arg_p = prop_mapping;
prop_info.c_arg_cnt = 3;
jerryx_arg_t mapping[] =
{
jerryx_arg_object_properties (&prop_info, JERRYX_ARG_OPTIONAL),
};
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));
if (validator_prop_count == 1)
{
TEST_ASSERT (native1);
TEST_ASSERT (native2 == 1.5);
TEST_ASSERT (native3 == 3);
}
validator_prop_count++;
return jerry_create_undefined ();
} /* test_validator_prop2_handler */
static jerry_value_t
test_validator_int2_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, num1, num2, num3, num4, num5, num6, num7, num8, num9;
num8 = 123;
num9 = 123;
jerryx_arg_t mapping[] =
{
jerryx_arg_int8 (&num0, JERRYX_ARG_ROUND, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_int8 (&num1, JERRYX_ARG_FLOOR, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_int8 (&num2, JERRYX_ARG_CEIL, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_int8 (&num3, JERRYX_ARG_ROUND, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_int8 (&num4, JERRYX_ARG_FLOOR, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_int8 (&num5, JERRYX_ARG_CEIL, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_int8 (&num6, JERRYX_ARG_ROUND, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_int8 (&num7, JERRYX_ARG_ROUND, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_int8 (&num8, JERRYX_ARG_ROUND, JERRYX_ARG_CLAMP, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_int8 (&num9, JERRYX_ARG_ROUND, JERRYX_ARG_NO_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));
TEST_ASSERT (num0 == -2);
TEST_ASSERT (num1 == -2);
TEST_ASSERT (num2 == -1);
TEST_ASSERT (num3 == 2);
TEST_ASSERT (num4 == 1);
TEST_ASSERT (num5 == 2);
TEST_ASSERT (num6 == 127);
TEST_ASSERT (num7 == -128);
TEST_ASSERT (num8 == 127);
TEST_ASSERT (num9 == 123);
jerry_release_value (is_ok);
validator_int_count++;
return jerry_create_undefined ();
} /* test_validator_int2_handler */
static jerry_value_t
test_validator_array1_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 */
{
double native1 = 0;
double native2 = 0;
double native3 = 0;
jerryx_arg_array_items_t arr_info;
jerryx_arg_t item_mapping[] =
{
jerryx_arg_number (&native1, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_number (&native2, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED),
jerryx_arg_number (&native3, JERRYX_ARG_COERCE, JERRYX_ARG_OPTIONAL)
};
arr_info.c_arg_p = item_mapping;
arr_info.c_arg_cnt = 3;
jerryx_arg_t mapping[] =
{
jerryx_arg_array (&arr_info, JERRYX_ARG_OPTIONAL),
};
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));
if (validator_array_count == 0)
{
TEST_ASSERT (native1 == 1);
TEST_ASSERT (native2 == 2);
TEST_ASSERT (native3 == 0);
}
validator_array_count++;
return jerry_create_undefined ();
} /* test_validator_array1_handler */
void main (void)
{
printf ("Jerry Compilation " __DATE__ " " __TIME__ "\n");
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);
if (jerry_value_has_error_flag (print_function))
{
printf ("Error: could not look up print function, expression results won't be printed\n");
}
shell_register_app_cmd_handler (shell_cmd_handler);
shell_init ("js> ", commands);
/* Don't call jerry_cleanup() here, as shell_init() returns after setting
up background task to process shell input, and that task calls
shell_cmd_handler(), etc. as callbacks. This processing happens in
the infinite loop, so JerryScript doesn't need to be de-initialized. */
} /* main */
/**
* Check whether an error is a SyntaxError or not
*
* @return true - if param is SyntaxError
* false - otherwise
*/
static bool
jerry_value_is_syntax_error (jerry_value_t error_value) /**< error value */
{
assert (jerry_is_feature_enabled (JERRY_FEATURE_ERROR_MESSAGES));
if (!jerry_value_is_object (error_value))
{
return false;
}
jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *)"name");
jerry_value_t error_name = jerry_get_property (error_value, prop_name);
jerry_release_value (prop_name);
if (jerry_value_has_error_flag (error_name)
|| !jerry_value_is_string (error_name))
{
return false;
}
jerry_size_t err_str_size = jerry_get_string_size (error_name);
jerry_char_t err_str_buf[err_str_size];
jerry_size_t sz = jerry_string_to_char_buffer (error_name, err_str_buf, err_str_size);
jerry_release_value (error_name);
if (sz == 0)
{
return false;
}
if (!strcmp ((char *) err_str_buf, "SyntaxError"))
{
return true;
}
return false;
} /* jerry_value_is_syntax_error */
void main (void)
{
uint32_t zephyr_ver = sys_kernel_version_get ();
printf ("JerryScript build: " __DATE__ " " __TIME__ "\n");
printf ("JerryScript API %d.%d\n", JERRY_API_MAJOR_VERSION, JERRY_API_MINOR_VERSION);
printf ("Zephyr version %d.%d.%d\n", (int)SYS_KERNEL_VER_MAJOR (zephyr_ver),
(int)SYS_KERNEL_VER_MINOR (zephyr_ver),
(int)SYS_KERNEL_VER_PATCHLEVEL (zephyr_ver));
zephyr_getline_init ();
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);
if (jerry_value_has_error_flag (print_function))
{
printf ("Error: could not look up print function, expression results won't be printed\n");
}
while (1)
{
char *s;
printf("js> ");
fflush(stdout);
s = zephyr_getline ();
if (*s)
{
shell_cmd_handler (s);
}
}
/* As we never retturn from REPL above, don't call jerry_cleanup() here. */
} /* main */
iotjs_jval_t iotjs_jhelper_call(const iotjs_jval_t* jfunc,
const iotjs_jval_t* jthis,
const iotjs_jargs_t* jargs, bool* throws) {
IOTJS_ASSERT(iotjs_jval_is_object(jfunc));
jerry_value_t* jargv_ = NULL;
jerry_length_t jargc_ = iotjs_jargs_length(jargs);
#ifdef NDEBUG
jargv_ = (jerry_value_t*)jargs->unsafe.argv;
#else
if (jargc_ > 0) {
unsigned buffer_size = sizeof(iotjs_jval_t) * jargc_;
jargv_ = (jerry_value_t*)iotjs_buffer_allocate(buffer_size);
for (unsigned i = 0; i < jargc_; ++i) {
jargv_[i] = iotjs_jval_as_raw(iotjs_jargs_get(jargs, i));
}
}
#endif
jerry_value_t jfunc_ = iotjs_jval_as_raw(jfunc);
jerry_value_t jthis_ = iotjs_jval_as_raw(jthis);
jerry_value_t res = jerry_call_function(jfunc_, jthis_, jargv_, jargc_);
#ifndef NDEBUG
if (jargv_) {
iotjs_buffer_release((char*)jargv_);
}
#endif
*throws = jerry_value_has_error_flag(res);
jerry_value_clear_error_flag(&res);
return iotjs_jval_create_raw(res);
}
/**
* Provide a 'print' implementation for scripts.
*
* The routine converts all of its arguments to strings and outputs them
* char-by-char using jerryx_port_handler_print_char.
*
* The NUL character is output as "\u0000", other characters are output
* bytewise.
*
* Note:
* This implementation does not use standard C `printf` to print its
* output. This allows more flexibility but also extends the core
* JerryScript engine port API. Applications that want to use
* `jerryx_handler_print` must ensure that their port implementation also
* provides `jerryx_port_handler_print_char`.
*
* @return undefined - if all arguments could be converted to strings,
* error - otherwise.
*/
jerry_value_t
jerryx_handler_print (const jerry_value_t func_obj_val, /**< function object */
const jerry_value_t this_p, /**< this arg */
const jerry_value_t args_p[], /**< function arguments */
const jerry_length_t args_cnt) /**< number of function arguments */
{
(void) func_obj_val; /* unused */
(void) this_p; /* unused */
static const char *null_str = "\\u0000";
jerry_value_t ret_val = jerry_create_undefined ();
for (jerry_length_t arg_index = 0;
jerry_value_is_undefined (ret_val) && arg_index < args_cnt;
arg_index++)
{
jerry_value_t str_val = jerry_value_to_string (args_p[arg_index]);
if (!jerry_value_has_error_flag (str_val))
{
if (arg_index != 0)
{
jerryx_port_handler_print_char (' ');
}
jerry_size_t substr_size;
jerry_length_t substr_pos = 0;
jerry_char_t substr_buf[256];
while ((substr_size = jerry_substring_to_char_buffer (str_val,
substr_pos,
substr_pos + 256,
substr_buf,
256)) != 0)
{
#ifdef JERRY_DEBUGGER
jerry_debugger_send_output (substr_buf, substr_size, JERRY_DEBUGGER_OUTPUT_OK);
#endif /* JERRY_DEBUGGER */
for (jerry_size_t chr_index = 0; chr_index < substr_size; chr_index++)
{
char chr = (char) substr_buf[chr_index];
if (chr == '\0')
{
for (jerry_size_t null_index = 0; null_str[null_index] != 0; null_index++)
{
jerryx_port_handler_print_char (null_str[null_index]);
}
}
else
{
jerryx_port_handler_print_char (chr);
}
}
substr_pos += substr_size;
}
jerry_release_value (str_val);
}
else
{
ret_val = str_val;
}
}
jerryx_port_handler_print_char ('\n');
return ret_val;
} /* jerryx_handler_print */
static int shell_cmd_handler (int argc, char *argv[])
{
if (argc <= 0)
{
return -1;
}
unsigned int size = 0;
for (int t = 0; t < argc; t++)
{
size += strlen (argv[t]) + 1;
}
source_buffer = (char *) malloc (size);
char *d = source_buffer;
unsigned int len;
for (int t = 0; t < argc; t++)
{
len = strlen (argv[t]);
memcpy (d, argv[t], len);
d += len;
*d = ' ';
d++;
}
* (d - 1) = '\0';
if (flags & VERBOSE)
{
printf ("[%s] %lu\n", source_buffer, strlen (source_buffer));
}
jerry_value_t ret_val;
ret_val = jerry_eval ((jerry_char_t *) source_buffer,
strlen (source_buffer),
false);
free (source_buffer);
if (jerry_value_has_error_flag (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. */
jerry_value_clear_error_flag (&ret_val);
}
if (!jerry_value_has_error_flag (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 */
