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;
}
