// A client socket wants to connect to this server. // Parameters: // * uv_stream_t* handle - server handle // * int status - status code static void OnConnection(uv_stream_t* handle, int status) { // Server tcp wrapper. iotjs_tcpwrap_t* tcp_wrap = iotjs_tcpwrap_from_handle((uv_tcp_t*)handle); // Tcp object jerry_value_t jtcp = iotjs_tcpwrap_jobject(tcp_wrap); // `onconnection` callback. jerry_value_t jonconnection = iotjs_jval_get_property(jtcp, IOTJS_MAGIC_STRING_ONCONNECTION); IOTJS_ASSERT(jerry_value_is_function(jonconnection)); // The callback takes two parameter // [0] status // [1] client tcp object iotjs_jargs_t args = iotjs_jargs_create(2); iotjs_jargs_append_number(&args, status); if (status == 0) { // Create client socket handle wrapper. jerry_value_t jcreate_tcp = iotjs_jval_get_property(jtcp, IOTJS_MAGIC_STRING_CREATETCP); IOTJS_ASSERT(jerry_value_is_function(jcreate_tcp)); jerry_value_t jclient_tcp = iotjs_jhelper_call_ok(jcreate_tcp, jerry_create_undefined(), iotjs_jargs_get_empty()); IOTJS_ASSERT(jerry_value_is_object(jclient_tcp)); iotjs_tcpwrap_t* tcp_wrap_client = (iotjs_tcpwrap_t*)(iotjs_jval_get_object_native_handle(jclient_tcp)); uv_stream_t* client_handle = (uv_stream_t*)(iotjs_tcpwrap_tcp_handle(tcp_wrap_client)); int err = uv_accept(handle, client_handle); if (err) { iotjs_jargs_destroy(&args); return; } iotjs_jargs_append_jval(&args, jclient_tcp); jerry_release_value(jcreate_tcp); jerry_release_value(jclient_tcp); } iotjs_make_callback(jonconnection, jtcp, &args); jerry_release_value(jonconnection); iotjs_jargs_destroy(&args); }
static bool bridge_native_call(const char* module_name, const char* func_name, const char* message, iotjs_string_t* output_str) { bool result = false; jerry_value_t jmodule = iotjs_module_get(module_name); jerry_value_t jfunc = iotjs_jval_get_property(jmodule, func_name); if (jerry_value_is_function(jfunc) == false) { return result; } jerry_value_t jval = jerry_create_string((const jerry_char_t*)message); jerry_value_t jres = iotjs_invoke_callback_with_result(jfunc, jmodule, &jval, 1); if (jerry_value_is_string(jres)) { IOTJS_ASSERT(output_str != NULL); *output_str = iotjs_jval_as_string(jres); result = true; } jerry_release_value(jfunc); jerry_release_value(jres); jerry_release_value(jval); return result; }
static void gpio_emit_change_event(iotjs_gpio_t* gpio) { IOTJS_VALIDATED_STRUCT_METHOD(iotjs_gpio_t, gpio); jerry_value_t jgpio = _this->jobject; jerry_value_t jonChange = iotjs_jval_get_property(jgpio, "onChange"); IOTJS_ASSERT(jerry_value_is_function(jonChange)); iotjs_jhelper_call_ok(jonChange, jgpio, iotjs_jargs_get_empty()); jerry_release_value(jonChange); }
static void AfterAsync(uv_fs_t* req) { const jerry_value_t cb = *IOTJS_UV_REQUEST_JSCALLBACK(req); IOTJS_ASSERT(jerry_value_is_function(cb)); jerry_value_t jargs[2] = { 0 }; size_t jargc = 0; if (req->result < 0) { jerry_value_t jerror = iotjs_create_uv_exception(req->result, "open"); jargs[jargc++] = jerror; } else { jargs[jargc++] = jerry_create_null(); switch (req->fs_type) { case UV_FS_CLOSE: { break; } case UV_FS_OPEN: case UV_FS_READ: case UV_FS_WRITE: { jargs[jargc++] = jerry_create_number((double)req->result); break; } case UV_FS_SCANDIR: { int r; uv_dirent_t ent; uint32_t idx = 0; jargs[jargc++] = jerry_create_array(0); while ((r = uv_fs_scandir_next(req, &ent)) != UV_EOF) { jerry_value_t name = jerry_create_string((const jerry_char_t*)ent.name); iotjs_jval_set_property_by_index(jargs[1], idx, name); jerry_release_value(name); idx++; } break; } case UV_FS_FSTAT: case UV_FS_STAT: { uv_stat_t s = (req->statbuf); jargs[jargc++] = MakeStatObject(&s); break; } default: { break; } } } iotjs_invoke_callback(cb, jerry_create_undefined(), jargs, jargc); jerry_release_value(jargs[0]); jerry_release_value(jargs[1]); uv_fs_req_cleanup(req); iotjs_uv_request_destroy((uv_req_t*)req); }
void OnRead(uv_stream_t* handle, ssize_t nread, const uv_buf_t* buf) { iotjs_tcpwrap_t* tcp_wrap = iotjs_tcpwrap_from_handle((uv_tcp_t*)handle); // tcp handle jerry_value_t jtcp = iotjs_tcpwrap_jobject(tcp_wrap); // socket object jerry_value_t jsocket = iotjs_jval_get_property(jtcp, IOTJS_MAGIC_STRING_OWNER); IOTJS_ASSERT(jerry_value_is_object(jsocket)); // onread callback jerry_value_t jonread = iotjs_jval_get_property(jtcp, IOTJS_MAGIC_STRING_ONREAD); IOTJS_ASSERT(jerry_value_is_function(jonread)); iotjs_jargs_t jargs = iotjs_jargs_create(4); iotjs_jargs_append_jval(&jargs, jsocket); iotjs_jargs_append_number(&jargs, nread); iotjs_jargs_append_bool(&jargs, false); if (nread <= 0) { if (buf->base != NULL) { iotjs_buffer_release(buf->base); } if (nread < 0) { if (nread == UV__EOF) { iotjs_jargs_replace(&jargs, 2, jerry_create_boolean(true)); } iotjs_make_callback(jonread, jerry_create_undefined(), &jargs); } } else { jerry_value_t jbuffer = iotjs_bufferwrap_create_buffer((size_t)nread); iotjs_bufferwrap_t* buffer_wrap = iotjs_bufferwrap_from_jbuffer(jbuffer); iotjs_bufferwrap_copy(buffer_wrap, buf->base, (size_t)nread); iotjs_jargs_append_jval(&jargs, jbuffer); iotjs_make_callback(jonread, jerry_create_undefined(), &jargs); jerry_release_value(jbuffer); iotjs_buffer_release(buf->base); } iotjs_jargs_destroy(&jargs); jerry_release_value(jonread); jerry_release_value(jsocket); }
// Socket close result handler. void AfterClose(uv_handle_t* handle) { iotjs_handlewrap_t* wrap = iotjs_handlewrap_from_handle(handle); // tcp object. jerry_value_t jtcp = iotjs_handlewrap_jobject(wrap); // callback function. jerry_value_t jcallback = iotjs_jval_get_property(jtcp, IOTJS_MAGIC_STRING_ONCLOSE); if (jerry_value_is_function(jcallback)) { iotjs_make_callback(jcallback, jerry_create_undefined(), iotjs_jargs_get_empty()); } jerry_release_value(jcallback); }
void iotjs_tizen_app_control_cb(app_control_h app_control, void* user_data) { DDDLOG("%s", __func__); iotjs_environment_t* env = iotjs_environment_get(); if (env->state != kRunningMain && env->state != kRunningLoop) { return; } const char* event_emitter_name = IOTJS_MAGIC_STRING_TIZEN; const char* event_name = IOTJS_MAGIC_STRING_APP_CONTROL; jerry_value_t tizen = iotjs_module_get(event_emitter_name); jerry_value_t fn = iotjs_jval_get_property(tizen, IOTJS_MAGIC_STRING_EMIT); if (jerry_value_is_function(fn) == false) { DDDLOG("tizen module is not loaded"); goto exit; } // parse app control char* json = NULL; bundle* b = NULL; app_control_export_as_bundle(app_control, &b); if (BUNDLE_ERROR_NONE != bundle_to_json(b, &json)) { DDLOG("bundle_to_json failed"); bundle_free(b); return; } DDDLOG("JSON: %s", json); // call emit jerry_value_t jargv[2] = { jerry_create_string( (const jerry_char_t*)event_name), jerry_create_string((const jerry_char_t*)json) }; iotjs_invoke_callback(fn, tizen, jargv, 2); jerry_release_value(jargv[0]); jerry_release_value(jargv[1]); free(json); bundle_free(b); exit: jerry_release_value(fn); }
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 void AfterShutdown(uv_shutdown_t* req, int status) { iotjs_shutdown_reqwrap_t* req_wrap = (iotjs_shutdown_reqwrap_t*)(req->data); iotjs_tcpwrap_t* tcp_wrap = (iotjs_tcpwrap_t*)(req->handle->data); IOTJS_ASSERT(req_wrap != NULL); IOTJS_ASSERT(tcp_wrap != NULL); // function onShutdown(status) jerry_value_t jonshutdown = iotjs_shutdown_reqwrap_jcallback(req_wrap); IOTJS_ASSERT(jerry_value_is_function(jonshutdown)); iotjs_jargs_t args = iotjs_jargs_create(1); iotjs_jargs_append_number(&args, status); iotjs_make_callback(jonshutdown, jerry_create_undefined(), &args); iotjs_jargs_destroy(&args); iotjs_shutdown_reqwrap_dispatched(req_wrap); }
// Connection request result handler. static void AfterConnect(uv_connect_t* req, int status) { iotjs_connect_reqwrap_t* req_wrap = (iotjs_connect_reqwrap_t*)(req->data); IOTJS_ASSERT(req_wrap != NULL); // Take callback function object. // function afterConnect(status) jerry_value_t jcallback = iotjs_connect_reqwrap_jcallback(req_wrap); IOTJS_ASSERT(jerry_value_is_function(jcallback)); // Only parameter is status code. iotjs_jargs_t args = iotjs_jargs_create(1); iotjs_jargs_append_number(&args, status); // Make callback. iotjs_make_callback(jcallback, jerry_create_undefined(), &args); // Destroy args iotjs_jargs_destroy(&args); // Release request wrapper. iotjs_connect_reqwrap_dispatched(req_wrap); }
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 */
/** * The handler should have following arguments: * this: Ignore. * arg1: Bool. * arg2: Number. It must be strict primitive number. * arg3: String. * arg4: function. It is an optional argument. * */ static jerry_value_t test_validator1_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 */ { bool arg1; double arg2 = 0.0; char arg3[5] = "1234"; jerry_value_t arg4 = jerry_create_undefined (); jerryx_arg_t mapping[] = { /* ignore this */ jerryx_arg_ignore (), /* 1st argument should be boolean */ jerryx_arg_boolean (&arg1, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED), /* 2nd argument should be strict number */ jerryx_arg_number (&arg2, JERRYX_ARG_NO_COERCE, JERRYX_ARG_REQUIRED), /* 3th argument should be string */ jerryx_arg_string (arg3, 5, JERRYX_ARG_COERCE, JERRYX_ARG_REQUIRED), /* 4th argument should be function, and it is optional */ jerryx_arg_function (&arg4, JERRYX_ARG_OPTIONAL) }; jerry_value_t is_ok = jerryx_arg_transform_this_and_args (this_val, args_p, args_cnt, mapping, ARRAY_SIZE (mapping)); if (validator1_count == 0) { TEST_ASSERT (!jerry_value_has_error_flag (is_ok)); TEST_ASSERT (arg1); TEST_ASSERT (arg2 == 10.5); TEST_ASSERT (strcmp (arg3, "abc") == 0); TEST_ASSERT (jerry_value_is_function (arg4)); } else if (validator1_count == 1) { TEST_ASSERT (!jerry_value_has_error_flag (is_ok)); TEST_ASSERT (arg1); TEST_ASSERT (arg2 == 10.5); TEST_ASSERT (strcmp (arg3, "abc") == 0); TEST_ASSERT (jerry_value_is_undefined (arg4)); } else if (validator1_count == 2) { TEST_ASSERT (!jerry_value_has_error_flag (is_ok)); TEST_ASSERT (arg1); TEST_ASSERT (arg2 == 10.5); TEST_ASSERT (strcmp (arg3, "") == 0); TEST_ASSERT (jerry_value_is_undefined (arg4)); } else { TEST_ASSERT (jerry_value_has_error_flag (is_ok)); } jerry_release_value (is_ok); jerry_release_value (arg4); validator1_count++; return jerry_create_undefined (); } /* test_validator1_handler */
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 */
static void AfterAsync(uv_fs_t* req) { iotjs_fs_reqwrap_t* req_wrap = (iotjs_fs_reqwrap_t*)(req->data); IOTJS_ASSERT(req_wrap != NULL); IOTJS_ASSERT(&req_wrap->req == req); const jerry_value_t cb = iotjs_reqwrap_jcallback(&req_wrap->reqwrap); IOTJS_ASSERT(jerry_value_is_function(cb)); iotjs_jargs_t jarg = iotjs_jargs_create(2); if (req->result < 0) { jerry_value_t jerror = iotjs_create_uv_exception(req->result, "open"); iotjs_jargs_append_jval(&jarg, jerror); jerry_release_value(jerror); } else { iotjs_jargs_append_null(&jarg); switch (req->fs_type) { case UV_FS_CLOSE: { break; } case UV_FS_OPEN: case UV_FS_READ: case UV_FS_WRITE: { iotjs_jargs_append_number(&jarg, (double)req->result); break; } case UV_FS_SCANDIR: { int r; uv_dirent_t ent; uint32_t idx = 0; jerry_value_t ret = jerry_create_array(0); while ((r = uv_fs_scandir_next(req, &ent)) != UV_EOF) { jerry_value_t name = jerry_create_string((const jerry_char_t*)ent.name); iotjs_jval_set_property_by_index(ret, idx, name); jerry_release_value(name); idx++; } iotjs_jargs_append_jval(&jarg, ret); jerry_release_value(ret); break; } case UV_FS_FSTAT: case UV_FS_STAT: { uv_stat_t s = (req->statbuf); jerry_value_t ret = MakeStatObject(&s); iotjs_jargs_append_jval(&jarg, ret); jerry_release_value(ret); break; } default: { iotjs_jargs_append_null(&jarg); break; } } } iotjs_make_callback(cb, jerry_create_undefined(), &jarg); iotjs_jargs_destroy(&jarg); iotjs_fs_reqwrap_destroy(req_wrap); }