archive-gh-me/jerryscript
1
0
Fork 0
mirror of https://github.com/jerryscript-project/jerryscript.git synced 2025-12-15 16:29:21 +00:00
Code Issues Projects Releases Wiki Activity

Rework the public API (#4829)

Browse Source 
Related to #4186.

Some notable changes:
  - The term 'Error' now strictly refers to native Error objects defined in
    the ECMA standard, which are ordinary objects. All other uses of
    'error' or 'error reference' where the term refers to a thrown value is
    now called 'exception'.

  - Simplified the naming scheme of many String API functions. These functions
    will now also take an 'encoding' argument to specify the desired
    encoding in which to operate.

  - Removed the substring-copy-to-buffer functions. These functions
    behaved awkwardly, as they use character index to specify the
    start/end positions, and were mostly used incorrectly with byte
    offsets instead. The functionality can still be replicated with
    other functions if necessary.

  - String-to-buffer functions will no longer fail if the buffer is not
    sufficiently large, the string will instead be cropped.

  - Fixed the usage of the '_sz' prefix in many API functions. The term
    'sz' means zero-terminated string in hungarian notation, this was
    used incorrectly in many cases.

  - Renamed most of the public API functions to have shorter, more on-point
    names, rather than the often too long descriptive names. Functions are now
    also grouped by the type of value they operate on, where this makes
    sense.

JerryScript-DCO-1.0-Signed-off-by: Dániel Bátyai dbatyai@inf.u-szeged.hu
This commit is contained in:
Dániel Bátyai 2021-12-06 10:20:09 +01:00 committed by GitHub
parent 81d2319144
commit 9860d66a56
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
180 changed files with 10738 additions and 11025 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
docs/01.CONFIGURATION.md
View File

@ -190,7 +190,7 @@ This option is enabled by default.
### Memory statistics
This option can be used to provide memory usage statistics either upon engine termination, or during runtime using the `jerry_get_memory_stats` jerry API function.
This option can be used to provide memory usage statistics either upon engine termination, or during runtime using the `jerry_heap_stats` jerry API function.
The feature can create a significant performance overhead, and should only be used for measurement purposes. This option is disabled by default.
| Options | |

4947
docs/02.API-REFERENCE.md
View File

File diff suppressed because it is too large Load Diff

263
docs/03.API-EXAMPLE.md
View File

@ -35,47 +35,14 @@ Test if the `pkg-config` works for JerryScript:
$ pkg-config --cflags --libs libjerry-core libjerry-port-default libjerry-ext libjerry-math
```
## Example 1. Execute JavaScript from your application
The most basic example to test the engine is to create an `api-example-1.c` file containing the following code:
[doctest]: # ()
```c
#include "jerryscript.h"
int
main (void)
{
const jerry_char_t script[] = "var str = 'Hello, World!';";
bool ret_value = jerry_run_simple (script, sizeof (script) - 1, JERRY_INIT_EMPTY);
return (ret_value ? 0 : 1);
}
```
To compile it one can use the following command:
```sh
$ gcc api-example-1.c -o api-example-1 $(pkg-config --cflags --libs libjerry-core libjerry-port-default libjerry-math)
```
If everything is correct the application returns with a zero exit code:
```
$ ./api-example-1
$ echo $?
```
## Example 2. Split engine initialization and script execution.
In this example the engine is initialized directly with the `jerry_init` method
and cleaned up with the `jerry_cleanup` method. The example JavaScript code
is directly parsed and executed via the `jerry_eval` method. Each `jerry_value_t`
returned by the API methods is freed with the `jerry_release_value` method.
returned by the API methods is freed with the `jerry_value_free` method.
To make sure that the code parsing and execution was ok, the `jerry_value_is_error`
To make sure that the code parsing and execution was ok, the `jerry_value_is_exception`
method is used to check for any errors.
Use the following code for the `api-example-2.c` file:
@ -103,10 +70,10 @@ main (void)
JERRY_PARSE_NO_OPTS);
/* Check if there was any error (syntax or runtime) */
bool run_ok = !jerry_value_is_error (eval_ret);
bool run_ok = !jerry_value_is_exception (eval_ret);
/* Parsed source code must be freed */
jerry_release_value (eval_ret);
jerry_value_free (eval_ret);
/* Cleanup engine */
jerry_cleanup ();
@ -156,20 +123,20 @@ main (void)
jerry_value_t parsed_code = jerry_parse (script, sizeof (script) - 1, NULL);
/* Check if there is any JS code parse error */
if (!jerry_value_is_error (parsed_code))
if (!jerry_value_is_exception (parsed_code))
{
/* Execute the parsed source code in the Global scope */
jerry_value_t ret_value = jerry_run (parsed_code);
/* Check the execution return value if there is any error */
run_ok = !jerry_value_is_error (ret_value);
run_ok = !jerry_value_is_exception (ret_value);
/* Returned value must be freed */
jerry_release_value (ret_value);
jerry_value_free (ret_value);
}
/* Parsed source code must be freed */
jerry_release_value (parsed_code);
jerry_value_free (parsed_code);
/* Cleanup engine */
jerry_cleanup ();
@ -200,10 +167,10 @@ In this example a very simple "print" method is added which prints out a static
This method will be implemented in C and will be called from the JavaScript code.
For this a few extra API methods are required:
- `jerry_get_global_object`
- `jerry_create_string`
- `jerry_set_property`
- `jerry_create_external_function`
- `jerry_current_realm`
- `jerry_string_sz`
- `jerry_object_set`
- `jerry_function_external`
The `api-example-4.c` file should contain the following code:
@ -223,7 +190,7 @@ print_handler (const jerry_call_info_t *call_info_p,
printf ("Print handler was called\n");
/* Return an "undefined" value to the JavaScript engine */
return jerry_create_undefined ();
return jerry_undefined ();
}
int
@ -238,40 +205,40 @@ main (void)
/* Add the "print" method for the JavaScript global object */
{
/* Get the "global" object */
jerry_value_t global_object = jerry_get_global_object ();
jerry_value_t global_object = jerry_current_realm ();
/* Create a "print" JS string */
jerry_value_t property_name_print = jerry_create_string ((const jerry_char_t *) "print");
jerry_value_t property_name_print = jerry_string_sz ("print");
/* Create a function from a native C method (this function will be called from JS) */
jerry_value_t property_value_func = jerry_create_external_function (print_handler);
jerry_value_t property_value_func = jerry_function_external (print_handler);
/* Add the "print" property with the function value to the "global" object */
jerry_value_t set_result = jerry_set_property (global_object, property_name_print, property_value_func);
jerry_value_t set_result = jerry_object_set (global_object, property_name_print, property_value_func);
/* Check if there was no error when adding the property (in this case it should never happen) */
if (jerry_value_is_error (set_result)) {
if (jerry_value_is_exception (set_result)) {
printf ("Failed to add the 'print' property\n");
}
/* Release all jerry_value_t-s */
jerry_release_value (set_result);
jerry_release_value (property_value_func);
jerry_release_value (property_name_print);
jerry_release_value (global_object);
jerry_value_free (set_result);
jerry_value_free (property_value_func);
jerry_value_free (property_name_print);
jerry_value_free (global_object);
}
/* Setup Global scope code */
jerry_value_t parsed_code = jerry_parse (script, script_size, NULL);
if (!jerry_value_is_error (parsed_code))
if (!jerry_value_is_exception (parsed_code))
{
/* Execute the parsed source code in the Global scope */
jerry_value_t ret_value = jerry_run (parsed_code);
/* Returned value must be freed */
jerry_release_value (ret_value);
jerry_value_free (ret_value);
}
/* Parsed source code must be freed */
jerry_release_value (parsed_code);
jerry_value_free (parsed_code);
/* Cleanup engine */
jerry_cleanup ();
@ -304,7 +271,7 @@ argument (which probably comes from a JavaScript source) to a JS string and prin
New API methods used:
- `jerry_value_to_string`
- `jerry_string_to_utf8_char_buffer`
- `jerry_string_to_buffer`
The `api-example-5.c` file should contain the following code:
@ -332,17 +299,17 @@ print_handler (const jerry_call_info_t *call_info_p,
* Please note that if the string does not fit into the buffer nothing will be copied.
* More details on the API reference page
*/
jerry_size_t copied_bytes = jerry_string_to_utf8_char_buffer (string_value, buffer, sizeof (buffer) - 1);
jerry_size_t copied_bytes = jerry_string_to_buffer (string_value, JERRY_ENCODING_UTF8, buffer, sizeof (buffer) - 1);
buffer[copied_bytes] = '\0';
/* Release the "toString" result */
jerry_release_value (string_value);
jerry_value_free (string_value);
printf ("%s\n", (const char *)buffer);
}
/* Return an "undefined" value to the JavaScript engine */
return jerry_create_undefined ();
return jerry_undefined ();
}
int
@ -357,40 +324,40 @@ main (void)
/* Add the "print" method for the JavaScript global object */
{
/* Get the "global" object */
jerry_value_t global_object = jerry_get_global_object ();
jerry_value_t global_object = jerry_current_realm ();
/* Create a "print" JS string */
jerry_value_t property_name_print = jerry_create_string ((const jerry_char_t *) "print");
jerry_value_t property_name_print = jerry_string_sz ("print");
/* Create a function from a native C method (this function will be called from JS) */
jerry_value_t property_value_func = jerry_create_external_function (print_handler);
jerry_value_t property_value_func = jerry_function_external (print_handler);
/* Add the "print" property with the function value to the "global" object */
jerry_value_t set_result = jerry_set_property (global_object, property_name_print, property_value_func);
jerry_value_t set_result = jerry_object_set (global_object, property_name_print, property_value_func);
/* Check if there was no error when adding the property (in this case it should never happen) */
if (jerry_value_is_error (set_result)) {
if (jerry_value_is_exception (set_result)) {
printf ("Failed to add the 'print' property\n");
}
/* Release all jerry_value_t-s */
jerry_release_value (set_result);
jerry_release_value (property_value_func);
jerry_release_value (property_name_print);
jerry_release_value (global_object);
jerry_value_free (set_result);
jerry_value_free (property_value_func);
jerry_value_free (property_name_print);
jerry_value_free (global_object);
}
/* Setup Global scope code */
jerry_value_t parsed_code = jerry_parse (script, script_size, NULL);
if (!jerry_value_is_error (parsed_code))
if (!jerry_value_is_exception (parsed_code))
{
/* Execute the parsed source code in the Global scope */
jerry_value_t ret_value = jerry_run (parsed_code);
/* Returned value must be freed */
jerry_release_value (ret_value);
jerry_value_free (ret_value);
}
/* Parsed source code must be freed */
jerry_release_value (parsed_code);
jerry_value_free (parsed_code);
/* Cleanup engine */
jerry_cleanup ();
@ -440,23 +407,22 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
/* Register 'print' function from the extensions to the global object */
jerryx_handler_register_global ((const jerry_char_t *) "print",
jerryx_handler_print);
jerryx_handler_register_global ("print", jerryx_handler_print);
/* Setup Global scope code */
jerry_value_t parsed_code = jerry_parse (script, script_size, NULL);
if (!jerry_value_is_error (parsed_code))
if (!jerry_value_is_exception (parsed_code))
{
/* Execute the parsed source code in the Global scope */
jerry_value_t ret_value = jerry_run (parsed_code);
/* Returned value must be freed */
jerry_release_value (ret_value);
jerry_value_free (ret_value);
}
/* Parsed source code must be freed */
jerry_release_value (parsed_code);
jerry_value_free (parsed_code);
/* Cleanup engine */
jerry_cleanup ();
@ -502,30 +468,29 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
/* Register 'print' function from the extensions */
jerryx_handler_register_global ((const jerry_char_t *) "print",
jerryx_handler_print);
jerryx_handler_register_global ("print", jerryx_handler_print);
/* Getting pointer to the Global object */
jerry_value_t global_object = jerry_get_global_object ();
jerry_value_t global_object = jerry_current_realm ();
/* Constructing strings */
jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "my_var");
jerry_value_t prop_value = jerry_create_string ((const jerry_char_t *) "Hello from C!");
jerry_value_t prop_name = jerry_string_sz ("my_var");
jerry_value_t prop_value = jerry_string_sz ("Hello from C!");
/* Setting the string value as a property of the Global object */
jerry_value_t set_result = jerry_set_property (global_object, prop_name, prop_value);
jerry_value_t set_result = jerry_object_set (global_object, prop_name, prop_value);
/* The 'set_result' should be checked if there was any error */
if (jerry_value_is_error (set_result)) {
if (jerry_value_is_exception (set_result)) {
printf ("Failed to add the 'my_var' property\n");
}
jerry_release_value (set_result);
jerry_value_free (set_result);
/* Releasing string values, as it is no longer necessary outside of engine */
jerry_release_value (prop_name);
jerry_release_value (prop_value);
jerry_value_free (prop_name);
jerry_value_free (prop_value);
/* Releasing the Global object */
jerry_release_value (global_object);
jerry_value_free (global_object);
/* Now starting script that would output value of just initialized field */
jerry_value_t eval_ret = jerry_eval (script,
@ -533,7 +498,7 @@ main (void)
JERRY_PARSE_NO_OPTS);
/* Free JavaScript value, returned by eval */
jerry_release_value (eval_ret);
jerry_value_free (eval_ret);
/* Freeing engine */
jerry_cleanup ();
@ -561,9 +526,9 @@ $ ./api-example-7
JerryScript value can be a boolean, number, null, object, string, undefined or some special type of objects (arraybuffer, symbols, etc).
There is a special "error" value which wraps another value. This "error" can be created by throwing a JavaScript value from JS code
or via API method(s). It is advised to check for this error with the `jerry_value_is_error` method as not all API methods
can process error values. To extract the value from the "error" the API method `jerry_get_value_from_error` should be used.
If an error object is created via API method (for example with `jerry_create_error`) the "error" value is automatically created.
or via API method(s). It is advised to check for this error with the `jerry_value_is_exception` method as not all API methods
can process error values. To extract the value from the "error" the API method `jerry_exception_value` should be used.
If an error object is created via API method (for example with `jerry_error`) the "error" value is automatically created.
Notice the difference between error value and error object:
- The error object is a object which was constructed via one of the `Error` objects (available from the global object or from API).
@ -580,7 +545,7 @@ var error_object = new Error ("error message");
throw "message";
```
To check what type a given `jerry_value_t` is the `jerry_value_is_*` methods or the `jerry_value_get_type` could be used.
To check what type a given `jerry_value_t` is the `jerry_value_is_*` methods or the `jerry_value_type` could be used.
For example the following code snippet could print out a few types (not all types are checked):
[doctest]: # (test="compile")
@ -595,14 +560,14 @@ print_value (const jerry_value_t jsvalue)
{
jerry_value_t value;
/* If there is an error extract the object from it */
if (jerry_value_is_error (jsvalue))
if (jerry_value_is_exception (jsvalue))
{
printf ("Error value detected: ");
value = jerry_get_value_from_error (jsvalue, false);
value = jerry_exception_value (jsvalue, false);
}
else
{
value = jerry_acquire_value (jsvalue);
value = jerry_value_copy (jsvalue);
}
if (jerry_value_is_undefined (value))
@ -627,7 +592,7 @@ print_value (const jerry_value_t jsvalue)
/* Float value */
else if (jerry_value_is_number (value))
{
printf ("number: %lf", jerry_get_number_value (value));
printf ("number: %lf", jerry_value_as_number (value));
}
/* String value */
else if (jerry_value_is_string (value))
@ -635,11 +600,11 @@ print_value (const jerry_value_t jsvalue)
jerry_char_t str_buf_p[256];
/* Determining required buffer size */
jerry_size_t req_sz = jerry_get_string_size (value);
jerry_size_t req_sz = jerry_string_size (value, JERRY_ENCODING_CESU8);
if (req_sz <= 255)
{
jerry_string_to_char_buffer (value, str_buf_p, req_sz);
jerry_string_to_buffer (value, JERRY_ENCODING_CESU8, str_buf_p, req_sz);
str_buf_p[req_sz] = '\0';
printf ("%s", (const char *) str_buf_p);
}
@ -655,7 +620,7 @@ print_value (const jerry_value_t jsvalue)
}
printf ("\n");
jerry_release_value (value);
jerry_value_free (value);
}
```
@ -689,14 +654,14 @@ print_value (const jerry_value_t jsvalue)
{
jerry_value_t value;
/* If there is an error extract the object from it */
if (jerry_value_is_error (jsvalue))
if (jerry_value_is_exception (jsvalue))
{
printf ("Error value detected: ");
value = jerry_get_value_from_error (jsvalue, false);
value = jerry_exception_value (jsvalue, false);
}
else
{
value = jerry_acquire_value (jsvalue);
value = jerry_value_copy (jsvalue);
}
if (jerry_value_is_undefined (value))
@ -721,7 +686,7 @@ print_value (const jerry_value_t jsvalue)
/* Float value */
else if (jerry_value_is_number (value))
{
printf ("number: %lf", jerry_get_number_value (value));
printf ("number: %lf", jerry_value_as_number (value));
}
/* String value */
else if (jerry_value_is_string (value))
@ -729,11 +694,11 @@ print_value (const jerry_value_t jsvalue)
jerry_char_t str_buf_p[256];
/* Determining required buffer size */
jerry_size_t req_sz = jerry_get_string_size (value);
jerry_size_t req_sz = jerry_string_size (value, JERRY_ENCODING_CESU8);
if (req_sz <= 255)
{
jerry_string_to_char_buffer (value, str_buf_p, req_sz);
jerry_string_to_buffer (value, JERRY_ENCODING_CESU8, str_buf_p, req_sz);
str_buf_p[req_sz] = '\0';
printf ("%s", (const char *) str_buf_p);
}
@ -749,7 +714,7 @@ print_value (const jerry_value_t jsvalue)
}
printf ("\n");
jerry_release_value (value);
jerry_value_free (value);
}
int
@ -761,8 +726,7 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
/* Register 'print' function from the extensions */
jerryx_handler_register_global ((const jerry_char_t *) "print",
jerryx_handler_print);
jerryx_handler_register_global ("print", jerryx_handler_print);
while (!is_done)
{
@ -805,7 +769,7 @@ main (void)
/* Print out the value */
print_value (ret_val);
jerry_release_value (ret_val);
jerry_value_free (ret_val);
}
/* Cleanup engine */
@ -853,7 +817,7 @@ get_msg_handler (const jerry_call_info_t *call_info_p, /**< call information */
const jerry_value_t *args_p, /**< function arguments */
const jerry_length_t args_cnt) /**< number of function arguments */
{
return jerry_create_string ((const jerry_char_t *) my_struct.msg);
return jerry_string_sz (my_struct.msg);
} /* get_msg_handler */
int
@ -863,33 +827,32 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
/* Register 'print' function from the extensions */
jerryx_handler_register_global ((const jerry_char_t *) "print",
jerryx_handler_print);
jerryx_handler_register_global ("print", jerryx_handler_print);
/* Do something with the native object */
my_struct.msg = "Hello, World!";
/* Create an empty JS object */
jerry_value_t object = jerry_create_object ();
jerry_value_t object = jerry_object ();
/* Create a JS function object and wrap into a jerry value */
jerry_value_t func_obj = jerry_create_external_function (get_msg_handler);
jerry_value_t func_obj = jerry_function_external (get_msg_handler);
/* Set the native function as a property of the empty JS object */
jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "myFunc");
jerry_release_value (jerry_set_property (object, prop_name, func_obj));
jerry_release_value (prop_name);
jerry_release_value (func_obj);
jerry_value_t prop_name = jerry_string_sz ("myFunc");
jerry_value_free (jerry_object_set (object, prop_name, func_obj));
jerry_value_free (prop_name);
jerry_value_free (func_obj);
/* Wrap the JS object (not empty anymore) into a jerry api value */
jerry_value_t global_object = jerry_get_global_object ();
jerry_value_t global_object = jerry_current_realm ();
/* Add the JS object to the global context */
prop_name = jerry_create_string ((const jerry_char_t *) "MyObject");
jerry_release_value (jerry_set_property (global_object, prop_name, object));
jerry_release_value (prop_name);
jerry_release_value (object);
jerry_release_value (global_object);
prop_name = jerry_string_sz ("MyObject");
jerry_value_free (jerry_object_set (global_object, prop_name, object));
jerry_value_free (prop_name);
jerry_value_free (object);
jerry_value_free (global_object);
/* Now we have a "builtin" object called MyObject with a function called myFunc()
*
@ -905,7 +868,7 @@ main (void)
jerry_value_t eval_ret = jerry_eval (script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
/* Free JavaScript value, returned by eval */
jerry_release_value (eval_ret);
jerry_value_free (eval_ret);
/* Cleanup engine */
jerry_cleanup ();
@ -960,27 +923,27 @@ add_handler (const jerry_call_info_t *call_info_p, /**< call information */
/* Note: that the argument count check is ignored for the example's case */
/* Get 'this.x' */
jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "x");
jerry_value_t x_val = jerry_get_property (call_info_p->this_value, prop_name);
jerry_value_t prop_name = jerry_string_sz ("x");
jerry_value_t x_val = jerry_object_get (call_info_p->this_value, prop_name);
if (!jerry_value_is_error (x_val))
if (!jerry_value_is_exception (x_val))
{
/* Convert Jerry API values to double */
double x = jerry_get_number_value (x_val);
double d = jerry_get_number_value (args_p[0]);
double x = jerry_value_as_number (x_val);
double d = jerry_value_as_number (args_p[0]);
/* Add the parameter to 'x' */
jerry_value_t res_val = jerry_create_number (x + d);
jerry_value_t res_val = jerry_number (x + d);
/* Set the new value of 'this.x' */
jerry_release_value (jerry_set_property (call_info_p->this_value, prop_name, res_val));
jerry_release_value (res_val);
jerry_value_free (jerry_object_set (call_info_p->this_value, prop_name, res_val));
jerry_value_free (res_val);
}
jerry_release_value (x_val);
jerry_release_value (prop_name);
jerry_value_free (x_val);
jerry_value_free (prop_name);
return jerry_create_undefined ();
return jerry_undefined ();
} /* add_handler */
int
@ -990,8 +953,7 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
/* Register 'print' function from the extensions */
jerryx_handler_register_global ((const jerry_char_t *) "print",
jerryx_handler_print);
jerryx_handler_register_global ("print", jerryx_handler_print);
/* Create a JS object */
const jerry_char_t my_js_object[] = " \
@ -1013,16 +975,16 @@ main (void)
JERRY_PARSE_NO_OPTS);
/* Create a JS function object and wrap into a jerry value */
jerry_value_t add_func_obj = jerry_create_external_function (add_handler);
jerry_value_t add_func_obj = jerry_function_external (add_handler);
/* Set the native function as a property of previously created MyObject */
jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "add2x");
jerry_release_value (jerry_set_property (my_js_obj_val, prop_name, add_func_obj));
jerry_release_value (add_func_obj);
jerry_release_value (prop_name);
jerry_value_t prop_name = jerry_string_sz ("add2x");
jerry_value_free (jerry_object_set (my_js_obj_val, prop_name, add_func_obj));
jerry_value_free (add_func_obj);
jerry_value_free (prop_name);
/* Free JavaScript value, returned by eval (my_js_object) */
jerry_release_value (my_js_obj_val);
jerry_value_free (my_js_obj_val);
const jerry_char_t script[] = " \
var str = MyObject.foo (); \
@ -1035,7 +997,7 @@ main (void)
jerry_value_t eval_ret = jerry_eval (script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
/* Free JavaScript value, returned by eval */
jerry_release_value (eval_ret);
jerry_value_free (eval_ret);
/* Cleanup engine */
jerry_cleanup ();
@ -1090,14 +1052,13 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
/* Register the print function */
jerryx_handler_register_global ((const jerry_char_t *) "print",
jerryx_handler_print);
jerryx_handler_register_global ("print", jerryx_handler_print);
/* Evaluate the script */
jerry_value_t eval_ret = jerry_eval (script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
/* Free the JavaScript value returned by eval */
jerry_release_value (eval_ret);
jerry_value_free (eval_ret);
/* Cleanup the engine */
jerry_cleanup ();

62
docs/06.REFERENCE-COUNTING.md
View File

@ -3,10 +3,10 @@
In JerryScript all `jerry_value_t` values are independent
references to internal objects. Values returned by JerryScript
API functions are always live references and must be released
by `jerry_release_value`.
by `jerry_value_free`.
```c
jerry_value_t global = jerry_get_global_object ();
jerry_value_t global = jerry_current_realm ();
/* The value stored in the 'global' variable contains a live
* reference to the global object. The system also keeps its
@ -14,9 +14,9 @@ by `jerry_release_value`.
* are independent, and both must be destroyed before the global
* object can be freed. */
jerry_release_value (global);
jerry_value_free (global);
/* Without jerry_release_value() the global object will not
/* Without jerry_value_free() the global object will not
* be freed even by jerry_cleanup(). After the reference
* is released it becomes a dead reference and cannot be
* used anymore. */
@ -26,15 +26,15 @@ Multiple references might refer to the same internal object
even though their `jerry_value_t` representation might be different.
```c
jerry_value_t pi_ref1 = jerry_create_number (3.14);
jerry_value_t pi_ref2 = jerry_acquire_value (pi_ref1);
jerry_value_t pi_ref1 = jerry_number (3.14);
jerry_value_t pi_ref2 = jerry_value_copy (pi_ref1);
/* Both pi_ref1 and pi_ref2 refer to the same 3.14 value
* although they might not be equal in C (pi_ref1 != pi_ref2). */
/* Both references must be released. */
jerry_release_value (pi_ref1);
jerry_release_value (pi_ref2);
jerry_value_free (pi_ref1);
jerry_value_free (pi_ref2);
```
Releasing the same `jerry_value_t` twice to release two live
@ -42,8 +42,8 @@ references is not allowed and it might cause crashes. Hence the
following code is an **INCORRECT WAY** of releasing the 3.14 value.
```c
jerry_release_value (pi_ref1);
jerry_release_value (pi_ref1);
jerry_value_free (pi_ref1);
jerry_value_free (pi_ref1);
```
JerryScript API functions returning with a `jerry_value_t` always
@ -53,7 +53,7 @@ stated in the documentation). The next example shows this
behaviour through property getting and setting.
```c
jerry_value_t prop_value = jerry_get_property (...);
jerry_value_t prop_value = jerry_object_get (...);
/* The prop_value must be released later because both the base
* object and the prop_value have an independent reference to
@ -61,7 +61,7 @@ behaviour through property getting and setting.
* prop_value contains a live reference to an error object.
* This reference must be released as well. */
if (jerry_value_is_error (prop_value))
if (jerry_value_is_exception (prop_value))
{
/* Errors can be handled here. */
}
@ -73,12 +73,12 @@ behaviour through property getting and setting.
}
/* The prop_value must be released. */
jerry_release_value (prop_value);
jerry_value_free (prop_value);
/* Property setting is the same. */
jerry_value_t new_prop_value = jerry_create_number (2.718);
jerry_value_t result = jerry_set_property (..., new_prop_value);
jerry_value_t new_prop_value = jerry_number (2.718);
jerry_value_t result = jerry_object_set (..., new_prop_value);
/* If the property set is successful, a new reference is created
* for the value referenced by new_prop_value. The new_prop_value
@ -86,14 +86,14 @@ behaviour through property getting and setting.
* is successful. */
/* The new_prop_value can be passed to other JerryScript API
* functions before the jerry_release_value () call. */
* functions before the jerry_value_free () call. */
jerry_release_value (new_prop_value);
jerry_value_free (new_prop_value);
/* The reference stored in the 'result' variable is live whether
* the operation is successful or not, and must also be freed. */
if (jerry_value_is_error (result))
if (jerry_value_is_exception (result))
{
/* Errors can be handled here. */
}
@ -102,7 +102,7 @@ behaviour through property getting and setting.
/* A reference to a true primitive value is returned. */
}
jerry_release_value (result);
jerry_value_free (result);
```
The simplest form of setting a property without error checking
@ -110,8 +110,8 @@ is the following:
```c
/* There are no 'ifs' in this snippet. */
jerry_release_value (jerry_set_property (..., new_prop_value));
jerry_release_value (new_prop_value);
jerry_value_free (jerry_object_set (..., new_prop_value));
jerry_value_free (new_prop_value);
```
The reference returned by a `jerry_external_handler_t` callback
@ -128,48 +128,48 @@ jerry_value_t my_external_handler (const jerry_value_t function_obj,
* these references are automatically released after the handler
* is returned. This approach reduces code size which is useful
* on embedded systems. However you can create other references
* to them by calling jerry_acquire_value () if needed. */
* to them by calling jerry_value_copy () if needed. */
/* Since the ownership of the reference is transferred to the
* caller the following snippet is valid. */
/* If the value to be returned is needed for other purposes the
* jerry_acquire_value () can be used to create new references. */
return jerry_create_string (...);
* jerry_value_copy () can be used to create new references. */
return jerry_string (...);
}
```
Duplicating a `jerry_value_t` in C does not create another live reference.
```c
jerry_value_t undef = jerry_create_undefined ();
jerry_value_t undef = jerry_undefined ();
jerry_value_t undef2 = undef;
/* Releasing either undef or undef2 is valid but not both.
* After the release both references become dead (invalid). */
jerry_release_value (undef2);
jerry_value_free (undef2);
/* Dead references can be reassigned again. */
undef = jerry_create_boolean (true);
undef = jerry_boolean (true);
```
References can be duplicated in C as long as only one of them is freed.
```c
jerry_value_t a = jerry_create_boolean (true);
jerry_value_t a = jerry_boolean (true);
jerry_value_t b = a;
jerry_value_t c = a;
/* A new reference is assigned to 'a'. */
a = jerry_create_boolean (false);
a = jerry_boolean (false);
[...]
jerry_release_value (a);
jerry_value_free (a);
/* The 'a' (boolean false) reference becomes dead (invalid). */
jerry_release_value (c);
jerry_value_free (c);
/* Both 'b' and 'c' (boolean true) references become dead. */
/* Since all references are released, no memory leak occurs. */

26
docs/07.DEBUGGER.md
View File

@ -97,14 +97,14 @@ when a source code is received successfully.
```c
typedef jerry_value_t
(*jerry_debugger_wait_for_source_callback_t) (const jerry_char_t *resource_name_p,
size_t resource_name_size,
(*jerry_debugger_wait_for_source_callback_t) (const jerry_char_t *source_name_p,
size_t source_name_size,
const jerry_char_t *source_p,
size_t source_size, void *user_p);
```
- `resource_name_p` - resource (usually a file) name of the source code
- `resource_name_size` - size of resource name
- `source_name_p` - resource (usually a file) name of the source code
- `source_name_size` - size of resource name
- `source_p` - source code character data
- `source_size` - size of source code
- `user_p` - custom pointer passed to [jerry_debugger_wait_for_client_source](#jerry_debugger_wait_for_client_source)
@ -306,8 +306,8 @@ jerry_debugger_wait_for_client_source (jerry_debugger_wait_for_source_callback_t
* Runs the source code received by jerry_debugger_wait_for_client_source.
*/
static jerry_value_t
wait_for_source_callback (const jerry_char_t *resource_name_p, /**< resource name */
size_t resource_name_size, /**< size of resource name */
wait_for_source_callback (const jerry_char_t *source_name_p, /**< resource name */
size_t source_name_size, /**< size of resource name */
const jerry_char_t *source_p, /**< source code */
size_t source_size, /**< source code size */
void *user_p /**< user pointer */)
@ -315,19 +315,21 @@ wait_for_source_callback (const jerry_char_t *resource_name_p, /**< resource nam
(void) user_p;
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name = jerry_create_string ((const jerry_char_t *) resource_name_p);
parse_options.options = JERRY_PARSE_HAS_SOURCE_NAME;
parse_options.source_name = jerry_string ((const jerry_char_t *) source_name_p,
(jerry_size_t) source_name_size,
JERRY_ENCODING_UTF8);
jerry_value_t ret_val = jerry_parse (source_p,
source_size,
&parse_options);
jerry_release_value (parse_options.resource_name);
jerry_value_free (parse_options.source_name);
if (!jerry_value_is_error (ret_val))
if (!jerry_value_is_exception (ret_val))
{
jerry_value_t func_val = ret_val;
ret_val = jerry_run (func_val);
jerry_release_value (func_val);
jerry_value_free (func_val);
}
return ret_val;
@ -355,7 +357,7 @@ main (void)
NULL,
&run_result);
jerry_release_value (run_result);
jerry_value_free (run_result);
}
while (receive_status == JERRY_DEBUGGER_SOURCE_RECEIVED);

12
docs/09.EXT-REFERENCE-ARG.md
View File

@ -244,7 +244,7 @@ my_external_handler (const jerry_value_t function_obj,
mapping,
4);
if (jerry_value_is_error (rv))
if (jerry_value_is_exception (rv))
{
/* Handle error. */
return rv;
@ -255,7 +255,7 @@ my_external_handler (const jerry_value_t function_obj,
* required_bool, required_str and optional_num can now be used.
*/
return jerry_create_undefined (); /* Or return something more meaningful. */
return jerry_undefined (); /* Or return something more meaningful. */
}
```
@ -640,7 +640,7 @@ my_external_handler (const jerry_value_t function_obj,
mapping,
1);
if (jerry_value_is_error (rv))
if (jerry_value_is_exception (rv))
{
/* Handle error. */
return rv;
@ -651,7 +651,7 @@ my_external_handler (const jerry_value_t function_obj,
* required_bool, required_num and optional_num can now be used.
*/
return jerry_create_undefined (); /* Or return something more meaningful. */
return jerry_undefined (); /* Or return something more meaningful. */
}
```
@ -731,7 +731,7 @@ my_external_handler (const jerry_value_t function_obj,
mapping,
1);
if (jerry_value_is_error (rv))
if (jerry_value_is_exception (rv))
{
/* Handle error. */
return rv;
@ -742,7 +742,7 @@ my_external_handler (const jerry_value_t function_obj,
* required_bool, required_num and optional_num can now be used.
*/
return jerry_create_undefined (); /* Or return something more meaningful. */
return jerry_undefined (); /* Or return something more meaningful. */
}
```

68
docs/10.EXT-REFERENCE-HANDLER.md
View File

@ -12,7 +12,7 @@ Set a property on a target object with a given name.
*Note*:
- The property name must be a zero terminated UTF-8 string.
- There should be no '\0' (NULL) character in the name excluding the string terminator.
- Returned value must be freed with [jerry_release_value](#jerry_release_value) when it
- Returned value must be freed with [jerry_value_free](#jerry_value_free) when it
is no longer needed.
@ -45,19 +45,19 @@ main (int argc, char **argv)
{
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t global = jerry_get_global_object ();
jerry_value_t global = jerry_current_realm ();
jerry_value_t value = jerry_create_number (3.3);
jerry_value_t value = jerry_number (3.3);
jerry_value_t result = jerryx_set_property_str (global, "value", value);
if (jerry_value_is_error (result))
if (jerry_value_is_exception (result))
{
/* The error type/reason can be extracted via the `jerry_get_value_from_error` method */
/* The error type/reason can be extracted via the `jerry_exception_value` method */
printf ("Error during property configuration\r\n");
}
jerry_release_value (result);
jerry_release_value (value);
jerry_release_value (global);
jerry_value_free (result);
jerry_value_free (value);
jerry_value_free (global);
jerry_cleanup();
return 0;
@ -73,7 +73,7 @@ Get the value of a property from the specified object with the given name.
*Notes*:
- The property name must be a zero terminated UTF-8 string.
- There should be no '\0' (NULL) character in the name excluding the string terminator.
- Returned value must be freed with [jerry_release_value](#jerry_release_value) when it
- Returned value must be freed with [jerry_value_free](#jerry_value_free) when it
is no longer needed.
@ -104,14 +104,14 @@ main (int argc, char **argv)
{
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t global = jerry_get_global_object ();
jerry_value_t global = jerry_current_realm ();
jerry_value_t math_object = jerryx_get_property_str (global, "Math");
/* use math_object */
jerry_release_value (math_object);
jerry_release_value (global);
jerry_value_free (math_object);
jerry_value_free (global);
jerry_cleanup();
return 0;
@ -125,7 +125,7 @@ main (int argc, char **argv)
Check if a property exists on an object.
*Notes*:
- The operation performed is the same as what the `jerry_has_property` method.
- The operation performed is the same as what the `jerry_object_has` method.
- The property name must be a zero terminated UTF-8 string.
- There should be no '\0' (NULL) character in the name excluding the string terminator.
@ -157,11 +157,11 @@ main (int argc, char **argv)
{
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t global = jerry_get_global_object ();
jerry_value_t global = jerry_current_realm ();
bool have_math = jerryx_has_property_str (global, "Math");
jerry_release_value (global);
jerry_value_free (global);
jerry_cleanup();
return have_math ? 0 : 1;
@ -273,7 +273,7 @@ handler (const jerry_call_info_t *call_info_p,
{
printf ("native handler called!\n");
return jerry_create_boolean (true);
return jerry_boolean (true);
}
int
@ -283,24 +283,24 @@ main (int argc, char **argv)
jerryx_property_entry methods[] =
{
{ "demo", jerry_create_external_function (handler) },
{ "demo", jerry_function_external (handler) },
{ NULL, 0 },
};
jerry_value_t global = jerry_get_global_object ();
jerry_value_t global = jerry_current_realm ();
jerryx_register_result reg = jerryx_set_properties (global, methods);
/* if `reg.result` is undefined all methods are registered */
if (jerry_value_is_error (reg.result))
if (jerry_value_is_exception (reg.result))
{
printf ("Only registered %d properties\r\n", reg.registered);
/* clean up not registered property values */
jerryx_release_property_entry (methods, reg);
/* clean up the error */
jerry_release_value (reg.result);
jerry_value_free (reg.result);
}
jerry_release_value (global);
jerry_value_free (global);
jerry_cleanup();
@ -314,8 +314,8 @@ To make property registration convenient, there are a set of macros to use
when setting a property entry:
* `JERRYX_PROPERTY_NUMBER(NAME, NUMBER)` - creates a number entry.
* `JERRYX_PROPERTY_STRING(NAME, STR)` - creates an UTF-8 string entry. This string must be zero terminated.
* `JERRYX_PROPERTY_STRING_SZ(NAME, STR, SIZE)` - creates an UTF-8 string entry using only `SIZE` bytes from the string.
* `JERRYX_PROPERTY_STRING(NAME, STR, SIZE)` - creates an UTF-8 string entry using `SIZE` bytes from the string.
* `JERRYX_PROPERTY_STRING_SZ(NAME, STR)` - creates an ASCII string entry. This string must be zero terminated.
* `JERRYX_PROPERTY_BOOLEAN(NAME, VALUE)` - creates a boolean entry.
* `JERRYX_PROPERTY_FUNCTION(NAME, NATIVE)` - creates a native C function entry.
* `JERRYX_PROPERTY_UNDEFINED(NAME)` - creates an undefined property entry.
@ -336,7 +336,7 @@ handler (const jerry_call_info_t *call_info_p,
{
printf ("native handler called!\n");
return jerry_create_boolean (true);
return jerry_boolean (true);
}
int
@ -357,20 +357,20 @@ main (int argc, char **argv)
JERRYX_PROPERTY_LIST_END(),
};
jerry_value_t global = jerry_get_global_object ();
jerry_value_t global = jerry_current_realm ();
jerryx_register_result reg = jerryx_set_properties (global, methods);
/* if `reg.result` is undefined all methods are registered */
if (jerry_value_is_error (reg.result))
if (jerry_value_is_exception (reg.result))
{
printf ("Only registered %d properties\r\n", reg.registered);
/* clean up not registered property values */
jerryx_release_property_entry (methods, reg);
/* clean up the error */
jerry_release_value (reg.result);
jerry_value_free (reg.result);
}
jerry_release_value (global);
jerry_value_free (global);
jerry_cleanup();
@ -551,14 +551,14 @@ jerryx_handler_print (const jerry_value_t func_obj_val, const jerry_value_t this
Register a JavaScript function in the global object.
*Note*: Returned value must be freed with `jerry_release_value`, when it is no
*Note*: Returned value must be freed with `jerry_value_free`, when it is no
longer needed.
**Prototype**
```c
jerry_value_t
jerryx_handler_register_global (const jerry_char_t *name_p,
jerryx_handler_register_global (const char *name_p,
jerry_external_handler_t handler_p);
```
@ -589,14 +589,14 @@ static const struct {
static void
register_common_functions (void)
{
jerry_value_t ret = jerry_create_undefined ();
jerry_value_t ret = jerry_undefined ();
for (int i = 0; common_functions[i].name_p != NULL && !jerry_value_is_error (ret); i++)
for (int i = 0; common_functions[i].name_p != NULL && !jerry_value_is_exception (ret); i++)
{
ret = jerryx_handler_register_global ((const jerry_char_t *) common_functions[i].name_p,
ret = jerryx_handler_register_global (common_functions[i].name_p,
common_functions[i].handler_p);
}
jerry_release_value (ret);
jerry_value_free (ret);
}
```

14
docs/11.EXT-REFERENCE-AUTORELEASE.md
View File

@ -4,7 +4,7 @@
**Summary**
Macro for `const jerry_value_t` for which jerry_release_value() is
Macro for `const jerry_value_t` for which jerry_value_free() is
automatically called when the variable goes out of scope.
*Note*: The macro depends on compiler support. For GCC and LLVM/clang, the macro is implemented
@ -21,23 +21,23 @@ using the `__cleanup__` variable attribute. For other compilers, no support has
static void
foo (bool enable)
{
JERRYX_AR_VALUE_T bar = jerry_create_string ((const jerry_char_t *) "...");
JERRYX_AR_VALUE_T bar = jerry_string_sz ("...");
if (enable)
{
JERRYX_AR_VALUE_T baz = jerry_get_global_object ();
JERRYX_AR_VALUE_T baz = jerry_current_realm ();
/* bar and baz can now be used. */
/*
* jerry_release_value (baz) and jerry_release_value (bar) is called automatically before
* jerry_value_free (baz) and jerry_value_free (bar) is called automatically before
* returning, because `baz` and `bar` go out of scope.
*/
return;
}
/*
* jerry_release_value (bar) is called automatically when the function returns,
* jerry_value_free (bar) is called automatically when the function returns,
* because `bar` goes out of scope.
*/
}
@ -46,5 +46,5 @@ foo (bool enable)
**See also**
- [jerry_value_t](../docs/02.API-REFERENCE.md#jerry_value_t)
- [jerry_acquire_value](../docs/02.API-REFERENCE.md#jerry_acquire_value)
- [jerry_release_value](../docs/02.API-REFERENCE.md#jerry_release_value)
- [jerry_value_copy](../docs/02.API-REFERENCE.md#jerry_value_copy)
- [jerry_value_free](../docs/02.API-REFERENCE.md#jerry_value_free)

8
docs/12.EXT-REFERENCE-MODULE.md
View File

@ -164,9 +164,9 @@ load_and_evaluate_js_file (const jerry_value_t name, jerry_value_t *result)
char *js_file_contents = NULL;
int file_size = 0;
jerry_size_t name_size = jerry_get_utf8_string_size (name);
jerry_size_t name_size = jerry_string_size (name, JERRY_ENCODING_UTF8);
jerry_char_t name_string[name_size + 1];
jerry_string_to_utf8_char_buffer (name, name_string, name_size);
jerry_string_to_buffer (name, JERRY_ENCODING_UTF8, name_string, name_size);
name_string[name_size] = 0;
FILE *js_file = fopen (name_string, "r");
@ -205,7 +205,7 @@ canonicalize_file_path (const jerry_value_t name)
/**
* Since a file on the file system can be referred to by multiple relative paths, but only by one absolute path, the
* absolute path becomes the canonical name for the module. Thus, to establish this canonical name, we must search
* name for "./" and "../", follow symlinks, etc., then create absolute_path via jerry_create_string () and return
* name for "./" and "../", follow symlinks, etc., then create absolute_path via jerry_string () and return
* it, because it is the canonical name for this module. Thus, we avoid loading the same JavaScript file twice.
*/
@ -271,7 +271,7 @@ loaded.
static jerry_value_t
my_module_on_resolve (void)
{
return jerry_create_external_function (very_useful_function);
return jerry_function_external (very_useful_function);
} /* my_module_on_resolve */
/* Note that there is no semicolon at the end of the next line. This is how it must be. */

12
docs/14.EXT-REFERENCE-HANDLE-SCOPE.md
View File

@ -20,7 +20,7 @@ JerryScript only supports a single nested hierarchy of scopes. There is only one
static jerry_value_t
create_object (void)
{
jerry_value_t obj = jerry_create_object ();
jerry_value_t obj = jerry_object ();
return obj;
} /* create_object */
@ -41,7 +41,7 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
test_handle_scope_val ();
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
jerry_cleanup ();
} /* main */
@ -66,7 +66,7 @@ create_object (void)
{
jerryx_escapable_handle_scope scope;
jerryx_open_escapable_handle_scope (&scope);
jerry_value_t obj = jerryx_create_handle (jerry_create_object ());
jerry_value_t obj = jerryx_create_handle (jerry_object ());
jerry_value_t escaped_obj;
jerryx_escape_handle(scope, obj, &escaped_obj);
@ -93,7 +93,7 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
test_handle_scope_val ();
jerry_gc (JERRY_GC_PRESSURE_LOW);
jerry_heap_gc (JERRY_GC_PRESSURE_LOW);
jerry_cleanup ();
} /* main */
@ -102,8 +102,8 @@ main (void)
**See also**
- [jerry_value_t](../docs/02.API-REFERENCE.md#jerry_value_t)
- [jerry_acquire_value](../docs/02.API-REFERENCE.md#jerry_acquire_value)
- [jerry_release_value](../docs/02.API-REFERENCE.md#jerry_release_value)
- [jerry_value_copy](../docs/02.API-REFERENCE.md#jerry_value_copy)
- [jerry_value_free](../docs/02.API-REFERENCE.md#jerry_value_free)
## Pre-allocated list of handle scopes and handles

6
jerry-core/CMakeLists.txt
View File

@ -38,7 +38,7 @@ set(JERRY_SNAPSHOT_EXEC OFF CACHE BOOL "Enable executing
set(JERRY_SNAPSHOT_SAVE OFF CACHE BOOL "Enable saving snapshot files?")
set(JERRY_SYSTEM_ALLOCATOR OFF CACHE BOOL "Enable system allocator?")
set(JERRY_VALGRIND OFF CACHE BOOL "Enable Valgrind support?")
set(JERRY_VM_EXEC_STOP OFF CACHE BOOL "Enable VM execution stop callback?")
set(JERRY_VM_HALT OFF CACHE BOOL "Enable VM execution stop callback?")
set(JERRY_VM_THROW OFF CACHE BOOL "Enable VM throw callback?")
set(JERRY_GLOBAL_HEAP_SIZE "(512)" CACHE STRING "Size of memory heap, in kilobytes")
set(JERRY_GC_LIMIT "(0)" CACHE STRING "Heap usage limit to trigger garbage collection")
@ -98,7 +98,7 @@ message(STATUS "JERRY_SNAPSHOT_EXEC " ${JERRY_SNAPSHOT_EXEC} ${JERRY_
message(STATUS "JERRY_SNAPSHOT_SAVE " ${JERRY_SNAPSHOT_SAVE} ${JERRY_SNAPSHOT_SAVE_MESSAGE})
message(STATUS "JERRY_SYSTEM_ALLOCATOR " ${JERRY_SYSTEM_ALLOCATOR})
message(STATUS "JERRY_VALGRIND " ${JERRY_VALGRIND})
message(STATUS "JERRY_VM_EXEC_STOP " ${JERRY_VM_EXEC_STOP})
message(STATUS "JERRY_VM_HALT " ${JERRY_VM_HALT})
message(STATUS "JERRY_VM_THROW " ${JERRY_VM_THROW})
message(STATUS "JERRY_GLOBAL_HEAP_SIZE " ${JERRY_GLOBAL_HEAP_SIZE})
message(STATUS "JERRY_GC_LIMIT " ${JERRY_GC_LIMIT})
@ -642,7 +642,7 @@ if(JERRY_VALGRIND)
endif()
# Enable VM execution stop callback
jerry_add_define01(JERRY_VM_EXEC_STOP)
jerry_add_define01(JERRY_VM_HALT)
# Enable VM throw callback
jerry_add_define01(JERRY_VM_THROW)

14
jerry-core/api/jerry-debugger.c
View File

@ -103,7 +103,7 @@ jerry_debugger_wait_for_client_source (jerry_debugger_wait_for_source_callback_t
void *user_p, /**< user pointer passed to the callback */
jerry_value_t *return_value) /**< [out] parse and run return value */
{
*return_value = jerry_create_undefined ();
*return_value = jerry_undefined ();
#if JERRY_DEBUGGER
if ((JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_CONNECTED)
@ -146,13 +146,13 @@ jerry_debugger_wait_for_client_source (jerry_debugger_wait_for_source_callback_t
{
JERRY_ASSERT (client_source_data_p != NULL);
jerry_char_t *resource_name_p = (jerry_char_t *) (client_source_data_p + 1);
size_t resource_name_size = strlen ((const char *) resource_name_p);
jerry_char_t *source_name_p = (jerry_char_t *) (client_source_data_p + 1);
size_t source_name_size = strlen ((const char *) source_name_p);
*return_value = callback_p (resource_name_p,
resource_name_size,
resource_name_p + resource_name_size + 1,
client_source_data_p->uint8_size - resource_name_size - 1,
*return_value = callback_p (source_name_p,
source_name_size,
source_name_p + source_name_size + 1,
client_source_data_p->uint8_size - source_name_size - 1,
user_p);
ret_type = JERRY_DEBUGGER_SOURCE_RECEIVED;

87
jerry-core/api/jerry-snapshot.c
View File

@ -33,23 +33,6 @@
#if JERRY_SNAPSHOT_SAVE || JERRY_SNAPSHOT_EXEC
/**
* Create an error object
*
* Note:
* - returned value must be freed with jerry_release_value, when it is no longer needed
* - the error flag is set for the returned value
*
* @return value of the constructed error object
*/
static jerry_value_t
jerry_create_error_from_id (jerry_error_t error_type, /**< type of error */
ecma_error_msg_t msg) /**< ecma_error_msg id of value of 'message' property
* of constructed error object */
{
return jerry_create_error (error_type, (jerry_char_t *) ecma_get_error_utf8 (msg));
} /* jerry_create_error_from_id */
/**
* Get snapshot configuration flags.
*
@ -159,7 +142,7 @@ snapshot_add_compiled_code (const ecma_compiled_code_t *compiled_code_p, /**< co
size_t snapshot_buffer_size, /**< snapshot buffer size */
snapshot_globals_t *globals_p) /**< snapshot globals */
{
const jerry_char_t *error_buffer_too_small_p = (const jerry_char_t *) "Snapshot buffer too small";
const char *error_buffer_too_small_p = "Snapshot buffer too small";
if (!ecma_is_value_empty (globals_p->snapshot_error))
{
@ -170,7 +153,7 @@ snapshot_add_compiled_code (const ecma_compiled_code_t *compiled_code_p, /**< co
if (globals_p->snapshot_buffer_write_offset > JERRY_SNAPSHOT_MAXIMUM_WRITE_OFFSET)
{
globals_p->snapshot_error = jerry_create_error_from_id (JERRY_ERROR_RANGE, ECMA_ERR_MAXIMUM_SNAPSHOT_SIZE);
globals_p->snapshot_error = jerry_throw_sz (JERRY_ERROR_RANGE, ecma_get_error_msg (ECMA_ERR_MAXIMUM_SNAPSHOT_SIZE));
return 0;
}
@ -184,7 +167,8 @@ snapshot_add_compiled_code (const ecma_compiled_code_t *compiled_code_p, /**< co
#if JERRY_ESNEXT
if (compiled_code_p->status_flags & CBC_CODE_FLAGS_HAS_TAGGED_LITERALS)
{
globals_p->snapshot_error = jerry_create_error_from_id (JERRY_ERROR_RANGE, ECMA_ERR_TAGGED_TEMPLATE_LITERALS);
globals_p->snapshot_error =
jerry_throw_sz (JERRY_ERROR_RANGE, ecma_get_error_msg (ECMA_ERR_TAGGED_TEMPLATE_LITERALS));
return 0;
}
@ -200,8 +184,7 @@ snapshot_add_compiled_code (const ecma_compiled_code_t *compiled_code_p, /**< co
/* Regular expression. */
if (globals_p->snapshot_buffer_write_offset + sizeof (ecma_compiled_code_t) > snapshot_buffer_size)
{
globals_p->snapshot_error =
jerry_create_error (JERRY_ERROR_RANGE, (const jerry_char_t *) error_buffer_too_small_p);
globals_p->snapshot_error = jerry_throw_sz (JERRY_ERROR_RANGE, error_buffer_too_small_p);
return 0;
}
@ -222,8 +205,7 @@ snapshot_add_compiled_code (const ecma_compiled_code_t *compiled_code_p, /**< co
buffer_p,
buffer_size))
{
globals_p->snapshot_error =
jerry_create_error (JERRY_ERROR_RANGE, (const jerry_char_t *) error_buffer_too_small_p);
globals_p->snapshot_error = jerry_throw_sz (JERRY_ERROR_RANGE, error_buffer_too_small_p);
/* cannot return inside ECMA_FINALIZE_UTF8_STRING */
}
@ -257,7 +239,7 @@ snapshot_add_compiled_code (const ecma_compiled_code_t *compiled_code_p, /**< co
compiled_code_p,
((size_t) compiled_code_p->size) << JMEM_ALIGNMENT_LOG))
{
globals_p->snapshot_error = jerry_create_error (JERRY_ERROR_RANGE, (const jerry_char_t *) error_buffer_too_small_p);
globals_p->snapshot_error = jerry_throw_sz (JERRY_ERROR_RANGE, error_buffer_too_small_p);
return 0;
}
@ -331,7 +313,7 @@ static_snapshot_error_unsupported_literal (snapshot_globals_t *globals_p, /**< s
ecma_object_t *error_object_p = ecma_new_standard_error (JERRY_ERROR_RANGE, ecma_stringbuilder_finalize (&builder));
globals_p->snapshot_error = ecma_create_error_object_reference (error_object_p);
globals_p->snapshot_error = ecma_create_exception_from_object (error_object_p);
} /* static_snapshot_error_unsupported_literal */
/**
@ -354,7 +336,7 @@ static_snapshot_add_compiled_code (const ecma_compiled_code_t *compiled_code_p,
if (globals_p->snapshot_buffer_write_offset >= JERRY_SNAPSHOT_MAXIMUM_WRITE_OFFSET)
{
globals_p->snapshot_error = jerry_create_error_from_id (JERRY_ERROR_RANGE, ECMA_ERR_MAXIMUM_SNAPSHOT_SIZE);
globals_p->snapshot_error = jerry_throw_sz (JERRY_ERROR_RANGE, ecma_get_error_msg (ECMA_ERR_MAXIMUM_SNAPSHOT_SIZE));
return 0;
}
@ -369,7 +351,7 @@ static_snapshot_add_compiled_code (const ecma_compiled_code_t *compiled_code_p,
{
/* Regular expression literals are not supported. */
globals_p->snapshot_error =
jerry_create_error_from_id (JERRY_ERROR_RANGE, ECMA_ERR_REGULAR_EXPRESSION_NOT_SUPPORTED);
jerry_throw_sz (JERRY_ERROR_RANGE, ecma_get_error_msg (ECMA_ERR_REGULAR_EXPRESSION_NOT_SUPPORTED));
return 0;
}
@ -379,7 +361,7 @@ static_snapshot_add_compiled_code (const ecma_compiled_code_t *compiled_code_p,
compiled_code_p,
((size_t) compiled_code_p->size) << JMEM_ALIGNMENT_LOG))
{
globals_p->snapshot_error = jerry_create_error_from_id (JERRY_ERROR_RANGE, ECMA_ERR_SNAPSHOT_BUFFER_SMALL);
globals_p->snapshot_error = jerry_throw_sz (JERRY_ERROR_RANGE, ecma_get_error_msg (ECMA_ERR_SNAPSHOT_BUFFER_SMALL));
return 0;
}
@ -766,7 +748,7 @@ jerry_generate_snapshot (jerry_value_t compiled_code, /**< parsed script or func
if ((generate_snapshot_opts & ~allowed_options) != 0)
{
return jerry_create_error_from_id (JERRY_ERROR_RANGE, ECMA_ERR_SNAPSHOT_FLAG_NOT_SUPPORTED);
return jerry_throw_sz (JERRY_ERROR_RANGE, ecma_get_error_msg (ECMA_ERR_SNAPSHOT_FLAG_NOT_SUPPORTED));
}
const ecma_compiled_code_t *bytecode_data_p = NULL;
@ -798,7 +780,7 @@ jerry_generate_snapshot (jerry_value_t compiled_code, /**< parsed script or func
if (JERRY_UNLIKELY (bytecode_data_p == NULL))
{
return jerry_create_error (JERRY_ERROR_RANGE, (const jerry_char_t *) "Unsupported compiled code");
return jerry_throw_sz (JERRY_ERROR_RANGE, ecma_get_error_msg (ECMA_ERR_SNAPSHOT_UNSUPPORTED_COMPILED_CODE));
}
snapshot_globals_t globals;
@ -848,7 +830,7 @@ jerry_generate_snapshot (jerry_value_t compiled_code, /**< parsed script or func
&literals_num))
{
JERRY_ASSERT (lit_map_p == NULL);
return jerry_create_error_from_id (JERRY_ERROR_COMMON, ECMA_ERR_CANNOT_ALLOCATE_MEMORY_LITERALS);
return jerry_throw_sz (JERRY_ERROR_COMMON, ecma_get_error_msg (ECMA_ERR_CANNOT_ALLOCATE_MEMORY_LITERALS));
}
jerry_snapshot_set_offsets (buffer_p + (aligned_header_size / sizeof (uint32_t)),
@ -872,7 +854,7 @@ jerry_generate_snapshot (jerry_value_t compiled_code, /**< parsed script or func
JERRY_UNUSED (buffer_p);
JERRY_UNUSED (buffer_size);
return jerry_create_error (JERRY_ERROR_COMMON, (const jerry_char_t *) "Snapshot save is not supported");
return jerry_throw_sz (JERRY_ERROR_COMMON, ecma_get_error_msg (ECMA_ERR_SNAPSHOT_SAVE_DISABLED));
#endif /* JERRY_SNAPSHOT_SAVE */
} /* jerry_generate_snapshot */
@ -880,7 +862,7 @@ jerry_generate_snapshot (jerry_value_t compiled_code, /**< parsed script or func
* Execute/load snapshot from specified buffer
*
* Note:
* returned value must be freed with jerry_release_value, when it is no longer needed.
* returned value must be freed with jerry_value_free, when it is no longer needed.
*
* @return result of bytecode - if run was successful
* thrown error - otherwise
@ -902,16 +884,15 @@ jerry_exec_snapshot (const uint32_t *snapshot_p, /**< snapshot */
if ((exec_snapshot_opts & ~(allowed_opts)) != 0)
{
ecma_raise_range_error (ECMA_ERR_UNSUPPORTED_SNAPSHOT_EXEC_FLAGS_ARE_SPECIFIED);
return ecma_create_error_reference_from_context ();
return jerry_throw_sz (JERRY_ERROR_RANGE,
ecma_get_error_msg (ECMA_ERR_UNSUPPORTED_SNAPSHOT_EXEC_FLAGS_ARE_SPECIFIED));
}
const uint8_t *snapshot_data_p = (uint8_t *) snapshot_p;
if (snapshot_size <= sizeof (jerry_snapshot_header_t))
{
ecma_raise_type_error (ECMA_ERR_INVALID_SNAPSHOT_FORMAT);
return ecma_create_error_reference_from_context ();
return jerry_throw_sz (JERRY_ERROR_TYPE, ecma_get_error_msg (ECMA_ERR_INVALID_SNAPSHOT_FORMAT));
}
const jerry_snapshot_header_t *header_p = (const jerry_snapshot_header_t *) snapshot_data_p;
@ -919,20 +900,17 @@ jerry_exec_snapshot (const uint32_t *snapshot_p, /**< snapshot */
if (header_p->magic != JERRY_SNAPSHOT_MAGIC || header_p->version != JERRY_SNAPSHOT_VERSION
|| !snapshot_check_global_flags (header_p->global_flags))
{
ecma_raise_type_error (ECMA_ERR_INVALID_SNAPSHOT_VERSION_OR_FEATURES);
return ecma_create_error_reference_from_context ();
return jerry_throw_sz (JERRY_ERROR_TYPE, ecma_get_error_msg (ECMA_ERR_INVALID_SNAPSHOT_VERSION_OR_FEATURES));
}
if (header_p->lit_table_offset > snapshot_size)
{
ecma_raise_type_error (ECMA_ERR_INVALID_SNAPSHOT_VERSION_OR_FEATURES);
return ecma_create_error_reference_from_context ();
return jerry_throw_sz (JERRY_ERROR_TYPE, ecma_get_error_msg (ECMA_ERR_INVALID_SNAPSHOT_VERSION_OR_FEATURES));
}
if (func_index >= header_p->number_of_funcs)
{
ecma_raise_range_error (ECMA_ERR_FUNCTION_INDEX_IS_HIGHER_THAN_MAXIMUM);
return ecma_create_error_reference_from_context ();
return jerry_throw_sz (JERRY_ERROR_TYPE, ecma_get_error_msg (ECMA_ERR_FUNCTION_INDEX_IS_HIGHER_THAN_MAXIMUM));
}
JERRY_ASSERT ((header_p->lit_table_offset % sizeof (uint32_t)) == 0);
@ -944,14 +922,13 @@ jerry_exec_snapshot (const uint32_t *snapshot_p, /**< snapshot */
{
if (!(exec_snapshot_opts & JERRY_SNAPSHOT_EXEC_ALLOW_STATIC))
{
ecma_raise_common_error (ECMA_ERR_STATIC_SNAPSHOTS_ARE_NOT_ENABLED);
return ecma_create_error_reference_from_context ();
return jerry_throw_sz (JERRY_ERROR_COMMON, ecma_get_error_msg (ECMA_ERR_STATIC_SNAPSHOTS_ARE_NOT_ENABLED));
}
if (exec_snapshot_opts & JERRY_SNAPSHOT_EXEC_COPY_DATA)
{
ecma_raise_common_error (ECMA_ERR_STATIC_SNAPSHOTS_CANNOT_BE_COPIED_INTO_MEMORY);
return ecma_create_error_reference_from_context ();
return jerry_throw_sz (JERRY_ERROR_COMMON,
ecma_get_error_msg (ECMA_ERR_STATIC_SNAPSHOTS_CANNOT_BE_COPIED_INTO_MEMORY));
}
}
else
@ -979,16 +956,16 @@ jerry_exec_snapshot (const uint32_t *snapshot_p, /**< snapshot */
#endif /* JERRY_BUILTIN_REALMS */
#if JERRY_RESOURCE_NAME
ecma_value_t resource_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON);
ecma_value_t source_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON);
if ((exec_snapshot_opts & JERRY_SNAPSHOT_EXEC_HAS_RESOURCE) && option_values_p != NULL
&& ecma_is_value_string (option_values_p->resource_name) > 0)
&& ecma_is_value_string (option_values_p->source_name) > 0)
{
ecma_ref_ecma_string (ecma_get_string_from_value (option_values_p->resource_name));
resource_name = option_values_p->resource_name;
ecma_ref_ecma_string (ecma_get_string_from_value (option_values_p->source_name));
source_name = option_values_p->source_name;
}
script_p->resource_name = resource_name;
script_p->source_name = source_name;
#endif /* JERRY_RESOURCE_NAME */
#if JERRY_FUNCTION_TO_STRING
@ -1061,7 +1038,7 @@ jerry_exec_snapshot (const uint32_t *snapshot_p, /**< snapshot */
if (ECMA_IS_VALUE_ERROR (ret_val))
{
return ecma_create_error_reference_from_context ();
return ecma_create_exception_from_context ();
}
return ret_val;
@ -1072,7 +1049,7 @@ jerry_exec_snapshot (const uint32_t *snapshot_p, /**< snapshot */
JERRY_UNUSED (exec_snapshot_opts);
JERRY_UNUSED (option_values_p);
return jerry_create_error (JERRY_ERROR_COMMON, (const jerry_char_t *) "Snapshot execution is not supported");
return jerry_throw_sz (JERRY_ERROR_COMMON, ecma_get_error_msg (ECMA_ERR_SNAPSHOT_EXEC_DISABLED));
#endif /* JERRY_SNAPSHOT_EXEC */
} /* jerry_exec_snapshot */

2945
jerry-core/api/jerryscript.c
View File

File diff suppressed because it is too large Load Diff

12
jerry-core/config.h
View File

@ -454,9 +454,9 @@
* 0: Disable vm exec stop callback support.
* 1: Enable vm exec stop callback support.
*/
#ifndef JERRY_VM_EXEC_STOP
#define JERRY_VM_EXEC_STOP 0
#endif /* !defined (JERRY_VM_EXEC_STOP) */
#ifndef JERRY_VM_HALT
#define JERRY_VM_HALT 0
#endif /* !defined (JERRY_VM_HALT) */
/**
* Enable/Disable the vm throw callback function.
@ -690,9 +690,9 @@
#if (JERRY_VALGRIND != 0) && (JERRY_VALGRIND != 1)
#error "Invalid value for 'JERRY_VALGRIND' macro."
#endif /* (JERRY_VALGRIND != 0) && (JERRY_VALGRIND != 1) */
#if (JERRY_VM_EXEC_STOP != 0) && (JERRY_VM_EXEC_STOP != 1)
#error "Invalid value for 'JERRY_VM_EXEC_STOP' macro."
#endif /* (JERRY_VM_EXEC_STOP != 0) && (JERRY_VM_EXEC_STOP != 1) */
#if (JERRY_VM_HALT != 0) && (JERRY_VM_HALT != 1)
#error "Invalid value for 'JERRY_VM_HALT' macro."
#endif /* (JERRY_VM_HALT != 0) && (JERRY_VM_HALT != 1) */
#if (JERRY_VM_THROW != 0) && (JERRY_VM_THROW != 1)
#error "Invalid value for 'JERRY_VM_THROW' macro."
#endif /* (JERRY_VM_THROW != 0) && (JERRY_VM_THROW != 1) */

13
jerry-core/ecma/base/ecma-error-messages.inc.h
View File

@ -31,6 +31,7 @@ ECMA_ERROR_DEF (ECMA_ERR_OBJECT_EXPECTED, "Object expected")
#if JERRY_BUILTIN_ANNEXB && JERRY_BUILTIN_REGEXP
ECMA_ERROR_DEF (ECMA_ERR_INVALID_ARGUMENT, "Invalid argument")
#endif /* JERRY_BUILTIN_ANNEXB && JERRY_BUILTIN_REGEXP */
ECMA_ERROR_DEF (ECMA_ERR_INVALID_ENCODING, "Invalid encoding")
#if JERRY_BUILTIN_REGEXP
ECMA_ERROR_DEF (ECMA_ERR_NOTHING_TO_REPEAT, "Nothing to repeat")
#endif /* JERRY_BUILTIN_REGEXP */
@ -189,6 +190,9 @@ ECMA_ERROR_DEF (ECMA_ERR_THE_STRUCTURE_IS_CYCLICAL, "The structure is cyclical")
#if JERRY_BUILTIN_REGEXP
ECMA_ERROR_DEF (ECMA_ERR_UNEXPECTED_END_OF_PATTERN, "Unexpected end of pattern")
#endif /* JERRY_BUILTIN_REGEXP */
#if JERRY_SNAPSHOT_SAVE
ECMA_ERROR_DEF (ECMA_ERR_SNAPSHOT_UNSUPPORTED_COMPILED_CODE, "Unsupported compiled code")
#endif /* JERRY_SNAPSHOT_SAVE */
#if !(JERRY_BUILTIN_BIGINT)
ECMA_ERROR_DEF (ECMA_ERR_BIGINT_NOT_SUPPORTED, "BigInt support is disabled")
#endif /* !(JERRY_BUILTIN_BIGINT) */
@ -305,6 +309,9 @@ ECMA_ERROR_DEF (ECMA_ERR_PRIVATE_METHOD_IS_NOT_WRITABLE, "Private method is not
ECMA_ERROR_DEF (ECMA_ERR_RADIX_IS_OUT_OF_RANGE, "Radix must be between 2 and 36")
#endif /* JERRY_BUILTIN_BIGINT \
|| JERRY_BUILTIN_NUMBER */
#if !(JERRY_SNAPSHOT_EXEC)
ECMA_ERROR_DEF (ECMA_ERR_SNAPSHOT_EXEC_DISABLED, "Snapshot execution is disabled")
#endif /* !(JERRY_SNAPSHOT_EXEC) */
#if !(JERRY_BUILTIN_TYPEDARRAY)
ECMA_ERROR_DEF (ECMA_ERR_TYPED_ARRAY_NOT_SUPPORTED, "TypedArray support is disabled")
#endif /* !(JERRY_BUILTIN_TYPEDARRAY) */
@ -318,6 +325,9 @@ ECMA_ERROR_DEF (ECMA_ERR_ITERATOR_NEXT_IS_NOT_CALLABLE, "Iterator 'next' is not
ECMA_ERROR_DEF (ECMA_ERR_ITERATOR_VALUE_IS_NOT_AN_OBJECT, "Iterator value is not an object")
ECMA_ERROR_DEF (ECMA_ERR_RESOLVE_METHOD_MUST_BE_CALLABLE, "Resolve method must be callable")
#endif /* JERRY_ESNEXT */
#if !(JERRY_SNAPSHOT_SAVE)
ECMA_ERROR_DEF (ECMA_ERR_SNAPSHOT_SAVE_DISABLED, "Snapshot generation is disabled")
#endif /* !(JERRY_SNAPSHOT_SAVE) */
#if !(JERRY_PARSER)
ECMA_ERROR_DEF (ECMA_ERR_PARSER_NOT_SUPPORTED, "Source code parsing is disabled")
#endif /* !(JERRY_PARSER) */
@ -384,9 +394,6 @@ ECMA_ERROR_DEF (ECMA_ERR_CALLBACK_IS_NOT_CALLABLE, "Callback function is not cal
#if JERRY_BUILTIN_TYPEDARRAY
ECMA_ERROR_DEF (ECMA_ERR_INITIAL_VALUE_CANNOT_BE_UNDEFINED, "Initial value cannot be undefined")
#endif /* JERRY_BUILTIN_TYPEDARRAY */
#if JERRY_BUILTIN_REGEXP
ECMA_ERROR_DEF (ECMA_ERR_INPUT_MUST_BE_A_VALID_UTF8_STRING, "Input must be a valid utf8 string")
#endif /* JERRY_BUILTIN_REGEXP */
#if JERRY_BUILTIN_SHAREDARRAYBUFFER
ECMA_ERROR_DEF (ECMA_ERR_INVALID_SHARED_ARRAYBUFFER_LENGTH, "Invalid Shared ArrayBuffer length")
#endif /* JERRY_BUILTIN_SHAREDARRAYBUFFER */

5
jerry-core/ecma/base/ecma-error-messages.ini
View File

@ -120,7 +120,6 @@ ECMA_ERR_INCORRECT_RETURN_PROXY_GET_TRAP = "Incorrect value is returned by a Pro
ECMA_ERR_INCORRECT_RETURN_PROXY_SET_TRAP = "Incorrect value is returned by a Proxy 'set' trap"
ECMA_ERR_INFINITY_OR_NAN_CANNOT_BE_CONVERTED_TO_BIGINT = "Infinity or NaN cannot be converted to BigInt"
ECMA_ERR_INITIAL_VALUE_CANNOT_BE_UNDEFINED = "Initial value cannot be undefined"
ECMA_ERR_INPUT_MUST_BE_A_VALID_UTF8_STRING = "Input must be a valid utf8 string"
ECMA_ERR_INVALID_ARRAYBUFFER_LENGTH = "Invalid ArrayBuffer length"
ECMA_ERR_INVALID_JSON_FORMAT = "Invalid JSON format"
ECMA_ERR_INVALID_REGEXP_FLAGS = "Invalid RegExp flags"
@ -129,6 +128,7 @@ ECMA_ERR_INVALID_TYPEDARRAY_LENGTH = "Invalid TypedArray length"
ECMA_ERR_INVALID_UTF8_CHARACTER = "Invalid UTF8 character"
ECMA_ERR_INVALID_UTF8_CODEPOINT = "Invalid UTF8 codepoint"
ECMA_ERR_INVALID_UTF8_STRING = "Invalid UTF8 string"
ECMA_ERR_INVALID_ENCODING = "Invalid encoding"
ECMA_ERR_INVALID_ARGUMENT = "Invalid argument"
ECMA_ERR_INVALID_ARGUMENT_IS_PASSED_TO_REGEXP_FUNCTION = "Invalid argument is passed to RegExp function"
ECMA_ERR_INVALID_ARGUMENT_TYPE_IN_TOPRIMITIVE = "Invalid argument type in toPrimitive"
@ -305,7 +305,10 @@ ECMA_ERR_LET_CONST_NOT_INITIALIZED = "Variables declared by let/const must be in
ECMA_ERR_MAXIMUM_SNAPSHOT_SIZE = "Maximum snapshot size reached"
ECMA_ERR_REGULAR_EXPRESSION_NOT_SUPPORTED = "Regular expression literals are not supported"
ECMA_ERR_SNAPSHOT_BUFFER_SMALL = "Snapshot buffer too small"
ECMA_ERR_SNAPSHOT_UNSUPPORTED_COMPILED_CODE = "Unsupported compiled code"
ECMA_ERR_SNAPSHOT_FLAG_NOT_SUPPORTED = "Unsupported generate snapshot flags specified"
ECMA_ERR_SNAPSHOT_SAVE_DISABLED = "Snapshot generation is disabled"
ECMA_ERR_SNAPSHOT_EXEC_DISABLED = "Snapshot execution is disabled"
ECMA_ERR_CANNOT_ALLOCATE_MEMORY_LITERALS = "Cannot allocate memory for literals"
ECMA_ERR_TAGGED_TEMPLATE_LITERALS = "Unsupported feature: tagged template literals"
ECMA_ERR_CONTAINER_NEEDED = "Value is not a Container or Iterator"

14
jerry-core/ecma/base/ecma-errors.c
View File

@ -21,15 +21,15 @@
*/
typedef struct
{
lit_utf8_byte_t *text; /* Text of ecma error message. */
char *text; /* Text of ecma error message. */
uint8_t size; /* Size of ecma error message. */
} ecma_error_message_t;
/* Error message texts with size. */
static ecma_error_message_t ecma_error_messages[] JERRY_ATTR_CONST_DATA = {
{ (lit_utf8_byte_t *) "", 0 }, /* ECMA_ERR_EMPTY */
{ "", 0 }, /* ECMA_ERR_EMPTY */
/** @cond doxygen_suppress */
#define ECMA_ERROR_DEF(id, utf8_string) { (lit_utf8_byte_t *) utf8_string, sizeof (utf8_string) - 1 },
#define ECMA_ERROR_DEF(id, string) { string, sizeof (string) - 1 },
#include "ecma-error-messages.inc.h"
#undef ECMA_ERROR_DEF
/** @endcond */
@ -41,8 +41,8 @@ static ecma_error_message_t ecma_error_messages[] JERRY_ATTR_CONST_DATA = {
*
* @return pointer to zero-terminated ecma error
*/
const lit_utf8_byte_t *
ecma_get_error_utf8 (uint32_t id) /**< ecma error id */
const char *
ecma_get_error_msg (ecma_error_msg_t id) /**< ecma error id */
{
JERRY_ASSERT (id != ECMA_IS_VALID_CONSTRUCTOR);
@ -51,7 +51,7 @@ ecma_get_error_utf8 (uint32_t id) /**< ecma error id */
#else /* !JERRY_ERROR_MESSAGES */
return NULL;
#endif /* JERRY_ERROR_MESSAGES */
} /* ecma_get_error_utf8 */
} /* ecma_get_error_msg */
/**
* Get size of specified ecma error
@ -59,7 +59,7 @@ ecma_get_error_utf8 (uint32_t id) /**< ecma error id */
* @return size in bytes
*/
lit_utf8_size_t
ecma_get_error_size (uint32_t id) /**< ecma error id */
ecma_get_error_size (ecma_error_msg_t id) /**< ecma error id */
{
JERRY_ASSERT (id != ECMA_IS_VALID_CONSTRUCTOR);

4
jerry-core/ecma/base/ecma-errors.h
View File

@ -33,7 +33,7 @@ typedef enum
ECMA_IS_VALID_CONSTRUCTOR /* used as return value when checking constructor */
} ecma_error_msg_t;
const lit_utf8_byte_t* ecma_get_error_utf8 (uint32_t id);
lit_utf8_size_t ecma_get_error_size (uint32_t id);
const char* ecma_get_error_msg (ecma_error_msg_t id);
lit_utf8_size_t ecma_get_error_size (ecma_error_msg_t id);
#endif /* !ECMA_ERRORS_H */

4
jerry-core/ecma/base/ecma-gc.c
View File

@ -1300,7 +1300,7 @@ ecma_gc_free_native_pointer (ecma_property_t property, /**< property descriptor
if (native_pointer_p->native_info_p != NULL)
{
jerry_object_native_free_callback_t free_cb = native_pointer_p->native_info_p->free_cb;
jerry_object_native_free_cb_t free_cb = native_pointer_p->native_info_p->free_cb;
if (free_cb != NULL)
{
@ -1324,7 +1324,7 @@ ecma_gc_free_native_pointer (ecma_property_t property, /**< property descriptor
{
if (item_p->data.native_info_p != NULL)
{
jerry_object_native_free_callback_t free_cb = item_p->data.native_info_p->free_cb;
jerry_object_native_free_cb_t free_cb = item_p->data.native_info_p->free_cb;
if (free_cb != NULL)
{

16
jerry-core/ecma/base/ecma-globals.h
View File

@ -56,7 +56,7 @@
*/
typedef enum
{
ECMA_STATUS_API_AVAILABLE = (1u << 0), /**< api available */
ECMA_STATUS_API_ENABLED = (1u << 0), /**< api available */
ECMA_STATUS_DIRECT_EVAL = (1u << 1), /**< eval is called directly */
#if JERRY_PROPERTY_HASHMAP
ECMA_STATUS_HIGH_PRESSURE_GC = (1u << 2), /**< last gc was under high pressure */
@ -1763,14 +1763,14 @@ typedef struct
#endif /* !defined (JERRY_BUILTIN_BIGINT) */
/**
* Abort flag for errors in C API.
* Flags for exception values.
*/
#define ECMA_ERROR_API_ABORT (1u << 0)
/**
* Throw captured flag for errors in C API.
*/
#define ECMA_ERROR_API_THROW_CAPTURED (1u << 1)
typedef enum
{
ECMA_ERROR_API_FLAG_NONE = 0,
ECMA_ERROR_API_FLAG_ABORT = (1u << 0), /**< abort flag */
ECMA_ERROR_API_FLAG_THROW_CAPTURED = (1u << 1), /**< throw captured flag */
} ecma_error_api_flags_t;
/**
* Representation of a thrown value on API level.

368
jerry-core/ecma/base/ecma-helpers-string.c
View File

@ -488,7 +488,7 @@ ecma_new_ecma_external_string_from_cesu8 (const lit_utf8_byte_t *string_p, /**<
/* Normal strings are created for short strings. */
ecma_string_t *string_desc_p = ecma_new_ecma_string_from_utf8 (string_p, string_size);
jerry_external_string_free_callback_t free_cb = JERRY_CONTEXT (external_string_free_callback_p);
jerry_external_string_free_cb_t free_cb = JERRY_CONTEXT (external_string_free_callback_p);
if (free_cb != NULL)
{
@ -501,7 +501,7 @@ ecma_new_ecma_external_string_from_cesu8 (const lit_utf8_byte_t *string_p, /**<
if (string_desc_p != NULL)
{
jerry_external_string_free_callback_t free_cb = JERRY_CONTEXT (external_string_free_callback_p);
jerry_external_string_free_cb_t free_cb = JERRY_CONTEXT (external_string_free_callback_p);
if (free_cb != NULL)
{
@ -974,7 +974,7 @@ ecma_destroy_ecma_string (ecma_string_t *string_p) /**< ecma-string */
}
ecma_external_string_t *external_string_p = (ecma_external_string_t *) string_p;
jerry_external_string_free_callback_t free_cb = JERRY_CONTEXT (external_string_free_callback_p);
jerry_external_string_free_cb_t free_cb = JERRY_CONTEXT (external_string_free_callback_p);
if (free_cb != NULL)
{
@ -1078,31 +1078,44 @@ ecma_string_get_array_index (const ecma_string_t *str_p) /**< ecma-string */
} /* ecma_string_get_array_index */
/**
* Convert ecma-string's contents to a cesu-8 string and put it to the buffer.
* It is the caller's responsibility to make sure that the string fits in the buffer.
* Copy digits of uint32 number, truncating if buffer is not large enough.
*
* @return number of bytes, actually copied to the buffer.
* @return number of digits copied
*/
static lit_utf8_size_t
ecma_uint32_to_buffer (uint32_t num, /**< number */
lit_utf8_byte_t *buffer_p /**< destination buffer */,
lit_utf8_size_t buffer_size /**< buffer size */)
{
lit_utf8_byte_t digits[ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32];
lit_utf8_size_t digit_count = ecma_uint32_to_utf8_string (num, digits, ECMA_MAX_CHARS_IN_STRINGIFIED_UINT32);
digit_count = JERRY_MIN (buffer_size, digit_count);
memcpy (buffer_p, digits, digit_count);
return digit_count;
} /* ecma_uint32_to_buffer */
/**
* Convert ecma-string's contents to the specified encoding and copy it to the buffer.
* String data will be truncated to fit the buffer.
*
* @return number of bytes copied to the buffer.
*/
lit_utf8_size_t JERRY_ATTR_WARN_UNUSED_RESULT
ecma_string_copy_to_cesu8_buffer (const ecma_string_t *string_p, /**< ecma-string descriptor */
lit_utf8_byte_t *buffer_p, /**< destination buffer pointer
* (can be NULL if buffer_size == 0) */
lit_utf8_size_t buffer_size) /**< size of buffer */
ecma_string_copy_to_buffer (const ecma_string_t *string_p, /**< ecma-string descriptor */
lit_utf8_byte_t *buffer_p, /**< destination buffer pointer
* (can be NULL if buffer_size == 0) */
lit_utf8_size_t buffer_size, /**< size of buffer */
jerry_encoding_t encoding) /**< encoding */
{
JERRY_ASSERT (string_p != NULL);
JERRY_ASSERT (buffer_p != NULL || buffer_size == 0);
JERRY_ASSERT (ecma_string_get_size (string_p) <= buffer_size);
lit_utf8_size_t size;
if (ECMA_IS_DIRECT_STRING (string_p))
{
if (ECMA_IS_DIRECT_STRING_WITH_TYPE (string_p, ECMA_DIRECT_STRING_UINT))
{
uint32_t uint32_number = (uint32_t) ECMA_GET_DIRECT_STRING_VALUE (string_p);
size = ecma_uint32_to_utf8_string (uint32_number, buffer_p, buffer_size);
JERRY_ASSERT (size <= buffer_size);
return size;
return ecma_uint32_to_buffer ((uint32_t) ECMA_GET_DIRECT_STRING_VALUE (string_p), buffer_p, buffer_size);
}
}
else
@ -1111,295 +1124,55 @@ ecma_string_copy_to_cesu8_buffer (const ecma_string_t *string_p, /**< ecma-strin
if (ECMA_STRING_GET_CONTAINER (string_p) == ECMA_STRING_CONTAINER_UINT32_IN_DESC)
{
uint32_t uint32_number = string_p->u.uint32_number;
size = ecma_uint32_to_utf8_string (uint32_number, buffer_p, buffer_size);
JERRY_ASSERT (size <= buffer_size);
return size;
return ecma_uint32_to_buffer (string_p->u.uint32_number, buffer_p, buffer_size);
}
}
const lit_utf8_byte_t *chars_p = ecma_string_get_chars_fast (string_p, &size);
JERRY_ASSERT (chars_p != NULL);
JERRY_ASSERT (size <= buffer_size);
memcpy (buffer_p, chars_p, size);
return size;
} /* ecma_string_copy_to_cesu8_buffer */
/**
* Convert ecma-string's contents to an utf-8 string and put it to the buffer.
* It is the caller's responsibility to make sure that the string fits in the buffer.
*
* @return number of bytes, actually copied to the buffer.
*/
lit_utf8_size_t JERRY_ATTR_WARN_UNUSED_RESULT
ecma_string_copy_to_utf8_buffer (const ecma_string_t *string_p, /**< ecma-string descriptor */
lit_utf8_byte_t *buffer_p, /**< destination buffer pointer
* (can be NULL if buffer_size == 0) */
lit_utf8_size_t buffer_size) /**< size of buffer */
{
JERRY_ASSERT (string_p != NULL);
JERRY_ASSERT (buffer_p != NULL || buffer_size == 0);
JERRY_ASSERT (ecma_string_get_utf8_size (string_p) <= buffer_size);
lit_utf8_size_t size;
if (ECMA_IS_DIRECT_STRING (string_p))
{
if (ECMA_IS_DIRECT_STRING_WITH_TYPE (string_p, ECMA_DIRECT_STRING_UINT))
{
uint32_t uint32_number = (uint32_t) ECMA_GET_DIRECT_STRING_VALUE (string_p);
size = ecma_uint32_to_utf8_string (uint32_number, buffer_p, buffer_size);
JERRY_ASSERT (size <= buffer_size);
return size;
}
}
else
{
JERRY_ASSERT (string_p->refs_and_container >= ECMA_STRING_REF_ONE);
if (ECMA_STRING_GET_CONTAINER (string_p) == ECMA_STRING_CONTAINER_UINT32_IN_DESC)
{
uint32_t uint32_number = string_p->u.uint32_number;
size = ecma_uint32_to_utf8_string (uint32_number, buffer_p, buffer_size);
JERRY_ASSERT (size <= buffer_size);
return size;
}
}
uint8_t flags = ECMA_STRING_FLAG_IS_ASCII;
const lit_utf8_byte_t *chars_p = ecma_string_get_chars (string_p, &size, NULL, NULL, &flags);
lit_utf8_size_t string_size;
const lit_utf8_byte_t *chars_p = ecma_string_get_chars_fast (string_p, &string_size);
lit_utf8_size_t copy_size = 0;
JERRY_ASSERT (chars_p != NULL);
if (flags & ECMA_STRING_FLAG_IS_ASCII)
switch (encoding)
{
JERRY_ASSERT (size <= buffer_size);
memcpy (buffer_p, chars_p, size);
return size;
}
size = lit_convert_cesu8_string_to_utf8_string (chars_p, size, buffer_p, buffer_size);
if (flags & ECMA_STRING_FLAG_MUST_BE_FREED)
{
jmem_heap_free_block ((void *) chars_p, size);
}
JERRY_ASSERT (size <= buffer_size);
return size;
} /* ecma_string_copy_to_utf8_buffer */
/**
* Convert ecma-string's contents to a cesu-8 string, extract the parts of the converted string between the specified
* start position and the end position (or the end of the string, whichever comes first), and copy these characters
* into the buffer.
*
* @return number of bytes, actually copied to the buffer.
*/
lit_utf8_size_t
ecma_substring_copy_to_cesu8_buffer (const ecma_string_t *string_desc_p, /**< ecma-string descriptor */
lit_utf8_size_t start_pos, /**< position of the first character */
lit_utf8_size_t end_pos, /**< position of the last character */
lit_utf8_byte_t *buffer_p, /**< destination buffer pointer
* (can be NULL if buffer_size == 0) */
lit_utf8_size_t buffer_size) /**< size of buffer */
{
JERRY_ASSERT (string_desc_p != NULL);
JERRY_ASSERT (buffer_p != NULL || buffer_size == 0);
lit_utf8_size_t string_length = ecma_string_get_length (string_desc_p);
lit_utf8_size_t size = 0;
if (start_pos >= string_length || start_pos >= end_pos)
{
return 0;
}
if (end_pos > string_length)
{
end_pos = string_length;
}
ECMA_STRING_TO_UTF8_STRING (string_desc_p, utf8_str_p, utf8_str_size);
const lit_utf8_byte_t *start_p = utf8_str_p;
if (string_length == utf8_str_size)
{
start_p += start_pos;
size = end_pos - start_pos;
if (size > buffer_size)
case JERRY_ENCODING_CESU8:
{
size = buffer_size;
}
copy_size = JERRY_MIN (string_size, buffer_size);
memcpy (buffer_p, start_p, size);
}
else
{
end_pos -= start_pos;
while (start_pos--)
{
start_p += lit_get_unicode_char_size_by_utf8_first_byte (*start_p);
}
const lit_utf8_byte_t *end_p = start_p;
while (end_pos--)
{
lit_utf8_size_t code_unit_size = lit_get_unicode_char_size_by_utf8_first_byte (*end_p);
if ((size + code_unit_size) > buffer_size)
if (copy_size < string_size)
{
/* Do not copy partial characters */
while ((chars_p[copy_size] & LIT_UTF8_EXTRA_BYTE_MASK) == LIT_UTF8_EXTRA_BYTE_MARKER)
{
copy_size--;
}
}
memcpy (buffer_p, chars_p, copy_size);
break;
}
case JERRY_ENCODING_UTF8:
{
if (string_size == ecma_string_get_length (string_p))
{
copy_size = JERRY_MIN (string_size, buffer_size);
memcpy (buffer_p, chars_p, copy_size);
break;
}
end_p += code_unit_size;
size += code_unit_size;
copy_size = lit_convert_cesu8_string_to_utf8_string (chars_p, string_size, buffer_p, buffer_size);
break;
}
memcpy (buffer_p, start_p, size);
}
ECMA_FINALIZE_UTF8_STRING (utf8_str_p, utf8_str_size);
JERRY_ASSERT (size <= buffer_size);
return size;
} /* ecma_substring_copy_to_cesu8_buffer */
/**
* Convert ecma-string's contents to an utf-8 string, extract the parts of the converted string between the specified
* start position and the end position (or the end of the string, whichever comes first), and copy these characters
* into the buffer.
*
* @return number of bytes, actually copied to the buffer.
*/
lit_utf8_size_t
ecma_substring_copy_to_utf8_buffer (const ecma_string_t *string_desc_p, /**< ecma-string descriptor */
lit_utf8_size_t start_pos, /**< position of the first character */
lit_utf8_size_t end_pos, /**< position of the last character */
lit_utf8_byte_t *buffer_p, /**< destination buffer pointer
* (can be NULL if buffer_size == 0) */
lit_utf8_size_t buffer_size) /**< size of buffer */
{
JERRY_ASSERT (string_desc_p != NULL);
JERRY_ASSERT (ECMA_IS_DIRECT_STRING (string_desc_p) || string_desc_p->refs_and_container >= ECMA_STRING_REF_ONE);
JERRY_ASSERT (buffer_p != NULL || buffer_size == 0);
lit_utf8_size_t size = 0;
lit_utf8_size_t utf8_str_length = ecma_string_get_utf8_length (string_desc_p);
if (start_pos >= utf8_str_length || start_pos >= end_pos)
{
return 0;
}
if (end_pos > utf8_str_length)
{
end_pos = utf8_str_length;
}
ECMA_STRING_TO_UTF8_STRING (string_desc_p, cesu8_str_p, cesu8_str_size);
lit_utf8_size_t cesu8_str_length = ecma_string_get_length (string_desc_p);
if (cesu8_str_length == cesu8_str_size)
{
cesu8_str_p += start_pos;
size = end_pos - start_pos;
if (size > buffer_size)
default:
{
size = buffer_size;
break;
}
memcpy (buffer_p, cesu8_str_p, size);
}
else
{
const lit_utf8_byte_t *cesu8_end_pos = cesu8_str_p + cesu8_str_size;
end_pos -= start_pos;
while (start_pos--)
{
ecma_char_t ch;
lit_utf8_size_t code_unit_size = lit_read_code_unit_from_cesu8 (cesu8_str_p, &ch);
cesu8_str_p += code_unit_size;
if ((cesu8_str_p != cesu8_end_pos) && lit_is_code_point_utf16_high_surrogate (ch))
{
ecma_char_t next_ch;
lit_utf8_size_t next_ch_size = lit_read_code_unit_from_cesu8 (cesu8_str_p, &next_ch);
if (lit_is_code_point_utf16_low_surrogate (next_ch))
{
JERRY_ASSERT (code_unit_size == next_ch_size);
cesu8_str_p += code_unit_size;
}
}
}
const lit_utf8_byte_t *cesu8_pos = cesu8_str_p;
lit_utf8_byte_t *utf8_pos = buffer_p;
lit_utf8_byte_t *utf8_end_pos = buffer_p + buffer_size;
while (end_pos--)
{
ecma_char_t ch;
lit_utf8_size_t code_unit_size = lit_read_code_unit_from_cesu8 (cesu8_pos, &ch);
if ((size + code_unit_size) > buffer_size)
{
break;
}
if (((cesu8_pos + code_unit_size) != cesu8_end_pos) && lit_is_code_point_utf16_high_surrogate (ch))
{
ecma_char_t next_ch;
lit_utf8_size_t next_ch_size = lit_read_code_unit_from_cesu8 (cesu8_pos + code_unit_size, &next_ch);
if (lit_is_code_point_utf16_low_surrogate (next_ch))
{
JERRY_ASSERT (code_unit_size == next_ch_size);
if ((size + code_unit_size + 1) > buffer_size)
{
break;
}
cesu8_pos += next_ch_size;
lit_code_point_t code_point = lit_convert_surrogate_pair_to_code_point (ch, next_ch);
lit_code_point_to_utf8 (code_point, utf8_pos);
size += (code_unit_size + 1);
}
else
{
memcpy (utf8_pos, cesu8_pos, code_unit_size);
size += code_unit_size;
}
}
else
{
memcpy (utf8_pos, cesu8_pos, code_unit_size);
size += code_unit_size;
}
utf8_pos = buffer_p + size;
cesu8_pos += code_unit_size;
}
JERRY_ASSERT (utf8_pos <= utf8_end_pos);
}
ECMA_FINALIZE_UTF8_STRING (cesu8_str_p, cesu8_str_size);
JERRY_ASSERT (size <= buffer_size);
return size;
} /* ecma_substring_copy_to_utf8_buffer */
return copy_size;
} /* ecma_string_copy_to_buffer */
/**
* Convert ecma-string's contents to a cesu-8 string and put it to the buffer.
@ -1407,14 +1180,14 @@ ecma_substring_copy_to_utf8_buffer (const ecma_string_t *string_desc_p, /**< ecm
* Check if the size of the string is equal with the size of the buffer.
*/
extern inline void JERRY_ATTR_ALWAYS_INLINE
ecma_string_to_utf8_bytes (const ecma_string_t *string_desc_p, /**< ecma-string descriptor */
lit_utf8_byte_t *buffer_p, /**< destination buffer pointer
* (can be NULL if buffer_size == 0) */
lit_utf8_size_t buffer_size) /**< size of buffer */
ecma_string_to_cesu8_bytes (const ecma_string_t *string_desc_p, /**< ecma-string descriptor */
lit_utf8_byte_t *buffer_p, /**< destination buffer pointer
* (can be NULL if buffer_size == 0) */
lit_utf8_size_t buffer_size) /**< size of buffer */
{
const lit_utf8_size_t size = ecma_string_copy_to_cesu8_buffer (string_desc_p, buffer_p, buffer_size);
const lit_utf8_size_t size = ecma_string_copy_to_buffer (string_desc_p, buffer_p, buffer_size, JERRY_ENCODING_CESU8);
JERRY_ASSERT (size == buffer_size);
} /* ecma_string_to_utf8_bytes */
} /* ecma_string_to_cesu8_bytes */
/**
* Get size of the uint32 number stored locally in the string's descriptor
@ -2707,9 +2480,7 @@ ecma_stringbuilder_create_from (ecma_string_t *string_p) /**< ecma string */
jmem_stats_allocate_string_bytes (initial_size);
#endif /* JERRY_MEM_STATS */
size_t copied_size =
ecma_string_copy_to_cesu8_buffer (string_p, ECMA_STRINGBUILDER_STRING_PTR (header_p), string_size);
JERRY_ASSERT (copied_size == string_size);
ecma_string_to_cesu8_bytes (string_p, ECMA_STRINGBUILDER_STRING_PTR (header_p), string_size);
ecma_stringbuilder_t ret = { .header_p = header_p };
return ret;
@ -2822,8 +2593,7 @@ ecma_stringbuilder_append (ecma_stringbuilder_t *builder_p, /**< string builder
const lit_utf8_size_t string_size = ecma_string_get_size (string_p);
lit_utf8_byte_t *dest_p = ecma_stringbuilder_grow (builder_p, string_size);
size_t copied_size = ecma_string_copy_to_cesu8_buffer (string_p, dest_p, string_size);
JERRY_ASSERT (copied_size == string_size);
ecma_string_to_cesu8_bytes (string_p, dest_p, string_size);
} /* ecma_stringbuilder_append */
/**

4
jerry-core/ecma/base/ecma-helpers-value.c
View File

@ -424,10 +424,10 @@ ecma_is_value_object (ecma_value_t value) /**< ecma value */
* false - otherwise
*/
extern inline bool JERRY_ATTR_CONST JERRY_ATTR_ALWAYS_INLINE
ecma_is_value_error_reference (ecma_value_t value) /**< ecma value */
ecma_is_value_exception (ecma_value_t value) /**< ecma value */
{
return (ecma_get_value_type_field (value) == ECMA_TYPE_ERROR);
} /* ecma_is_value_error_reference */
} /* ecma_is_value_exception */
/**
* Debug assertion that specified value's type is one of ECMA-defined

52
jerry-core/ecma/base/ecma-helpers.c
View File

@ -1254,7 +1254,7 @@ ecma_ref_extended_primitive (ecma_extended_primitive_t *primitve_p) /**< extende
* Decrease ref count of an error reference.
*/
void
ecma_deref_error_reference (ecma_extended_primitive_t *error_ref_p) /**< error reference */
ecma_deref_exception (ecma_extended_primitive_t *error_ref_p) /**< error reference */
{
JERRY_ASSERT (error_ref_p->refs_and_type >= ECMA_EXTENDED_PRIMITIVE_REF_ONE);
@ -1265,7 +1265,7 @@ ecma_deref_error_reference (ecma_extended_primitive_t *error_ref_p) /**< error r
ecma_free_value (error_ref_p->u.value);
jmem_pools_free (error_ref_p, sizeof (ecma_extended_primitive_t));
}
} /* ecma_deref_error_reference */
} /* ecma_deref_exception */
#if JERRY_BUILTIN_BIGINT
@ -1303,8 +1303,8 @@ ecma_deref_bigint (ecma_extended_primitive_t *bigint_p) /**< bigint value */
* @return error reference value
*/
ecma_value_t
ecma_create_error_reference (ecma_value_t value, /**< referenced value */
uint32_t options) /**< ECMA_ERROR_API_* options */
ecma_create_exception (ecma_value_t value, /**< referenced value */
uint32_t options) /**< ECMA_ERROR_API_* options */
{
ecma_extended_primitive_t *error_ref_p;
error_ref_p = (ecma_extended_primitive_t *) jmem_pools_alloc (sizeof (ecma_extended_primitive_t));
@ -1312,7 +1312,7 @@ ecma_create_error_reference (ecma_value_t value, /**< referenced value */
error_ref_p->refs_and_type = ECMA_EXTENDED_PRIMITIVE_REF_ONE | options;
error_ref_p->u.value = value;
return ecma_make_extended_primitive_value (error_ref_p, ECMA_TYPE_ERROR);
} /* ecma_create_error_reference */
} /* ecma_create_exception */
/**
* Create an error reference from the currently thrown error value.
@ -1320,47 +1320,47 @@ ecma_create_error_reference (ecma_value_t value, /**< referenced value */
* @return error reference value
*/
ecma_value_t
ecma_create_error_reference_from_context (void)
ecma_create_exception_from_context (void)
{
uint32_t options = 0;
uint32_t status_flags = JERRY_CONTEXT (status_flags);
if (status_flags & ECMA_STATUS_ABORT)
{
options |= ECMA_ERROR_API_ABORT;
options |= ECMA_ERROR_API_FLAG_ABORT;
}
#if JERRY_VM_THROW
if (status_flags & ECMA_STATUS_ERROR_THROWN)
{
options |= ECMA_ERROR_API_THROW_CAPTURED;
options |= ECMA_ERROR_API_FLAG_THROW_CAPTURED;
}
#endif /* JERRY_VM_THROW */
return ecma_create_error_reference (jcontext_take_exception (), options);
} /* ecma_create_error_reference_from_context */
return ecma_create_exception (jcontext_take_exception (), options);
} /* ecma_create_exception_from_context */
/**
* Create an error reference from a given object.
* Create an exception from a given object.
*
* Note:
* Reference of the value is taken.
* Reference of the object is taken.
*
* @return error reference value
* @return exception value
*/
extern inline ecma_value_t JERRY_ATTR_ALWAYS_INLINE
ecma_create_error_object_reference (ecma_object_t *object_p) /**< referenced object */
ecma_create_exception_from_object (ecma_object_t *object_p) /**< referenced object */
{
return ecma_create_error_reference (ecma_make_object_value (object_p), 0);
} /* ecma_create_error_object_reference */
return ecma_create_exception (ecma_make_object_value (object_p), 0);
} /* ecma_create_exception_from_object */
/**
* Raise error from the given error reference.
* Raise a new exception from the argument exception value.
*
* Note: the error reference's ref count is also decreased
* Note: the argument exceptions reference count is decreased
*/
void
ecma_raise_error_from_error_reference (ecma_value_t value) /**< error reference */
ecma_throw_exception (ecma_value_t value) /**< error reference */
{
JERRY_ASSERT (!jcontext_has_pending_exception () && !jcontext_has_pending_abort ());
ecma_extended_primitive_t *error_ref_p = ecma_get_extended_primitive_from_value (value);
@ -1376,13 +1376,13 @@ ecma_raise_error_from_error_reference (ecma_value_t value) /**< error reference
#endif /* JERRY_VM_THROW */
| ECMA_STATUS_ABORT);
if (!(error_ref_p->refs_and_type & ECMA_ERROR_API_ABORT))
if (!(error_ref_p->refs_and_type & ECMA_ERROR_API_FLAG_ABORT))
{
status_flags &= ~(uint32_t) ECMA_STATUS_ABORT;
}
#if JERRY_VM_THROW
if (!(error_ref_p->refs_and_type & ECMA_ERROR_API_THROW_CAPTURED))
if (!(error_ref_p->refs_and_type & ECMA_ERROR_API_FLAG_THROW_CAPTURED))
{
status_flags &= ~(uint32_t) ECMA_STATUS_ERROR_THROWN;
}
@ -1401,7 +1401,7 @@ ecma_raise_error_from_error_reference (ecma_value_t value) /**< error reference
}
JERRY_CONTEXT (error_value) = referenced_value;
} /* ecma_raise_error_from_error_reference */
} /* ecma_throw_exception */
/**
* Decrease the reference counter of a script value.
@ -1434,7 +1434,7 @@ ecma_script_deref (ecma_value_t script_value) /**< script value */
}
#if JERRY_RESOURCE_NAME
ecma_deref_ecma_string (ecma_get_string_from_value (script_p->resource_name));
ecma_deref_ecma_string (ecma_get_string_from_value (script_p->source_name));
#endif /* JERRY_RESOURCE_NAME */
#if JERRY_MODULE_SYSTEM
@ -1778,7 +1778,7 @@ ecma_compiled_code_get_line_info (const ecma_compiled_code_t *bytecode_header_p)
* @return resource name value
*/
ecma_value_t
ecma_get_resource_name (const ecma_compiled_code_t *bytecode_p) /**< compiled code */
ecma_get_source_name (const ecma_compiled_code_t *bytecode_p) /**< compiled code */
{
#if JERRY_RESOURCE_NAME
#if JERRY_SNAPSHOT_EXEC
@ -1789,12 +1789,12 @@ ecma_get_resource_name (const ecma_compiled_code_t *bytecode_p) /**< compiled co
#endif /* JERRY_SNAPSHOT_EXEC */
ecma_value_t script_value = ((cbc_uint8_arguments_t *) bytecode_p)->script_value;
return ECMA_GET_INTERNAL_VALUE_POINTER (cbc_script_t, script_value)->resource_name;
return ECMA_GET_INTERNAL_VALUE_POINTER (cbc_script_t, script_value)->source_name;
#else /* !JERRY_RESOURCE_NAME */
JERRY_UNUSED (bytecode_p);
return ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON);
#endif /* !JERRY_RESOURCE_NAME */
} /* ecma_get_resource_name */
} /* ecma_get_source_name */
#if (JERRY_STACK_LIMIT != 0)
/**

36
jerry-core/ecma/base/ecma-helpers.h
View File

@ -227,7 +227,7 @@ bool JERRY_ATTR_CONST ecma_is_value_prop_name (ecma_value_t value);
bool JERRY_ATTR_CONST ecma_is_value_direct_string (ecma_value_t value);
bool JERRY_ATTR_CONST ecma_is_value_non_direct_string (ecma_value_t value);
bool JERRY_ATTR_CONST ecma_is_value_object (ecma_value_t value);
bool JERRY_ATTR_CONST ecma_is_value_error_reference (ecma_value_t value);
bool JERRY_ATTR_CONST ecma_is_value_exception (ecma_value_t value);
ecma_value_t ecma_is_value_array (ecma_value_t arg);
void ecma_check_value_type_is_spec_defined (ecma_value_t value);
@ -316,24 +316,12 @@ void ecma_destroy_ecma_string (ecma_string_t *string_p);
ecma_number_t ecma_string_to_number (const ecma_string_t *str_p);
uint32_t ecma_string_get_array_index (const ecma_string_t *str_p);
lit_utf8_size_t JERRY_ATTR_WARN_UNUSED_RESULT ecma_string_copy_to_cesu8_buffer (const ecma_string_t *string_desc_p,
lit_utf8_byte_t *buffer_p,
lit_utf8_size_t buffer_size);
lit_utf8_size_t JERRY_ATTR_WARN_UNUSED_RESULT ecma_string_copy_to_utf8_buffer (const ecma_string_t *string_desc_p,
lit_utf8_byte_t *buffer_p,
lit_utf8_size_t buffer_size);
lit_utf8_size_t ecma_substring_copy_to_cesu8_buffer (const ecma_string_t *string_desc_p,
lit_utf8_size_t start_pos,
lit_utf8_size_t end_pos,
lit_utf8_byte_t *buffer_p,
lit_utf8_size_t buffer_size);
lit_utf8_size_t ecma_substring_copy_to_utf8_buffer (const ecma_string_t *string_desc_p,
lit_utf8_size_t start_pos,
lit_utf8_size_t end_pos,
lit_utf8_byte_t *buffer_p,
lit_utf8_size_t buffer_size);
lit_utf8_size_t JERRY_ATTR_WARN_UNUSED_RESULT ecma_string_copy_to_buffer (const ecma_string_t *string_desc_p,
lit_utf8_byte_t *buffer_p,
lit_utf8_size_t buffer_size,
jerry_encoding_t encoding);
void
ecma_string_to_utf8_bytes (const ecma_string_t *string_desc_p, lit_utf8_byte_t *buffer_p, lit_utf8_size_t buffer_size);
ecma_string_to_cesu8_bytes (const ecma_string_t *string_desc_p, lit_utf8_byte_t *buffer_p, lit_utf8_size_t buffer_size);
const lit_utf8_byte_t *ecma_string_get_chars (const ecma_string_t *string_p,
lit_utf8_size_t *size_p,
lit_utf8_size_t *length_p,
@ -498,15 +486,15 @@ ecma_property_descriptor_t ecma_make_empty_property_descriptor (void);
void ecma_free_property_descriptor (ecma_property_descriptor_t *prop_desc_p);
void ecma_ref_extended_primitive (ecma_extended_primitive_t *primitve_p);
void ecma_deref_error_reference (ecma_extended_primitive_t *error_ref_p);
void ecma_deref_exception (ecma_extended_primitive_t *exception_p);
#if JERRY_BUILTIN_BIGINT
void ecma_deref_bigint (ecma_extended_primitive_t *bigint_p);
#endif /* JERRY_BUILTIN_BIGINT */
ecma_value_t ecma_create_error_reference (ecma_value_t value, uint32_t options);
ecma_value_t ecma_create_error_reference_from_context (void);
ecma_value_t ecma_create_error_object_reference (ecma_object_t *object_p);
void ecma_raise_error_from_error_reference (ecma_value_t value);
ecma_value_t ecma_create_exception (ecma_value_t value, uint32_t options);
ecma_value_t ecma_create_exception_from_context (void);
ecma_value_t ecma_create_exception_from_object (ecma_object_t *object_p);
void ecma_throw_exception (ecma_value_t value);
void ecma_script_deref (ecma_value_t script_value);
void ecma_bytecode_ref (ecma_compiled_code_t *bytecode_p);
@ -520,7 +508,7 @@ ecma_collection_t *ecma_compiled_code_get_tagged_template_collection (const ecma
#if JERRY_LINE_INFO
uint8_t *ecma_compiled_code_get_line_info (const ecma_compiled_code_t *bytecode_header_p);
#endif /* JERRY_LINE_INFO */
ecma_value_t ecma_get_resource_name (const ecma_compiled_code_t *bytecode_p);
ecma_value_t ecma_get_source_name (const ecma_compiled_code_t *bytecode_p);
#if (JERRY_STACK_LIMIT != 0)
uintptr_t ecma_get_current_stack_usage (void);
#endif /* (JERRY_STACK_LIMIT != 0) */

2
jerry-core/ecma/base/ecma-line-info.c
View File

@ -116,7 +116,7 @@ ecma_line_info_free (uint8_t *line_info_p) /**< line info buffer */
void
ecma_line_info_get (uint8_t *line_info_p, /**< line info buffer */
uint32_t offset, /**< byte code offset */
jerry_backtrace_location_t *location_p) /**< [out] location */
jerry_frame_location_t *location_p) /**< [out] location */
{
uint32_t line = 1;
uint32_t column = ECMA_LINE_INFO_COLUMN_DEFAULT;

2
jerry-core/ecma/base/ecma-line-info.h
View File

@ -98,7 +98,7 @@ uint32_t ecma_line_info_difference_update (uint32_t current_value, uint32_t diff
/* General functions. */
void ecma_line_info_free (uint8_t *line_info_p);
void ecma_line_info_get (uint8_t *line_info_p, uint32_t offset, jerry_backtrace_location_t *location_p);
void ecma_line_info_get (uint8_t *line_info_p, uint32_t offset, jerry_frame_location_t *location_p);
#if JERRY_PARSER_DUMP_BYTE_CODE
void ecma_line_info_dump (uint8_t *line_info_p);

2
jerry-core/ecma/base/ecma-literal-storage.c
View File

@ -633,7 +633,7 @@ ecma_save_literals_for_snapshot (ecma_collection_t *lit_pool_p, /**< list of kno
*(uint16_t *) destination_p = (uint16_t) length;
ecma_string_to_utf8_bytes (string_p, destination_p + sizeof (uint16_t), length);
ecma_string_to_cesu8_bytes (string_p, destination_p + sizeof (uint16_t), length);
length = JERRY_ALIGNUP (sizeof (uint16_t) + length, JERRY_SNAPSHOT_LITERAL_ALIGNMENT);
}

14
jerry-core/ecma/base/ecma-module.c
View File

@ -563,9 +563,9 @@ ecma_module_evaluate (ecma_module_t *module_p) /**< module */
{
ret_value = module_p->u.callback (ecma_make_object_value (&module_p->header.object));
if (JERRY_UNLIKELY (ecma_is_value_error_reference (ret_value)))
if (JERRY_UNLIKELY (ecma_is_value_exception (ret_value)))
{
ecma_raise_error_from_error_reference (ret_value);
ecma_throw_exception (ret_value);
ret_value = ECMA_VALUE_ERROR;
}
}
@ -1099,7 +1099,7 @@ typedef struct ecma_module_stack_item_t
*/
ecma_value_t
ecma_module_link (ecma_module_t *module_p, /**< root module */
jerry_module_resolve_callback_t callback, /**< resolve module callback */
jerry_module_resolve_cb_t callback, /**< resolve module callback */
void *user_p) /**< pointer passed to the resolve callback */
{
if (module_p->header.u.cls.u1.module_state != JERRY_MODULE_STATE_UNLINKED)
@ -1141,9 +1141,9 @@ restart:
ecma_value_t resolve_result = callback (node_p->u.path_or_module, module_val, user_p);
if (JERRY_UNLIKELY (ecma_is_value_error_reference (resolve_result)))
if (JERRY_UNLIKELY (ecma_is_value_exception (resolve_result)))
{
ecma_raise_error_from_error_reference (resolve_result);
ecma_throw_exception (resolve_result);
goto error;
}
@ -1373,9 +1373,9 @@ ecma_module_import (ecma_value_t specifier, /**< module specifier */
JERRY_CONTEXT (module_import_callback_user_p));
ecma_deref_ecma_string (specifier_p);
if (JERRY_UNLIKELY (ecma_is_value_error_reference (result)))
if (JERRY_UNLIKELY (ecma_is_value_exception (result)))
{
ecma_raise_error_from_error_reference (result);
ecma_throw_exception (result);
goto error;
}

4
jerry-core/ecma/base/ecma-module.h
View File

@ -68,7 +68,7 @@ typedef struct ecma_module
union
{
ecma_compiled_code_t *compiled_code_p; /**< compiled code for the module */
jerry_native_module_evaluate_callback_t callback; /**< callback for evaluating native modules */
jerry_native_module_evaluate_cb_t callback; /**< callback for evaluating native modules */
} u;
} ecma_module_t;
@ -117,7 +117,7 @@ typedef struct ecma_module_resolve_stack
ecma_value_t ecma_module_initialize (ecma_module_t *module_p);
ecma_module_t *ecma_module_get_resolved_module (ecma_value_t module_val);
ecma_value_t ecma_module_link (ecma_module_t *module_p, jerry_module_resolve_callback_t callback_p, void *user_p);
ecma_value_t ecma_module_link (ecma_module_t *module_p, jerry_module_resolve_cb_t callback_p, void *user_p);
ecma_value_t ecma_module_evaluate (ecma_module_t *module_p);
ecma_value_t ecma_module_import (ecma_value_t specifier, ecma_value_t user_value);

2
jerry-core/ecma/builtin-objects/ecma-builtin-async-from-sync-iterator-prototype.c
View File

@ -255,7 +255,7 @@ ecma_builtin_async_from_sync_iterator_prototype_do (ecma_async_from_sync_iterato
ecma_free_value (call_result);
#if JERRY_ERROR_MESSAGES
const lit_utf8_byte_t *msg_p = ecma_get_error_utf8 (ECMA_ERR_ARGUMENT_IS_NOT_AN_OBJECT);
const lit_utf8_byte_t *msg_p = (lit_utf8_byte_t *) ecma_get_error_msg (ECMA_ERR_ARGUMENT_IS_NOT_AN_OBJECT);
lit_utf8_size_t msg_size = ecma_get_error_size (ECMA_ERR_ARGUMENT_IS_NOT_AN_OBJECT);
ecma_string_t *error_msg_p = ecma_new_ecma_string_from_ascii (msg_p, msg_size);
#else /* !JERRY_ERROR_MESSAGES */

2
jerry-core/ecma/builtin-objects/ecma-builtin-global.c
View File

@ -649,7 +649,7 @@ ecma_builtin_global_dispatch_routine (uint8_t builtin_routine_id, /**< built-in
JMEM_DEFINE_LOCAL_ARRAY (input_start_p, input_size + 1, lit_utf8_byte_t);
ecma_string_to_utf8_bytes (str_p, input_start_p, input_size);
ecma_string_to_cesu8_bytes (str_p, input_start_p, input_size);
input_start_p[input_size] = LIT_BYTE_NULL;

8
jerry-core/ecma/builtin-objects/ecma-builtin-helpers.c
View File

@ -54,11 +54,12 @@ ecma_builtin_helper_object_to_string_tag_helper (ecma_value_t tag_value) /**< st
JERRY_ASSERT (ecma_is_value_string (tag_value));
ecma_string_t *tag_str_p = ecma_get_string_from_value (tag_value);
lit_utf8_size_t tag_str_size = ecma_string_get_size (tag_str_p);
ecma_string_t *ret_string_p;
/* Building string "[object #@@toStringTag#]"
The string size will be size("[object ") + size(#@@toStringTag#) + size ("]"). */
const lit_utf8_size_t buffer_size = 9 + ecma_string_get_size (tag_str_p);
const lit_utf8_size_t buffer_size = 9 + tag_str_size;
JMEM_DEFINE_LOCAL_ARRAY (str_buffer, buffer_size, lit_utf8_byte_t);
lit_utf8_byte_t *buffer_ptr = str_buffer;
@ -80,9 +81,8 @@ ecma_builtin_helper_object_to_string_tag_helper (ecma_value_t tag_value) /**< st
}
/* Copy to buffer the #@@toStringTag# string */
buffer_ptr += ecma_string_copy_to_cesu8_buffer (tag_str_p,
buffer_ptr,
(lit_utf8_size_t) ((str_buffer + buffer_size) - buffer_ptr));
ecma_string_to_cesu8_bytes (tag_str_p, buffer_ptr, tag_str_size);
buffer_ptr += tag_str_size;
JERRY_ASSERT (buffer_ptr <= str_buffer + buffer_size);

16
jerry-core/ecma/builtin-objects/ecma-builtin-json.c
View File

@ -133,6 +133,22 @@ ecma_builtin_json_parse_string (ecma_json_token_t *token_p) /**< token argument
break;
}
if (*current_p >= LIT_UTF8_4_BYTE_MARKER)
{
ecma_stringbuilder_append_raw (&result_builder, unappended_p, (lit_utf8_size_t) (current_p - unappended_p));
JERRY_ASSERT (current_p + 4 <= end_p);
lit_code_point_t cp;
lit_utf8_size_t read_size = lit_read_code_point_from_utf8 (current_p, 4, &cp);
JERRY_ASSERT (read_size == 4);
ecma_stringbuilder_append_codepoint (&result_builder, cp);
current_p += 4;
unappended_p = current_p;
continue;
}
if (*current_p == LIT_CHAR_BACKSLASH)
{
ecma_stringbuilder_append_raw (&result_builder, unappended_p, (lit_utf8_size_t) (current_p - unappended_p));

8
jerry-core/ecma/builtin-objects/ecma-builtin-string-prototype.c
View File

@ -1277,11 +1277,13 @@ ecma_builtin_string_prototype_object_repeat (ecma_string_t *original_string_p, /
JMEM_DEFINE_LOCAL_ARRAY (str_buffer, total_size, lit_utf8_byte_t);
lit_utf8_byte_t *buffer_ptr = str_buffer;
ecma_string_to_cesu8_bytes (original_string_p, str_buffer, size);
lit_utf8_byte_t *buffer_ptr = str_buffer + size;
for (int32_t n = 0; n < repeat_count; n++)
for (int32_t n = 1; n < repeat_count; n++)
{
buffer_ptr += ecma_string_copy_to_cesu8_buffer (original_string_p, buffer_ptr, (lit_utf8_size_t) (size));
memcpy (buffer_ptr, str_buffer, size);
buffer_ptr += size;
}
ret_string_p = ecma_new_ecma_string_from_utf8 (str_buffer, (lit_utf8_size_t) (buffer_ptr - str_buffer));

4
jerry-core/ecma/operations/ecma-arraybuffer-object.c
View File

@ -140,7 +140,7 @@ ecma_arraybuffer_allocate_buffer (ecma_object_t *arraybuffer_p) /**< ArrayBuffer
ecma_extended_object_t *extended_object_p = (ecma_extended_object_t *) arraybuffer_p;
uint32_t arraybuffer_length = extended_object_p->u.cls.u3.length;
ecma_arraybuffer_pointer_t *arraybuffer_pointer_p = (ecma_arraybuffer_pointer_t *) arraybuffer_p;
jerry_arraybuffer_allocate_t arraybuffer_allocate_callback = JERRY_CONTEXT (arraybuffer_allocate_callback);
jerry_arraybuffer_allocate_cb_t arraybuffer_allocate_callback = JERRY_CONTEXT (arraybuffer_allocate_callback);
uint8_t *buffer_p;
if (arraybuffer_allocate_callback != NULL)
@ -212,7 +212,7 @@ ecma_arraybuffer_release_buffer (ecma_object_t *arraybuffer_p) /**< ArrayBuffer
JERRY_ASSERT (ecma_object_class_is (arraybuffer_p, ECMA_OBJECT_CLASS_ARRAY_BUFFER)
|| ecma_object_is_shared_arraybuffer (arraybuffer_p));
jerry_arraybuffer_free_t free_callback = JERRY_CONTEXT (arraybuffer_free_callback);
jerry_arraybuffer_free_cb_t free_callback = JERRY_CONTEXT (arraybuffer_free_callback);
ecma_arraybuffer_pointer_t *arraybuffer_pointer_p = (ecma_arraybuffer_pointer_t *) arraybuffer_p;
uint32_t arraybuffer_length = arraybuffer_pointer_p->extended_object.u.cls.u3.length;

17
jerry-core/ecma/operations/ecma-exceptions.c
View File

@ -300,13 +300,14 @@ ecma_get_error_type (ecma_object_t *error_object_p) /**< possible error object *
*/
ecma_value_t
ecma_raise_standard_error (jerry_error_t error_type, /**< error type */
const lit_utf8_byte_t *msg_p) /**< error message */
const char *msg_p) /**< error message */
{
ecma_object_t *error_obj_p;
const lit_utf8_byte_t *str_p = (lit_utf8_byte_t *) msg_p;
if (msg_p != NULL)
{
ecma_string_t *error_msg_p = ecma_new_ecma_string_from_utf8 (msg_p, lit_zt_utf8_string_size (msg_p));
ecma_string_t *error_msg_p = ecma_new_ecma_string_from_utf8 (str_p, lit_zt_utf8_string_size (str_p));
error_obj_p = ecma_new_standard_error (error_type, error_msg_p);
ecma_deref_ecma_string (error_msg_p);
}
@ -416,7 +417,7 @@ ecma_raise_standard_error_with_format (jerry_error_t error_type, /**< error type
ecma_value_t
ecma_raise_common_error (ecma_error_msg_t msg) /**< error message */
{
return ecma_raise_standard_error (JERRY_ERROR_COMMON, ecma_get_error_utf8 (msg));
return ecma_raise_standard_error (JERRY_ERROR_COMMON, ecma_get_error_msg (msg));
} /* ecma_raise_common_error */
/**
@ -430,7 +431,7 @@ ecma_raise_common_error (ecma_error_msg_t msg) /**< error message */
ecma_value_t
ecma_raise_range_error (ecma_error_msg_t msg) /**< error message */
{
return ecma_raise_standard_error (JERRY_ERROR_RANGE, ecma_get_error_utf8 (msg));
return ecma_raise_standard_error (JERRY_ERROR_RANGE, ecma_get_error_msg (msg));
} /* ecma_raise_range_error */
/**
@ -444,7 +445,7 @@ ecma_raise_range_error (ecma_error_msg_t msg) /**< error message */
ecma_value_t
ecma_raise_reference_error (ecma_error_msg_t msg) /**< error message */
{
return ecma_raise_standard_error (JERRY_ERROR_REFERENCE, ecma_get_error_utf8 (msg));
return ecma_raise_standard_error (JERRY_ERROR_REFERENCE, ecma_get_error_msg (msg));
} /* ecma_raise_reference_error */
/**
@ -458,7 +459,7 @@ ecma_raise_reference_error (ecma_error_msg_t msg) /**< error message */
ecma_value_t
ecma_raise_syntax_error (ecma_error_msg_t msg) /**< error message */
{
return ecma_raise_standard_error (JERRY_ERROR_SYNTAX, ecma_get_error_utf8 (msg));
return ecma_raise_standard_error (JERRY_ERROR_SYNTAX, ecma_get_error_msg (msg));
} /* ecma_raise_syntax_error */
/**
@ -472,7 +473,7 @@ ecma_raise_syntax_error (ecma_error_msg_t msg) /**< error message */
ecma_value_t
ecma_raise_type_error (ecma_error_msg_t msg) /**< error message */
{
return ecma_raise_standard_error (JERRY_ERROR_TYPE, ecma_get_error_utf8 (msg));
return ecma_raise_standard_error (JERRY_ERROR_TYPE, ecma_get_error_msg (msg));
} /* ecma_raise_type_error */
/**
@ -486,7 +487,7 @@ ecma_raise_type_error (ecma_error_msg_t msg) /**< error message */
ecma_value_t
ecma_raise_uri_error (ecma_error_msg_t msg) /**< error message */
{
return ecma_raise_standard_error (JERRY_ERROR_URI, ecma_get_error_utf8 (msg));
return ecma_raise_standard_error (JERRY_ERROR_URI, ecma_get_error_msg (msg));
} /* ecma_raise_uri_error */
#if (JERRY_STACK_LIMIT != 0)

2
jerry-core/ecma/operations/ecma-exceptions.h
View File

@ -32,7 +32,7 @@ ecma_object_t *ecma_new_standard_error (jerry_error_t error_type, ecma_string_t
#if JERRY_ERROR_MESSAGES
ecma_value_t ecma_raise_standard_error_with_format (jerry_error_t error_type, const char *msg_p, ...);
#endif /* JERRY_ERROR_MESSAGES */
ecma_value_t ecma_raise_standard_error (jerry_error_t error_type, const lit_utf8_byte_t *msg_p);
ecma_value_t ecma_raise_standard_error (jerry_error_t error_type, const char *msg_p);
ecma_value_t ecma_raise_common_error (ecma_error_msg_t msg);
ecma_value_t ecma_raise_range_error (ecma_error_msg_t msg);
ecma_value_t ecma_raise_reference_error (ecma_error_msg_t msg);

4
jerry-core/ecma/operations/ecma-function-object.c
View File

@ -1287,9 +1287,9 @@ ecma_op_function_call_native (ecma_object_t *func_obj_p, /**< Function object */
JERRY_CONTEXT (global_object_p) = saved_global_object_p;
#endif /* JERRY_BUILTIN_REALMS */
if (JERRY_UNLIKELY (ecma_is_value_error_reference (ret_value)))
if (JERRY_UNLIKELY (ecma_is_value_exception (ret_value)))
{
ecma_raise_error_from_error_reference (ret_value);
ecma_throw_exception (ret_value);
return ECMA_VALUE_ERROR;
}

1382
jerry-core/include/jerryscript-core.h
View File

File diff suppressed because it is too large Load Diff

4
jerry-core/include/jerryscript-debugger.h
View File

@ -47,8 +47,8 @@ typedef enum
*
* @return this value is passed back by jerry_debugger_wait_and_run_client_source
*/
typedef jerry_value_t (*jerry_debugger_wait_for_source_callback_t) (const jerry_char_t *resource_name_p,
size_t resource_name_size,
typedef jerry_value_t (*jerry_debugger_wait_for_source_callback_t) (const jerry_char_t *source_name_p,
size_t source_name_size,
const jerry_char_t *source_p,
size_t source_size,
void *user_p);

8
jerry-core/include/jerryscript-snapshot.h
View File

@ -45,7 +45,7 @@ typedef enum
JERRY_SNAPSHOT_EXEC_COPY_DATA = (1u << 0), /**< copy snashot data */
JERRY_SNAPSHOT_EXEC_ALLOW_STATIC = (1u << 1), /**< static snapshots allowed */
JERRY_SNAPSHOT_EXEC_LOAD_AS_FUNCTION = (1u << 2), /**< load snapshot as function instead of executing it */
JERRY_SNAPSHOT_EXEC_HAS_RESOURCE = (1u << 3), /**< resource_name field is valid
JERRY_SNAPSHOT_EXEC_HAS_RESOURCE = (1u << 3), /**< source_name field is valid
* in jerry_exec_snapshot_option_values_t */
JERRY_SNAPSHOT_EXEC_HAS_USER_VALUE = (1u << 4), /**< user_value field is valid
* in jerry_exec_snapshot_option_values_t */
@ -56,9 +56,9 @@ typedef enum
*/
typedef struct
{
jerry_value_t resource_name; /**< resource name string (usually a file name)
* if JERRY_SNAPSHOT_EXEC_HAS_RESOURCE is set in exec_snapshot_opts
* Note: non-string values are ignored */
jerry_value_t source_name; /**< resource name string (usually a file name)
* if JERRY_SNAPSHOT_EXEC_HAS_RESOURCE is set in exec_snapshot_opts
* Note: non-string values are ignored */
jerry_value_t user_value; /**< user value assigned to all functions created by this script including
* eval calls executed by the script if JERRY_SNAPSHOT_EXEC_HAS_USER_VALUE
* is set in exec_snapshot_opts */

183
jerry-core/include/jerryscript-types.h
View File

@ -24,25 +24,11 @@
JERRY_C_API_BEGIN
/** \addtogroup jerry Jerry engine interface
/**
* @defgroup jerry-api-types JerryScript public API types
* @{
*/
/**
* Major version of JerryScript API.
*/
#define JERRY_API_MAJOR_VERSION 3
/**
* Minor version of JerryScript API.
*/
#define JERRY_API_MINOR_VERSION 0
/**
* Patch version of JerryScript API.
*/
#define JERRY_API_PATCH_VERSION 0
/**
* JerryScript init flags.
*/
@ -52,8 +38,6 @@ typedef enum
JERRY_INIT_SHOW_OPCODES = (1u << 0), /**< dump byte-code to log after parse */
JERRY_INIT_SHOW_REGEXP_OPCODES = (1u << 1), /**< dump regexp byte-code to log after compilation */
JERRY_INIT_MEM_STATS = (1u << 2), /**< dump memory statistics */
JERRY_INIT_MEM_STATS_SEPARATE = (1u << 3), /**< deprecated, an unused placeholder now */
JERRY_INIT_DEBUGGER = (1u << 4), /**< deprecated, an unused placeholder now */
} jerry_init_flag_t;
/**
@ -81,7 +65,7 @@ typedef enum
JERRY_FEATURE_CPOINTER_32_BIT, /**< 32 bit compressed pointers */
JERRY_FEATURE_ERROR_MESSAGES, /**< error messages */
JERRY_FEATURE_JS_PARSER, /**< js-parser */
JERRY_FEATURE_MEM_STATS, /**< memory statistics */
JERRY_FEATURE_HEAP_STATS, /**< memory statistics */
JERRY_FEATURE_PARSER_DUMP, /**< parser byte-code dumps */
JERRY_FEATURE_REGEXP_DUMP, /**< regexp byte-code dumps */
JERRY_FEATURE_SNAPSHOT_SAVE, /**< saving snapshot files */
@ -167,7 +151,7 @@ typedef enum
JERRY_PARSE_MODULE = (1 << 1), /**< parse source as an ECMAScript module */
JERRY_PARSE_HAS_ARGUMENT_LIST = (1 << 2), /**< argument_list field is valid,
* this also means that function parsing will be done */
JERRY_PARSE_HAS_RESOURCE = (1 << 3), /**< resource_name field is valid */
JERRY_PARSE_HAS_SOURCE_NAME = (1 << 3), /**< source_name field is valid */
JERRY_PARSE_HAS_START = (1 << 4), /**< start_line and start_column fields are valid */
JERRY_PARSE_HAS_USER_VALUE = (1 << 5), /**< user_value field is valid */
} jerry_parse_option_enable_feature_t;
@ -180,9 +164,9 @@ typedef struct
uint32_t options; /**< combination of jerry_parse_option_enable_feature_t values */
jerry_value_t argument_list; /**< function argument list if JERRY_PARSE_HAS_ARGUMENT_LIST is set in options
* Note: must be string value */
jerry_value_t resource_name; /**< resource name string (usually a file name)
* if JERRY_PARSE_HAS_RESOURCE is set in options
* Note: must be string value */
jerry_value_t source_name; /**< source name string (usually a file name)
* if JERRY_PARSE_HAS_SOURCE_NAME is set in options
* Note: must be string value */
uint32_t start_line; /**< start line of the source code if JERRY_PARSE_HAS_START is set in options */
uint32_t start_column; /**< start column of the source code if JERRY_PARSE_HAS_START is set in options */
jerry_value_t user_value; /**< user value assigned to all functions created by this script including eval
@ -245,6 +229,15 @@ typedef enum
* integer index property keys as numbers. */
} jerry_property_filter_t;
/**
* String encoding.
*/
typedef enum
{
JERRY_ENCODING_CESU8, /**< cesu-8 encoding */
JERRY_ENCODING_UTF8, /**< utf-8 encoding */
} jerry_encoding_t;
/**
* Description of JerryScript heap memory stats.
* It is for memory profiling.
@ -278,7 +271,7 @@ typedef jerry_value_t (*jerry_external_handler_t) (const jerry_call_info_t *call
/**
* Native free callback of generic value types.
*/
typedef void (*jerry_value_free_callback_t) (void *native_p);
typedef void (*jerry_value_free_cb_t) (void *native_p);
/**
* Forward definition of jerry_object_native_info_t.
@ -288,59 +281,63 @@ struct jerry_object_native_info_t;
/**
* Native free callback of an object.
*/
typedef void (*jerry_object_native_free_callback_t) (void *native_p, struct jerry_object_native_info_t *info_p);
typedef void (*jerry_object_native_free_cb_t) (void *native_p, struct jerry_object_native_info_t *info_p);
/**
* Free callback for external strings.
*/
typedef void (*jerry_external_string_free_callback_t) (jerry_char_t *string_p, jerry_size_t string_size, void *user_p);
typedef void (*jerry_external_string_free_cb_t) (jerry_char_t *string_p, jerry_size_t string_size, void *user_p);
/**
* Decorator callback for Error objects. The decorator can create
* or update any properties of the newly created Error object.
*/
typedef void (*jerry_error_object_created_callback_t) (const jerry_value_t error_object, void *user_p);
typedef void (*jerry_error_object_created_cb_t) (const jerry_value_t error_object, void *user_p);
/**
* Callback which tells whether the ECMAScript execution should be stopped.
*
* As long as the function returns with undefined the execution continues.
* When a non-undefined value is returned the execution stops and the value
* is thrown by the engine (if the error flag is not set for the returned
* value the engine automatically sets it).
* is thrown by the engine as an exception.
*
* Note: if the function returns with a non-undefined value it
* must return with the same value for future calls.
*/
typedef jerry_value_t (*jerry_vm_exec_stop_callback_t) (void *user_p);
typedef jerry_value_t (*jerry_halt_cb_t) (void *user_p);
/**
* Callback function which is called when an error is thrown in an ECMAScript code.
* The callback should not change the error_value. The callback is not called again
* Callback function which is called when an exception is thrown in an ECMAScript code.
* The callback should not change the exception_value. The callback is not called again
* until the value is caught.
*
* Note: the engine considers errors thrown by external functions as never caught.
* Note: the engine considers exceptions thrown by external functions as never caught.
*/
typedef void (*jerry_vm_throw_callback_t) (const jerry_value_t error_value, void *user_p);
typedef void (*jerry_throw_cb_t) (const jerry_value_t exception_value, void *user_p);
/**
* Function type applied each byte of a string
*/
typedef void (*jerry_string_iterate_cb_t) (uint8_t byte, void *user_p);
/**
* Function type applied for each data property of an object.
*/
typedef bool (*jerry_object_property_foreach_t) (const jerry_value_t property_name,
const jerry_value_t property_value,
void *user_data_p);
typedef bool (*jerry_object_property_foreach_cb_t) (const jerry_value_t property_name,
const jerry_value_t property_value,
void *user_data_p);
/**
* Function type applied for each object in the engine.
*/
typedef bool (*jerry_objects_foreach_t) (const jerry_value_t object, void *user_data_p);
typedef bool (*jerry_foreach_live_object_cb_t) (const jerry_value_t object, void *user_data_p);
/**
* Function type applied for each matching object in the engine.
*/
typedef bool (*jerry_objects_foreach_by_native_info_t) (const jerry_value_t object,
void *object_data_p,
void *user_data_p);
typedef bool (*jerry_foreach_live_object_with_info_cb_t) (const jerry_value_t object,
void *object_data_p,
void *user_data_p);
/**
* User context item manager
@ -349,7 +346,7 @@ typedef struct
{
/**
* Callback responsible for initializing a context item, or NULL to zero out the memory. This is called lazily, the
* first time jerry_get_context_data () is called with this manager.
* first time jerry_context_data () is called with this manager.
*
* @param [in] data The buffer that JerryScript allocated for the manager. The buffer is zeroed out. The size is
* determined by the bytes_needed field. The buffer is kept alive until jerry_cleanup () is called.
@ -382,7 +379,7 @@ typedef struct
/**
* Number of bytes to allocate for this manager. This is the size of the buffer that JerryScript will allocate on
* behalf of the manager. The pointer to this buffer is passed into init_cb, deinit_cb and finalize_cb. It is also
* returned from the jerry_get_context_data () API.
* returned from the jerry_context_data () API.
*/
size_t bytes_needed;
} jerry_context_data_manager_t;
@ -390,14 +387,14 @@ typedef struct
/**
* Function type for allocating buffer for JerryScript context.
*/
typedef void *(*jerry_context_alloc_t) (size_t size, void *cb_data_p);
typedef void *(*jerry_context_alloc_cb_t) (size_t size, void *cb_data_p);
/**
* Type information of a native pointer.
*/
typedef struct jerry_object_native_info_t
{
jerry_object_native_free_callback_t free_cb; /**< the free callback of the native pointer */
jerry_object_native_free_cb_t free_cb; /**< the free callback of the native pointer */
uint16_t number_of_references; /**< the number of value references which are marked by the garbage collector */
uint16_t offset_of_references; /**< byte offset indicating the start offset of value
* references in the user allocated buffer */
@ -425,44 +422,44 @@ typedef enum
JERRY_BIN_OP_MUL, /**< multiplication operator (*) */
JERRY_BIN_OP_DIV, /**< division operator (/) */
JERRY_BIN_OP_REM, /**< remainder operator (%) */
} jerry_binary_operation_t;
} jerry_binary_op_t;
/**
* Backtrace related types.
*/
/**
* List of backtrace frame types returned by jerry_backtrace_get_frame_type.
* List of backtrace frame types returned by jerry_frame_type.
*/
typedef enum
{
JERRY_BACKTRACE_FRAME_JS, /**< indicates that the frame is created for a JavaScript function/method */
} jerry_backtrace_frame_types_t;
} jerry_frame_type_t;
/**
* Location info retrieved by jerry_backtrace_get_location.
* Location info retrieved by jerry_frame_location.
*/
typedef struct
{
jerry_value_t resource_name; /**< resource name */
jerry_value_t source_name; /**< resource name */
jerry_size_t line; /**< line index */
jerry_size_t column; /**< column index */
} jerry_backtrace_location_t;
} jerry_frame_location_t;
/*
* Internal data structure for jerry_frame_t definition.
*/
struct jerry_frame_internal_t;
/**
* Internal data structure for jerry_backtrace_frame_t definition.
* Backtrace frame data passed to the jerry_backtrace_cb_t handler.
*/
struct jerry_backtrace_frame_internal_t;
typedef struct jerry_frame_internal_t jerry_frame_t;
/**
* Backtrace frame data passed to the jerry_backtrace_callback_t handler.
* Callback function which is called by jerry_backtrace for each stack frame.
*/
typedef struct jerry_backtrace_frame_internal_t jerry_backtrace_frame_t;
/**
* Callback function which is called by jerry_backtrace_capture for each stack frame.
*/
typedef bool (*jerry_backtrace_callback_t) (jerry_backtrace_frame_t *frame_p, void *user_p);
typedef bool (*jerry_backtrace_cb_t) (jerry_frame_t *frame_p, void *user_p);
/**
* Detailed value type related types.
@ -481,7 +478,7 @@ typedef enum
JERRY_TYPE_STRING, /**< string type */
JERRY_TYPE_OBJECT, /**< object type */
JERRY_TYPE_FUNCTION, /**< function type */
JERRY_TYPE_ERROR, /**< error/abort type */
JERRY_TYPE_EXCEPTION, /**< exception/abort type */
JERRY_TYPE_SYMBOL, /**< symbol type */
JERRY_TYPE_BIGINT, /**< bigint type */
} jerry_type_t;
@ -500,9 +497,9 @@ typedef enum
JERRY_OBJECT_TYPE_MODULE, /**< Module object (see jerry_parse) */
JERRY_OBJECT_TYPE_PROMISE, /**< Promise object */
JERRY_OBJECT_TYPE_DATAVIEW, /**< Dataview object */
JERRY_OBJECT_TYPE_FUNCTION, /**< Function object (see jerry_function_get_type) */
JERRY_OBJECT_TYPE_TYPEDARRAY, /**< %TypedArray% object (see jerry_get_typedarray_type) */
JERRY_OBJECT_TYPE_ITERATOR, /**< Iterator object (see jerry_iterator_get_type) */
JERRY_OBJECT_TYPE_FUNCTION, /**< Function object (see jerry_function_type) */
JERRY_OBJECT_TYPE_TYPEDARRAY, /**< %TypedArray% object (see jerry_typedarray_type) */
JERRY_OBJECT_TYPE_ITERATOR, /**< Iterator object (see jerry_iterator_type) */
JERRY_OBJECT_TYPE_CONTAINER, /**< Container object (see jerry_container_get_type) */
JERRY_OBJECT_TYPE_ERROR, /**< Error object */
JERRY_OBJECT_TYPE_ARRAYBUFFER, /**< Array buffer object */
@ -554,7 +551,7 @@ typedef enum
*/
typedef enum
{
JERRY_MODULE_STATE_INVALID = 0, /**< return value for jerry_module_get_state when its argument is not a module */
JERRY_MODULE_STATE_INVALID = 0, /**< return value for jerry_module_state when its argument is not a module */
JERRY_MODULE_STATE_UNLINKED = 1, /**< module is currently unlinked */
JERRY_MODULE_STATE_LINKING = 2, /**< module is currently being linked */
JERRY_MODULE_STATE_LINKED = 3, /**< module has been linked (its dependencies has been resolved) */
@ -566,36 +563,36 @@ typedef enum
/**
* Callback which is called by jerry_module_link to get the referenced module.
*/
typedef jerry_value_t (*jerry_module_resolve_callback_t) (const jerry_value_t specifier,
const jerry_value_t referrer,
void *user_p);
typedef jerry_value_t (*jerry_module_resolve_cb_t) (const jerry_value_t specifier,
const jerry_value_t referrer,
void *user_p);
/**
* Callback which is called when an import is resolved dynamically to get the referenced module.
*/
typedef jerry_value_t (*jerry_module_import_callback_t) (const jerry_value_t specifier,
const jerry_value_t user_value,
void *user_p);
typedef jerry_value_t (*jerry_module_import_cb_t) (const jerry_value_t specifier,
const jerry_value_t user_value,
void *user_p);
/**
* Callback which is called after the module enters into linked, evaluated or error state.
*/
typedef void (*jerry_module_state_changed_callback_t) (jerry_module_state_t new_state,
const jerry_value_t module,
const jerry_value_t value,
void *user_p);
typedef void (*jerry_module_state_changed_cb_t) (jerry_module_state_t new_state,
const jerry_value_t module,
const jerry_value_t value,
void *user_p);
/**
* Callback which is called when an import.meta expression of a module is evaluated the first time.
*/
typedef void (*jerry_module_import_meta_callback_t) (const jerry_value_t module,
const jerry_value_t meta_object,
void *user_p);
typedef void (*jerry_module_import_meta_cb_t) (const jerry_value_t module,
const jerry_value_t meta_object,
void *user_p);
/**
* Callback which is called by jerry_module_evaluate to evaluate the native module.
*/
typedef jerry_value_t (*jerry_native_module_evaluate_callback_t) (const jerry_value_t native_module);
typedef jerry_value_t (*jerry_native_module_evaluate_cb_t) (const jerry_value_t native_module);
/**
* Proxy related types.
@ -611,7 +608,7 @@ typedef enum
* [[PreventExtensions]], [[GetOwnProperty]],
* [[DefineOwnProperty]], [[HasProperty]], [[Get]],
* [[Set]], [[Delete]] and [[OwnPropertyKeys]] */
} jerry_proxy_object_options_t;
} jerry_proxy_custom_behavior_t;
/**
* Promise related types.
@ -629,7 +626,7 @@ typedef enum
} jerry_promise_state_t;
/**
* Event types for jerry_promise_callback_t callback function.
* Event types for jerry_promise_event_cb_t callback function.
* The description of the 'object' and 'value' arguments are provided for each type.
*/
typedef enum
@ -680,7 +677,7 @@ typedef enum
} jerry_promise_event_type_t;
/**
* Filter types for jerry_promise_set_callback callback function.
* Filter types for jerry_promise_on_event callback function.
* The callback is only called for those events which are enabled by the filters.
*/
typedef enum
@ -712,7 +709,7 @@ typedef enum
/**
* Notification callback for tracking Promise and async function operations.
*/
typedef void (*jerry_promise_callback_t) (jerry_promise_event_type_t event_type,
typedef void (*jerry_promise_event_cb_t) (jerry_promise_event_type_t event_type,
const jerry_value_t object,
const jerry_value_t value,
void *user_p);
@ -788,7 +785,7 @@ typedef enum
JERRY_CONTAINER_OP_DELETE, /**< Set/WeakSet/Map/WeakMap delete operation */
JERRY_CONTAINER_OP_SIZE, /**< Set/WeakSet/Map/WeakMap size operation */
JERRY_CONTAINER_OP_CLEAR, /**< Set/Map clear operation */
} jerry_container_operation_t;
} jerry_container_op_t;
/**
* Miscellaneous types.
@ -833,19 +830,19 @@ typedef enum
/**
* Callback for allocating the backing store of array buffer or shared array buffer objects.
*/
typedef uint8_t *(*jerry_arraybuffer_allocate_t) (jerry_arraybuffer_type_t buffer_type,
uint32_t buffer_size,
void **arraybuffer_user_p,
void *user_p);
typedef uint8_t *(*jerry_arraybuffer_allocate_cb_t) (jerry_arraybuffer_type_t buffer_type,
uint32_t buffer_size,
void **arraybuffer_user_p,
void *user_p);
/**
* Callback for freeing the backing store of array buffer or shared array buffer objects.
*/
typedef void (*jerry_arraybuffer_free_t) (jerry_arraybuffer_type_t buffer_type,
uint8_t *buffer_p,
uint32_t buffer_size,
void *arraybuffer_user_p,
void *user_p);
typedef void (*jerry_arraybuffer_free_cb_t) (jerry_arraybuffer_type_t buffer_type,
uint8_t *buffer_p,
uint32_t buffer_size,
void *arraybuffer_user_p,
void *user_p);
/**
* @}

15
jerry-core/include/jerryscript.h
View File

@ -16,6 +16,21 @@
#ifndef JERRYSCRIPT_H
#define JERRYSCRIPT_H
/**
* Major version of JerryScript API.
*/
#define JERRY_API_MAJOR_VERSION 3
/**
* Minor version of JerryScript API.
*/
#define JERRY_API_MINOR_VERSION 0
/**
* Patch version of JerryScript API.
*/
#define JERRY_API_PATCH_VERSION 0
#include "jerryscript-core.h"
#include "jerryscript-debugger.h"
#include "jerryscript-snapshot.h"

30
jerry-core/jcontext/jcontext.h
View File

@ -150,22 +150,22 @@ struct jerry_context_t
#if JERRY_MODULE_SYSTEM
ecma_module_t *module_current_p; /**< current module context */
jerry_module_state_changed_callback_t module_state_changed_callback_p; /**< callback which is called after the
* state of a module is changed */
jerry_module_state_changed_cb_t module_state_changed_callback_p; /**< callback which is called after the
* state of a module is changed */
void *module_state_changed_callback_user_p; /**< user pointer for module_state_changed_callback_p */
jerry_module_import_meta_callback_t module_import_meta_callback_p; /**< callback which is called when an
* import.meta expression of a module
* is evaluated the first time */
jerry_module_import_meta_cb_t module_import_meta_callback_p; /**< callback which is called when an
* import.meta expression of a module
* is evaluated the first time */
void *module_import_meta_callback_user_p; /**< user pointer for module_import_meta_callback_p */
jerry_module_import_callback_t module_import_callback_p; /**< callback for dynamic module import */
jerry_module_import_cb_t module_import_callback_p; /**< callback for dynamic module import */
void *module_import_callback_user_p; /**< user pointer for module_import_callback_p */
#endif /* JERRY_MODULE_SYSTEM */
vm_frame_ctx_t *vm_top_context_p; /**< top (current) interpreter context */
jerry_context_data_header_t *context_data_p; /**< linked list of user-provided context-specific pointers */
jerry_external_string_free_callback_t external_string_free_callback_p; /**< free callback for external strings */
jerry_external_string_free_cb_t external_string_free_callback_p; /**< free callback for external strings */
void *error_object_created_callback_user_p; /**< user pointer for error_object_update_callback_p */
jerry_error_object_created_callback_t error_object_created_callback_p; /**< decorator callback for Error objects */
jerry_error_object_created_cb_t error_object_created_callback_p; /**< decorator callback for Error objects */
size_t ecma_gc_objects_number; /**< number of currently allocated objects */
size_t ecma_gc_new_objects; /**< number of newly allocated objects since last GC session */
size_t jmem_heap_allocated_size; /**< size of allocated regions */
@ -194,30 +194,30 @@ struct jerry_context_t
#if JERRY_PROMISE_CALLBACK
uint32_t promise_callback_filters; /**< reported event types for promise callback */
void *promise_callback_user_p; /**< user pointer for promise callback */
jerry_promise_callback_t promise_callback; /**< user function for tracking Promise object operations */
jerry_promise_event_cb_t promise_callback; /**< user function for tracking Promise object operations */
#endif /* JERRY_PROMISE_CALLBACK */
#endif /* JERRY_ESNEXT */
#if JERRY_BUILTIN_TYPEDARRAY
uint32_t arraybuffer_compact_allocation_limit; /**< maximum size of compact allocation */
jerry_arraybuffer_allocate_t arraybuffer_allocate_callback; /**< callback for allocating
* arraybuffer memory */
jerry_arraybuffer_free_t arraybuffer_free_callback; /**< callback for freeing arraybuffer memory */
jerry_arraybuffer_allocate_cb_t arraybuffer_allocate_callback; /**< callback for allocating
* arraybuffer memory */
jerry_arraybuffer_free_cb_t arraybuffer_free_callback; /**< callback for freeing arraybuffer memory */
void *arraybuffer_allocate_callback_user_p; /**< user pointer passed to arraybuffer_allocate_callback
* and arraybuffer_free_callback functions */
#endif /* JERRY_BUILTIN_TYPEDARRAY */
#if JERRY_VM_EXEC_STOP
#if JERRY_VM_HALT
uint32_t vm_exec_stop_frequency; /**< reset value for vm_exec_stop_counter */
uint32_t vm_exec_stop_counter; /**< down counter for reducing the calls of vm_exec_stop_cb */
void *vm_exec_stop_user_p; /**< user pointer for vm_exec_stop_cb */
ecma_vm_exec_stop_callback_t vm_exec_stop_cb; /**< user function which returns whether the
* ECMAScript execution should be stopped */
#endif /* JERRY_VM_EXEC_STOP */
#endif /* JERRY_VM_HALT */
#if JERRY_VM_THROW
void *vm_throw_callback_user_p; /**< user pointer for vm_throw_callback_p */
jerry_vm_throw_callback_t vm_throw_callback_p; /**< callback for capturing throws */
jerry_throw_cb_t vm_throw_callback_p; /**< callback for capturing throws */
#endif /* JERRY_VM_THROW */
#if (JERRY_STACK_LIMIT != 0)

8
jerry-core/jrt/jrt.h
View File

@ -211,10 +211,10 @@ void JERRY_ATTR_NORETURN jerry_fatal (jerry_fatal_code_t code);
#define JERRY_BLOCK_TAIL_CALL_OPTIMIZATION() __asm__ __volatile__("")
#else /* !defined(__clang__) && !defined(__GNUC__) */
/* On GCC 10.x this version also works. */
#define JERRY_BLOCK_TAIL_CALL_OPTIMIZATION() \
do \
{ \
JERRY_CONTEXT (status_flags) |= ECMA_STATUS_API_AVAILABLE; \
#define JERRY_BLOCK_TAIL_CALL_OPTIMIZATION() \
do \
{ \
JERRY_CONTEXT (status_flags) |= ECMA_STATUS_API_ENABLED; \
} while (0)
#endif /* defined(__clang__) || defined (__GNUC__) */

58
jerry-core/lit/lit-strings.c
View File

@ -587,7 +587,7 @@ lit_utf8_decr (const lit_utf8_byte_t **buf_p) /**< [in,out] buffer with characte
do
{
current_p--;
} while ((*(current_p) &LIT_UTF8_EXTRA_BYTE_MASK) == LIT_UTF8_EXTRA_BYTE_MARKER);
} while ((*current_p & LIT_UTF8_EXTRA_BYTE_MASK) == LIT_UTF8_EXTRA_BYTE_MARKER);
*buf_p = current_p;
} /* lit_utf8_decr */
@ -824,57 +824,51 @@ lit_code_point_to_utf8 (lit_code_point_t code_point, /**< code point */
/**
* Convert cesu-8 string to an utf-8 string and put it into the buffer.
* It is the caller's responsibility to make sure that the string fits in the buffer.
* String will be truncated to fit the buffer.
*
* @return number of bytes copied to the buffer.
*/
lit_utf8_size_t
lit_convert_cesu8_string_to_utf8_string (const lit_utf8_byte_t *cesu8_string, /**< cesu-8 string */
lit_convert_cesu8_string_to_utf8_string (const lit_utf8_byte_t *cesu8_string_p, /**< cesu-8 string */
lit_utf8_size_t cesu8_size, /**< size of cesu-8 string */
lit_utf8_byte_t *utf8_string, /**< destination utf-8 buffer pointer
* (can be NULL if buffer_size == 0) */
lit_utf8_byte_t *utf8_string_p, /**< destination utf-8 buffer pointer
* (can be NULL if buffer_size == 0) */
lit_utf8_size_t utf8_size) /**< size of utf-8 buffer */
{
const lit_utf8_byte_t *cesu8_pos = cesu8_string;
const lit_utf8_byte_t *cesu8_end_pos = cesu8_string + cesu8_size;
const lit_utf8_byte_t *cesu8_cursor_p = cesu8_string_p;
const lit_utf8_byte_t *cesu8_end_p = cesu8_string_p + cesu8_size;
lit_utf8_byte_t *utf8_pos = utf8_string;
lit_utf8_byte_t *utf8_end_pos = utf8_string + utf8_size;
lit_utf8_byte_t *utf8_cursor_p = utf8_string_p;
lit_utf8_byte_t *utf8_end_p = utf8_string_p + utf8_size;
lit_utf8_size_t size = 0;
ecma_char_t prev_ch = 0;
lit_utf8_size_t prev_ch_size = 0;
while (cesu8_pos < cesu8_end_pos)
while (cesu8_cursor_p < cesu8_end_p)
{
ecma_char_t ch;
lit_utf8_size_t code_unit_size = lit_read_code_unit_from_cesu8 (cesu8_pos, &ch);
lit_code_point_t cp;
lit_utf8_size_t read_size = lit_read_code_point_from_cesu8 (cesu8_cursor_p, cesu8_end_p, &cp);
lit_utf8_size_t encoded_size = (cp >= LIT_UTF16_FIRST_SURROGATE_CODE_POINT) ? 4 : read_size;
if (lit_is_code_point_utf16_low_surrogate (ch) && lit_is_code_point_utf16_high_surrogate (prev_ch))
if (utf8_cursor_p + encoded_size > utf8_end_p)
{
JERRY_ASSERT (code_unit_size == prev_ch_size);
utf8_pos -= prev_ch_size;
lit_code_point_t code_point = lit_convert_surrogate_pair_to_code_point (prev_ch, ch);
lit_code_point_to_utf8 (code_point, utf8_pos);
size++;
break;
}
if (cp >= LIT_UTF16_FIRST_SURROGATE_CODE_POINT)
{
lit_code_point_to_utf8 (cp, utf8_cursor_p);
}
else
{
memcpy (utf8_pos, cesu8_pos, code_unit_size);
size += code_unit_size;
memcpy (utf8_cursor_p, cesu8_cursor_p, encoded_size);
}
utf8_pos = utf8_string + size;
cesu8_pos += code_unit_size;
prev_ch = ch;
prev_ch_size = code_unit_size;
utf8_cursor_p += encoded_size;
cesu8_cursor_p += read_size;
}
JERRY_ASSERT (cesu8_pos == cesu8_end_pos);
JERRY_ASSERT (utf8_pos <= utf8_end_pos);
JERRY_ASSERT (cesu8_cursor_p == cesu8_end_p);
JERRY_ASSERT (utf8_cursor_p <= utf8_end_p);
return size;
return (lit_utf8_byte_t) (utf8_cursor_p - utf8_string_p);
} /* lit_convert_cesu8_string_to_utf8_string */
/**

4
jerry-core/lit/lit-strings.h
View File

@ -116,9 +116,9 @@ lit_utf8_size_t lit_get_unicode_char_size_by_utf8_first_byte (const lit_utf8_byt
lit_utf8_size_t lit_code_unit_to_utf8 (ecma_char_t code_unit, lit_utf8_byte_t *buf_p);
lit_utf8_size_t lit_code_point_to_utf8 (lit_code_point_t code_point, lit_utf8_byte_t *buf);
lit_utf8_size_t lit_code_point_to_cesu8 (lit_code_point_t code_point, lit_utf8_byte_t *buf);
lit_utf8_size_t lit_convert_cesu8_string_to_utf8_string (const lit_utf8_byte_t *cesu8_string,
lit_utf8_size_t lit_convert_cesu8_string_to_utf8_string (const lit_utf8_byte_t *cesu8_string_p,
lit_utf8_size_t cesu8_size,
lit_utf8_byte_t *utf8_string,
lit_utf8_byte_t *utf8_string_p,
lit_utf8_size_t utf8_size);
lit_code_point_t lit_convert_surrogate_pair_to_code_point (ecma_char_t high_surrogate, ecma_char_t low_surrogate);

2
jerry-core/parser/js/byte-code.h
View File

@ -982,7 +982,7 @@ typedef struct
#endif /* JERRY_BUILTIN_REALMS */
uint32_t refs_and_type; /**< reference counter and type of the function */
#if JERRY_RESOURCE_NAME
ecma_value_t resource_name; /**< resource name */
ecma_value_t source_name; /**< resource name */
#endif /* JERRY_RESOURCE_NAME */
#if JERRY_FUNCTION_TO_STRING
ecma_value_t source_code; /**< source code */

20
jerry-core/parser/js/js-parser.c
View File

@ -2109,18 +2109,18 @@ parser_parse_source (void *source_p, /**< source code */
}
#if JERRY_RESOURCE_NAME
ecma_value_t resource_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON);
ecma_value_t source_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON);
if (context.options_p != NULL && (context.options_p->options & JERRY_PARSE_HAS_RESOURCE))
if (context.options_p != NULL && (context.options_p->options & JERRY_PARSE_HAS_SOURCE_NAME))
{
JERRY_ASSERT (ecma_is_value_string (context.options_p->resource_name));
JERRY_ASSERT (ecma_is_value_string (context.options_p->source_name));
ecma_ref_ecma_string (ecma_get_string_from_value (context.options_p->resource_name));
resource_name = context.options_p->resource_name;
ecma_ref_ecma_string (ecma_get_string_from_value (context.options_p->source_name));
source_name = context.options_p->source_name;
}
else if (context.global_status_flags & ECMA_PARSE_EVAL)
{
resource_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_EVAL);
source_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_EVAL);
}
#endif /* JERRY_RESOURCE_NAME */
@ -2263,7 +2263,7 @@ parser_parse_source (void *source_p, /**< source code */
#endif /* JERRY_BUILTIN_REALMS */
#if JERRY_RESOURCE_NAME
context.script_p->resource_name = resource_name;
context.script_p->source_name = source_name;
#endif /* JERRY_RESOURCE_NAME */
ECMA_SET_INTERNAL_VALUE_POINTER (context.script_value, context.script_p);
@ -2431,7 +2431,7 @@ parser_parse_source (void *source_p, /**< source code */
parser_cbc_stream_free (&context.byte_code);
#if JERRY_RESOURCE_NAME
ecma_deref_ecma_string (ecma_get_string_from_value (context.script_p->resource_name));
ecma_deref_ecma_string (ecma_get_string_from_value (context.script_p->source_name));
#endif /* JERRY_RESOURCE_NAME */
if (context.script_p != NULL)
@ -2515,7 +2515,7 @@ parser_parse_source (void *source_p, /**< source code */
ecma_raise_standard_error_with_format (JERRY_ERROR_SYNTAX,
"% [%:%:%]",
err_str_val,
resource_name,
source_name,
line_str_val,
col_str_val);
@ -3361,7 +3361,7 @@ parser_parse_script (void *source_p, /**< source code */
JERRY_UNUSED (source_p);
JERRY_UNUSED (source_size);
JERRY_UNUSED (parse_opts);
JERRY_UNUSED (resource_name);
JERRY_UNUSED (source_name);
ecma_raise_syntax_error (ECMA_ERR_PARSER_NOT_SUPPORTED);
return NULL;

6
jerry-core/vm/vm-defines.h
View File

@ -156,13 +156,13 @@ typedef struct
} vm_executable_object_t;
/**
* Real backtrace frame data passed to the jerry_backtrace_callback_t handler.
* Real backtrace frame data passed to the jerry_backtrace_cb_t handler.
*/
struct jerry_backtrace_frame_internal_t
struct jerry_frame_internal_t
{
vm_frame_ctx_t *context_p; /**< context pointer */
uint8_t frame_type; /**< frame type */
jerry_backtrace_location_t location; /**< location information */
jerry_frame_location_t location; /**< location information */
ecma_value_t function; /**< function reference */
ecma_value_t this_binding; /**< this binding passed to the function */
};

6
jerry-core/vm/vm-utils.c
View File

@ -78,8 +78,8 @@ vm_get_backtrace (uint32_t max_depth) /**< maximum backtrace depth, 0 = unlimite
while (context_p != NULL)
{
const ecma_compiled_code_t *bytecode_header_p = context_p->shared_p->bytecode_header_p;
ecma_value_t resource_name = ecma_get_resource_name (bytecode_header_p);
ecma_string_t *str_p = ecma_get_string_from_value (resource_name);
ecma_value_t source_name = ecma_get_source_name (bytecode_header_p);
ecma_string_t *str_p = ecma_get_string_from_value (source_name);
ecma_stringbuilder_t builder = ecma_stringbuilder_create ();
if (ecma_string_is_empty (str_p))
@ -94,7 +94,7 @@ vm_get_backtrace (uint32_t max_depth) /**< maximum backtrace depth, 0 = unlimite
if (bytecode_header_p->status_flags & CBC_CODE_FLAGS_HAS_LINE_INFO)
{
jerry_backtrace_location_t location;
jerry_frame_location_t location;
ecma_line_info_get (ecma_compiled_code_get_line_info (bytecode_header_p),
(uint32_t) (context_p->byte_code_p - context_p->byte_code_start_p),
&location);

14
jerry-core/vm/vm.c
View File

@ -1112,7 +1112,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
if (opcode_data & VM_OC_BACKWARD_BRANCH)
{
#if JERRY_VM_EXEC_STOP
#if JERRY_VM_HALT
if (JERRY_CONTEXT (vm_exec_stop_cb) != NULL && --JERRY_CONTEXT (vm_exec_stop_counter) == 0)
{
result = JERRY_CONTEXT (vm_exec_stop_cb) (JERRY_CONTEXT (vm_exec_stop_user_p));
@ -1125,9 +1125,9 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
{
JERRY_CONTEXT (vm_exec_stop_counter) = 1;
if (ecma_is_value_error_reference (result))
if (ecma_is_value_exception (result))
{
ecma_raise_error_from_error_reference (result);
ecma_throw_exception (result);
}
else
{
@ -1140,7 +1140,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
goto error;
}
}
#endif /* JERRY_VM_EXEC_STOP */
#endif /* JERRY_VM_HALT */
branch_offset = -branch_offset;
}
@ -3819,7 +3819,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
if (ecma_are_values_integer_numbers (left_value, right_value))
{
bool is_less = (ecma_integer_value_t) left_value < (ecma_integer_value_t) right_value;
#if !JERRY_VM_EXEC_STOP
#if !JERRY_VM_HALT
/* This is a lookahead to the next opcode to improve performance.
* If it is CBC_BRANCH_IF_TRUE_BACKWARD, execute it. */
if (*byte_code_p <= CBC_BRANCH_IF_TRUE_BACKWARD_3 && *byte_code_p >= CBC_BRANCH_IF_TRUE_BACKWARD)
@ -3853,7 +3853,7 @@ vm_loop (vm_frame_ctx_t *frame_ctx_p) /**< frame context */
continue;
}
#endif /* !JERRY_VM_EXEC_STOP */
#endif /* !JERRY_VM_HALT */
*stack_top_p++ = ecma_make_boolean_value (is_less);
continue;
}
@ -4842,7 +4842,7 @@ error:
{
JERRY_CONTEXT (status_flags) |= ECMA_STATUS_ERROR_THROWN;
jerry_vm_throw_callback_t vm_throw_callback_p = JERRY_CONTEXT (vm_throw_callback_p);
jerry_throw_cb_t vm_throw_callback_p = JERRY_CONTEXT (vm_throw_callback_p);
if (vm_throw_callback_p != NULL)
{

7
jerry-ext/arg/arg-js-iterator-helper.c
View File

@ -27,8 +27,7 @@
jerry_value_t
jerryx_arg_js_iterator_pop (jerryx_arg_js_iterator_t *js_arg_iter_p) /**< the JS arg iterator */
{
return (js_arg_iter_p->js_arg_idx++ < js_arg_iter_p->js_arg_cnt ? *js_arg_iter_p->js_arg_p++
: jerry_create_undefined ());
return (js_arg_iter_p->js_arg_idx++ < js_arg_iter_p->js_arg_cnt ? *js_arg_iter_p->js_arg_p++ : jerry_undefined ());
} /* jerryx_arg_js_iterator_pop */
/**
@ -42,7 +41,7 @@ jerryx_arg_js_iterator_restore (jerryx_arg_js_iterator_t *js_arg_iter_p) /**< th
{
if (js_arg_iter_p->js_arg_idx == 0)
{
return jerry_create_undefined ();
return jerry_undefined ();
}
--js_arg_iter_p->js_arg_idx;
@ -63,7 +62,7 @@ jerryx_arg_js_iterator_restore (jerryx_arg_js_iterator_t *js_arg_iter_p) /**< th
jerry_value_t
jerryx_arg_js_iterator_peek (jerryx_arg_js_iterator_t *js_arg_iter_p) /**< the JS arg iterator */
{
return (js_arg_iter_p->js_arg_idx < js_arg_iter_p->js_arg_cnt ? *js_arg_iter_p->js_arg_p : jerry_create_undefined ());
return (js_arg_iter_p->js_arg_idx < js_arg_iter_p->js_arg_cnt ? *js_arg_iter_p->js_arg_p : jerry_undefined ());
} /* jerryx_arg_js_iterator_peek */
/**

113
jerry-ext/arg/arg-transform-functions.c
View File

@ -56,12 +56,12 @@ jerryx_arg_transform_number_strict_common (jerryx_arg_js_iterator_t *js_arg_iter
if (!jerry_value_is_number (js_arg))
{
return jerry_create_error (JERRY_ERROR_TYPE, (jerry_char_t *) "It is not a number.");
return jerry_throw_sz (JERRY_ERROR_TYPE, "It is not a number.");
}
*number_p = jerry_get_number_value (js_arg);
*number_p = jerry_value_as_number (js_arg);
return jerry_create_undefined ();
return jerry_undefined ();
} /* jerryx_arg_transform_number_strict_common */
/**
@ -79,17 +79,17 @@ jerryx_arg_transform_number_common (jerryx_arg_js_iterator_t *js_arg_iter_p, /**
jerry_value_t to_number = jerry_value_to_number (js_arg);
if (jerry_value_is_error (to_number))
if (jerry_value_is_exception (to_number))
{
jerry_release_value (to_number);
jerry_value_free (to_number);
return jerry_create_error (JERRY_ERROR_TYPE, (jerry_char_t *) "It can not be converted to a number.");
return jerry_throw_sz (JERRY_ERROR_TYPE, "It can not be converted to a number.");
}
*number_p = jerry_get_number_value (to_number);
jerry_release_value (to_number);
*number_p = jerry_value_as_number (to_number);
jerry_value_free (to_number);
return jerry_create_undefined ();
return jerry_undefined ();
} /* jerryx_arg_transform_number_common */
/**
@ -133,14 +133,14 @@ jerryx_arg_helper_process_double (double *d, /**< [in, out] the number to be pro
{
if (*d != *d) /* isnan (*d) triggers conversion warning on clang<9 */
{
return jerry_create_error (JERRY_ERROR_TYPE, (jerry_char_t *) "The number is NaN.");
return jerry_throw_sz (JERRY_ERROR_TYPE, "The number is NaN.");
}
if (option.clamp == JERRYX_ARG_NO_CLAMP)
{
if (*d > max || *d < min)
{
return jerry_create_error (JERRY_ERROR_TYPE, (jerry_char_t *) "The number is out of range.");
return jerry_throw_sz (JERRY_ERROR_TYPE, "The number is out of range.");
}
}
else
@ -162,7 +162,7 @@ jerryx_arg_helper_process_double (double *d, /**< [in, out] the number to be pro
*d = ceil (*d);
}
return jerry_create_undefined ();
return jerry_undefined ();
} /* jerryx_arg_helper_process_double */
/**
@ -174,18 +174,18 @@ jerryx_arg_helper_process_double (double *d, /**< [in, out] the number to be pro
{ \
double tmp = 0.0; \
jerry_value_t rv = jerryx_arg_transform_number##suffix##_common (js_arg_iter_p, &tmp); \
if (jerry_value_is_error (rv)) \
if (jerry_value_is_exception (rv)) \
{ \
return rv; \
} \
jerry_release_value (rv); \
jerry_value_free (rv); \
union \
{ \
jerryx_arg_int_option_t int_option; \
uintptr_t extra_info; \
} u = { .extra_info = c_arg_p->extra_info }; \
rv = jerryx_arg_helper_process_double (&tmp, min, max, u.int_option); \
if (jerry_value_is_error (rv)) \
if (jerry_value_is_exception (rv)) \
{ \
return rv; \
} \
@ -220,13 +220,13 @@ jerryx_arg_transform_boolean_strict (jerryx_arg_js_iterator_t *js_arg_iter_p, /*
if (!jerry_value_is_boolean (js_arg))
{
return jerry_create_error (JERRY_ERROR_TYPE, (jerry_char_t *) "It is not a boolean.");
return jerry_throw_sz (JERRY_ERROR_TYPE, "It is not a boolean.");
}
bool *dest = c_arg_p->dest;
*dest = jerry_value_is_true (js_arg);
return jerry_create_undefined ();
return jerry_undefined ();
} /* jerryx_arg_transform_boolean_strict */
/**
@ -246,7 +246,7 @@ jerryx_arg_transform_boolean (jerryx_arg_js_iterator_t *js_arg_iter_p, /**< avai
bool *dest = c_arg_p->dest;
*dest = to_boolean;
return jerry_create_undefined ();
return jerry_undefined ();
} /* jerryx_arg_transform_boolean */
/**
@ -259,32 +259,22 @@ jerryx_arg_transform_boolean (jerryx_arg_js_iterator_t *js_arg_iter_p, /**< avai
static jerry_value_t
jerryx_arg_string_to_buffer_common_routine (jerry_value_t js_arg, /**< JS arg */
const jerryx_arg_t *c_arg_p, /**< native arg */
bool is_utf8) /**< whether it is UTF-8 string */
jerry_encoding_t encoding) /**< string encoding */
{
jerry_char_t *target_p = (jerry_char_t *) c_arg_p->dest;
jerry_size_t target_buf_size = (jerry_size_t) c_arg_p->extra_info;
jerry_size_t size;
jerry_length_t len;
if (!is_utf8)
jerry_size_t size = jerry_string_size (js_arg, encoding);
if (size > target_buf_size - 1)
{
size = jerry_string_to_char_buffer (js_arg, target_p, target_buf_size);
len = jerry_get_string_length (js_arg);
}
else
{
size = jerry_string_to_utf8_char_buffer (js_arg, target_p, target_buf_size);
len = jerry_get_utf8_string_length (js_arg);
}
if ((size == target_buf_size) || (size == 0 && len != 0))
{
return jerry_create_error (JERRY_ERROR_TYPE, (jerry_char_t *) "Buffer size is not large enough.");
return jerry_throw_sz (JERRY_ERROR_TYPE, "Buffer size is not large enough.");
}
jerry_string_to_buffer (js_arg, encoding, target_p, target_buf_size);
target_p[size] = '\0';
return jerry_create_undefined ();
return jerry_undefined ();
} /* jerryx_arg_string_to_buffer_common_routine */
/**
@ -296,16 +286,16 @@ jerryx_arg_string_to_buffer_common_routine (jerry_value_t js_arg, /**< JS arg */
static jerry_value_t
jerryx_arg_transform_string_strict_common (jerryx_arg_js_iterator_t *js_arg_iter_p, /**< available JS args */
const jerryx_arg_t *c_arg_p, /**< the native arg */
bool is_utf8) /**< whether it is a UTF-8 string */
jerry_encoding_t encoding) /**< string encoding */
{
jerry_value_t js_arg = jerryx_arg_js_iterator_pop (js_arg_iter_p);
if (!jerry_value_is_string (js_arg))
{
return jerry_create_error (JERRY_ERROR_TYPE, (jerry_char_t *) "It is not a string.");
return jerry_throw_sz (JERRY_ERROR_TYPE, "It is not a string.");
}
return jerryx_arg_string_to_buffer_common_routine (js_arg, c_arg_p, is_utf8);
return jerryx_arg_string_to_buffer_common_routine (js_arg, c_arg_p, encoding);
} /* jerryx_arg_transform_string_strict_common */
/**
@ -317,21 +307,21 @@ jerryx_arg_transform_string_strict_common (jerryx_arg_js_iterator_t *js_arg_iter
static jerry_value_t
jerryx_arg_transform_string_common (jerryx_arg_js_iterator_t *js_arg_iter_p, /**< available JS args */
const jerryx_arg_t *c_arg_p, /**< the native arg */
bool is_utf8) /**< whether it is a UTF-8 string */
jerry_encoding_t encoding) /**< string encoding */
{
jerry_value_t js_arg = jerryx_arg_js_iterator_pop (js_arg_iter_p);
jerry_value_t to_string = jerry_value_to_string (js_arg);
if (jerry_value_is_error (to_string))
if (jerry_value_is_exception (to_string))
{
jerry_release_value (to_string);
jerry_value_free (to_string);
return jerry_create_error (JERRY_ERROR_TYPE, (jerry_char_t *) "It can not be converted to a string.");
return jerry_throw_sz (JERRY_ERROR_TYPE, "It can not be converted to a string.");
}
jerry_value_t ret = jerryx_arg_string_to_buffer_common_routine (to_string, c_arg_p, is_utf8);
jerry_release_value (to_string);
jerry_value_t ret = jerryx_arg_string_to_buffer_common_routine (to_string, c_arg_p, encoding);
jerry_value_free (to_string);
return ret;
} /* jerryx_arg_transform_string_common */
@ -340,7 +330,7 @@ jerryx_arg_transform_string_common (jerryx_arg_js_iterator_t *js_arg_iter_p, /**
* Transform a JS argument to a cesu8 char array. Type coercion is not allowed.
*
* Note:
* returned value must be freed with jerry_release_value, when it is no longer needed.
* returned value must be freed with jerry_value_free, when it is no longer needed.
*
* @return jerry undefined: the transformer passes,
* jerry error: the transformer fails.
@ -349,14 +339,14 @@ jerry_value_t
jerryx_arg_transform_string_strict (jerryx_arg_js_iterator_t *js_arg_iter_p, /**< available JS args */
const jerryx_arg_t *c_arg_p) /**< the native arg */
{
return jerryx_arg_transform_string_strict_common (js_arg_iter_p, c_arg_p, false);
return jerryx_arg_transform_string_strict_common (js_arg_iter_p, c_arg_p, JERRY_ENCODING_CESU8);
} /* jerryx_arg_transform_string_strict */
/**
* Transform a JS argument to a utf8 char array. Type coercion is not allowed.
*
* Note:
* returned value must be freed with jerry_release_value, when it is no longer needed.
* returned value must be freed with jerry_value_free, when it is no longer needed.
*
* @return jerry undefined: the transformer passes,
* jerry error: the transformer fails.
@ -365,14 +355,14 @@ jerry_value_t
jerryx_arg_transform_utf8_string_strict (jerryx_arg_js_iterator_t *js_arg_iter_p, /**< available JS args */
const jerryx_arg_t *c_arg_p) /**< the native arg */
{
return jerryx_arg_transform_string_strict_common (js_arg_iter_p, c_arg_p, true);
return jerryx_arg_transform_string_strict_common (js_arg_iter_p, c_arg_p, JERRY_ENCODING_UTF8);
} /* jerryx_arg_transform_utf8_string_strict */
/**
* Transform a JS argument to a cesu8 char array. Type coercion is allowed.
*
* Note:
* returned value must be freed with jerry_release_value, when it is no longer needed.
* returned value must be freed with jerry_value_free, when it is no longer needed.
*
* @return jerry undefined: the transformer passes,
* jerry error: the transformer fails.
@ -381,14 +371,14 @@ jerry_value_t
jerryx_arg_transform_string (jerryx_arg_js_iterator_t *js_arg_iter_p, /**< available JS args */
const jerryx_arg_t *c_arg_p) /**< the native arg */
{
return jerryx_arg_transform_string_common (js_arg_iter_p, c_arg_p, false);
return jerryx_arg_transform_string_common (js_arg_iter_p, c_arg_p, JERRY_ENCODING_CESU8);
} /* jerryx_arg_transform_string */
/**
* Transform a JS argument to a utf8 char array. Type coercion is allowed.
*
* Note:
* returned value must be freed with jerry_release_value, when it is no longer needed.
* returned value must be freed with jerry_value_free, when it is no longer needed.
*
* @return jerry undefined: the transformer passes,
* jerry error: the transformer fails.
@ -397,7 +387,7 @@ jerry_value_t
jerryx_arg_transform_utf8_string (jerryx_arg_js_iterator_t *js_arg_iter_p, /**< available JS args */
const jerryx_arg_t *c_arg_p) /**< the native arg */
{
return jerryx_arg_transform_string_common (js_arg_iter_p, c_arg_p, true);
return jerryx_arg_transform_string_common (js_arg_iter_p, c_arg_p, JERRY_ENCODING_UTF8);
} /* jerryx_arg_transform_utf8_string */
/**
@ -414,13 +404,13 @@ jerryx_arg_transform_function (jerryx_arg_js_iterator_t *js_arg_iter_p, /**< ava
if (!jerry_value_is_function (js_arg))
{
return jerry_create_error (JERRY_ERROR_TYPE, (jerry_char_t *) "It is not a function.");
return jerry_throw_sz (JERRY_ERROR_TYPE, "It is not a function.");
}
jerry_value_t *func_p = c_arg_p->dest;
*func_p = jerry_acquire_value (js_arg);
*func_p = jerry_value_copy (js_arg);
return jerry_create_undefined ();
return jerry_undefined ();
} /* jerryx_arg_transform_function */
/**
@ -438,21 +428,20 @@ jerryx_arg_transform_native_pointer (jerryx_arg_js_iterator_t *js_arg_iter_p, /*
if (!jerry_value_is_object (js_arg))
{
return jerry_create_error (JERRY_ERROR_TYPE, (jerry_char_t *) "It is not an object.");
return jerry_throw_sz (JERRY_ERROR_TYPE, "It is not an object.");
}
const jerry_object_native_info_t *expected_info_p;
expected_info_p = (const jerry_object_native_info_t *) c_arg_p->extra_info;
void **ptr_p = (void **) c_arg_p->dest;
bool is_ok = jerry_get_object_native_pointer (js_arg, ptr_p, expected_info_p);
*ptr_p = jerry_object_get_native_ptr (js_arg, expected_info_p);
if (!is_ok)
if (*ptr_p == NULL)
{
return jerry_create_error (JERRY_ERROR_TYPE,
(jerry_char_t *) "The object has no native pointer or type does not match.");
return jerry_throw_sz (JERRY_ERROR_TYPE, "The object has no native pointer or type does not match.");
}
return jerry_create_undefined ();
return jerry_undefined ();
} /* jerryx_arg_transform_native_pointer */
/**
@ -543,5 +532,5 @@ jerryx_arg_transform_ignore (jerryx_arg_js_iterator_t *js_arg_iter_p, /**< avail
(void) js_arg_iter_p; /* unused */
(void) c_arg_p; /* unused */
return jerry_create_undefined ();
return jerry_undefined ();
} /* jerryx_arg_transform_ignore */

36
jerry-ext/arg/arg.c
View File

@ -35,11 +35,11 @@ jerryx_arg_transform_args (const jerry_value_t *js_arg_p, /**< points to the arr
const jerryx_arg_t *c_arg_p, /**< points to the array of validation/transformation steps */
jerry_length_t c_arg_cnt) /**< the count of the `c_arg_p` array */
{
jerry_value_t ret = jerry_create_undefined ();
jerry_value_t ret = jerry_undefined ();
jerryx_arg_js_iterator_t iterator = { .js_arg_p = js_arg_p, .js_arg_cnt = js_arg_cnt, .js_arg_idx = 0 };
for (; c_arg_cnt != 0 && !jerry_value_is_error (ret); c_arg_cnt--, c_arg_p++)
for (; c_arg_cnt != 0 && !jerry_value_is_exception (ret); c_arg_cnt--, c_arg_p++)
{
ret = c_arg_p->func (&iterator, c_arg_p);
}
@ -66,18 +66,18 @@ jerryx_arg_transform_this_and_args (const jerry_value_t this_val, /**< the this_
{
if (c_arg_cnt == 0)
{
return jerry_create_undefined ();
return jerry_undefined ();
}
jerryx_arg_js_iterator_t iterator = { .js_arg_p = &this_val, .js_arg_cnt = 1, .js_arg_idx = 0 };
jerry_value_t ret = c_arg_p->func (&iterator, c_arg_p);
if (jerry_value_is_error (ret))
if (jerry_value_is_exception (ret))
{
jerry_release_value (ret);
jerry_value_free (ret);
return jerry_create_error (JERRY_ERROR_TYPE, (jerry_char_t *) "'this' validation failed.");
return jerry_throw_sz (JERRY_ERROR_TYPE, "'this' validation failed.");
}
return jerryx_arg_transform_args (js_arg_p, js_arg_cnt, c_arg_p + 1, c_arg_cnt - 1);
@ -99,22 +99,22 @@ jerryx_arg_transform_object_properties (const jerry_value_t obj_val, /**< the JS
{
if (!jerry_value_is_object (obj_val))
{
return jerry_create_error (JERRY_ERROR_TYPE, (jerry_char_t *) "Not an object.");
return jerry_throw_sz (JERRY_ERROR_TYPE, "Not an object.");
}
JERRY_VLA (jerry_value_t, prop, name_cnt);
for (jerry_length_t i = 0; i < name_cnt; i++, name_p++)
{
const jerry_value_t name_str = jerry_create_string (*name_p);
prop[i] = jerry_get_property (obj_val, name_str);
jerry_release_value (name_str);
const jerry_value_t name_str = jerry_string_sz ((char *) (*name_p));
prop[i] = jerry_object_get (obj_val, name_str);
jerry_value_free (name_str);
if (jerry_value_is_error (prop[i]))
if (jerry_value_is_exception (prop[i]))
{
for (jerry_length_t j = 0; j < i; j++)
{
jerry_release_value (prop[j]);
jerry_value_free (prop[j]);
}
return prop[i];
@ -125,7 +125,7 @@ jerryx_arg_transform_object_properties (const jerry_value_t obj_val, /**< the JS
for (jerry_length_t i = 0; i < name_cnt; i++)
{
jerry_release_value (prop[i]);
jerry_value_free (prop[i]);
}
return ret;
@ -144,20 +144,20 @@ jerryx_arg_transform_array (const jerry_value_t array_val, /**< points to the JS
{
if (!jerry_value_is_array (array_val))
{
return jerry_create_error (JERRY_ERROR_TYPE, (jerry_char_t *) "Not an array.");
return jerry_throw_sz (JERRY_ERROR_TYPE, "Not an array.");
}
JERRY_VLA (jerry_value_t, arr, c_arg_cnt);
for (jerry_length_t i = 0; i < c_arg_cnt; i++)
{
arr[i] = jerry_get_property_by_index (array_val, i);
arr[i] = jerry_object_get_index (array_val, i);
if (jerry_value_is_error (arr[i]))
if (jerry_value_is_exception (arr[i]))
{
for (jerry_length_t j = 0; j < i; j++)
{
jerry_release_value (arr[j]);
jerry_value_free (arr[j]);
}
return arr[i];
@ -168,7 +168,7 @@ jerryx_arg_transform_array (const jerry_value_t array_val, /**< points to the JS
for (jerry_length_t i = 0; i < c_arg_cnt; i++)
{
jerry_release_value (arr[i]);
jerry_value_free (arr[i]);
}
return ret;

2
jerry-ext/debugger/debugger-rp.c
View File

@ -140,7 +140,7 @@ jerryx_debugger_rp_receive (jerry_debugger_transport_header_t *header_p, /**< he
bool
jerryx_debugger_rp_create (void)
{
const size_t interface_size = sizeof (jerry_debugger_transport_header_t);
const jerry_size_t interface_size = sizeof (jerry_debugger_transport_header_t);
jerry_debugger_transport_header_t *header_p;
header_p = (jerry_debugger_transport_header_t *) jerry_heap_alloc (interface_size);

2
jerry-ext/debugger/debugger-serial.c
View File

@ -367,7 +367,7 @@ jerryx_debugger_serial_create (const char *config) /**< specify the configuratio
JERRYX_DEBUG_MSG ("Client connected\n");
size_t size = sizeof (jerryx_debugger_transport_serial_t);
jerry_size_t size = sizeof (jerryx_debugger_transport_serial_t);
jerry_debugger_transport_header_t *header_p;
header_p = (jerry_debugger_transport_header_t *) jerry_heap_alloc (size);

2
jerry-ext/debugger/debugger-tcp.c
View File

@ -364,7 +364,7 @@ jerryx_debugger_tcp_create (uint16_t port) /**< listening port */
JERRYX_DEBUG_MSG ("Connected from: %s\n", inet_ntoa (addr.sin_addr));
size_t size = sizeof (jerryx_debugger_transport_tcp_t);
jerry_size_t size = sizeof (jerryx_debugger_transport_tcp_t);
jerry_debugger_transport_header_t *header_p;
header_p = (jerry_debugger_transport_header_t *) jerry_heap_alloc (size);

4
jerry-ext/debugger/debugger-ws.c
View File

@ -407,7 +407,7 @@ jerryx_debugger_ws_create (void)
{
bool is_handshake_ok = false;
const size_t buffer_size = 1024;
const jerry_size_t buffer_size = 1024;
uint8_t *request_buffer_p = (uint8_t *) jerry_heap_alloc (buffer_size);
if (!request_buffer_p)
@ -424,7 +424,7 @@ jerryx_debugger_ws_create (void)
return false;
}
const size_t interface_size = sizeof (jerry_debugger_transport_header_t);
const jerry_size_t interface_size = sizeof (jerry_debugger_transport_header_t);
jerry_debugger_transport_header_t *header_p;
header_p = (jerry_debugger_transport_header_t *) jerry_heap_alloc (interface_size);

4
jerry-ext/handle-scope/handle-scope.c
View File

@ -47,7 +47,7 @@ jerryx_handle_scope_release_handles (jerryx_handle_scope scope)
jerryx_handle_t *a_handle = scope->handle_ptr;
while (a_handle != NULL)
{
jerry_release_value (a_handle->jval);
jerry_value_free (a_handle->jval);
jerryx_handle_t *sibling = a_handle->sibling;
jerry_heap_free (a_handle, sizeof (jerryx_handle_t));
a_handle = sibling;
@ -58,7 +58,7 @@ jerryx_handle_scope_release_handles (jerryx_handle_scope scope)
for (size_t idx = 0; idx < prelist_handle_count; idx++)
{
jerry_release_value (scope->handle_prelist[idx]);
jerry_value_free (scope->handle_prelist[idx]);
}
scope->prelist_handle_count = 0;
} /* jerryx_handle_scope_release_handles */

41
jerry-ext/handler/handler-assert.c
View File

@ -38,52 +38,41 @@ jerryx_handler_assert_fatal (const jerry_call_info_t *call_info_p, /**< call inf
if (args_cnt == 1 && jerry_value_is_true (args_p[0]))
{
return jerry_create_boolean (true);
return jerry_boolean (true);
}
/* Assert failed, print a bit of JS backtrace */
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Script Error: assertion failed\n");
if (jerry_is_feature_enabled (JERRY_FEATURE_LINE_INFO))
if (jerry_feature_enabled (JERRY_FEATURE_LINE_INFO))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Script backtrace (top 5):\n");
/* If the line info feature is disabled an empty array will be returned. */
jerry_value_t backtrace_array = jerry_get_backtrace (5);
uint32_t array_length = jerry_get_array_length (backtrace_array);
jerry_value_t backtrace_array = jerry_backtrace (5);
uint32_t array_length = jerry_array_length (backtrace_array);
for (uint32_t idx = 0; idx < array_length; idx++)
{
jerry_value_t property = jerry_get_property_by_index (backtrace_array, idx);
jerry_length_t total_size = jerry_get_utf8_string_size (property);
jerry_length_t current_size = 0;
jerry_char_t string_buffer[64];
const jerry_length_t copy_size = (jerry_length_t) (sizeof (string_buffer) - 1);
jerry_value_t property = jerry_object_get_index (backtrace_array, idx);
/* On some systems the uint32_t values can't be printed with "%u" and
* on some systems it can be printed. To avoid differences in the uint32_t typdef
* The "PRIu32" macro is used to correctly add the formatter.
*/
jerry_port_log (JERRY_LOG_LEVEL_ERROR, " %" PRIu32 ": ", idx);
do
{
jerry_size_t copied_bytes = jerry_substring_to_utf8_char_buffer (property,
current_size,
current_size + copy_size,
string_buffer,
copy_size);
string_buffer[copied_bytes] = '\0';
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "%s", string_buffer);
current_size += copied_bytes;
} while (total_size != current_size);
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "\n");
jerry_char_t string_buffer[256];
const jerry_length_t buffer_size = (jerry_length_t) (sizeof (string_buffer) - 1);
jerry_release_value (property);
jerry_size_t copied_bytes = jerry_string_to_buffer (property, JERRY_ENCODING_UTF8, string_buffer, buffer_size);
string_buffer[copied_bytes] = '\0';
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "%s\n", string_buffer);
jerry_value_free (property);
}
jerry_release_value (backtrace_array);
jerry_value_free (backtrace_array);
}
jerry_port_fatal (ERR_FAILED_INTERNAL_ASSERTION);
@ -104,10 +93,10 @@ jerryx_handler_assert_throw (const jerry_call_info_t *call_info_p, /**< call inf
if (args_cnt == 1 && jerry_value_is_true (args_p[0]))
{
return jerry_create_boolean (true);
return jerry_boolean (true);
}
return jerry_create_error (JERRY_ERROR_COMMON, (jerry_char_t *) "assertion failed");
return jerry_throw_sz (JERRY_ERROR_COMMON, "assertion failed");
} /* jerryx_handler_assert_throw */
/**

4
jerry-ext/handler/handler-gc.c
View File

@ -30,6 +30,6 @@ jerryx_handler_gc (const jerry_call_info_t *call_info_p, /**< call information *
jerry_gc_mode_t mode =
((args_cnt > 0 && jerry_value_to_boolean (args_p[0])) ? JERRY_GC_PRESSURE_HIGH : JERRY_GC_PRESSURE_LOW);
jerry_gc (mode);
return jerry_create_undefined ();
jerry_heap_gc (mode);
return jerry_undefined ();
} /* jerryx_handler_gc */

60
jerry-ext/handler/handler-print.c
View File

@ -44,9 +44,7 @@ jerryx_handler_print (const jerry_call_info_t *call_info_p, /**< call informatio
{
(void) call_info_p; /* unused */
const char *const null_str = "\\u0000";
jerry_value_t ret_val = jerry_create_undefined ();
jerry_value_t ret_val = jerry_undefined ();
for (jerry_length_t arg_index = 0; arg_index < args_cnt; arg_index++)
{
@ -54,69 +52,29 @@ jerryx_handler_print (const jerry_call_info_t *call_info_p, /**< call informatio
if (jerry_value_is_symbol (args_p[arg_index]))
{
str_val = jerry_get_symbol_descriptive_string (args_p[arg_index]);
str_val = jerry_symbol_descriptive_string (args_p[arg_index]);
}
else
{
str_val = jerry_value_to_string (args_p[arg_index]);
}
if (jerry_value_is_error (str_val))
if (jerry_value_is_exception (str_val))
{
/* There is no need to free the undefined value. */
ret_val = str_val;
break;
}
jerry_length_t length = jerry_get_utf8_string_length (str_val);
jerry_length_t substr_pos = 0;
jerry_char_t substr_buf[256];
do
if (arg_index > 0)
{
jerry_size_t substr_size = jerry_substring_to_utf8_char_buffer (str_val, substr_pos, length, substr_buf, 256 - 1);
jerry_port_print_char (' ');
}
jerry_char_t *buf_end_p = substr_buf + substr_size;
/* Update start position by the number of utf-8 characters. */
for (jerry_char_t *buf_p = substr_buf; buf_p < buf_end_p; buf_p++)
{
/* Skip intermediate utf-8 octets. */
if ((*buf_p & 0xc0) != 0x80)
{
substr_pos++;
}
}
if (substr_pos == length)
{
*buf_end_p++ = (arg_index < args_cnt - 1) ? ' ' : '\n';
}
for (jerry_char_t *buf_p = substr_buf; buf_p < buf_end_p; buf_p++)
{
char chr = (char) *buf_p;
if (chr != '\0')
{
jerry_port_print_char (chr);
continue;
}
for (jerry_size_t null_index = 0; null_str[null_index] != '\0'; null_index++)
{
jerry_port_print_char (null_str[null_index]);
}
}
} while (substr_pos < length);
jerry_release_value (str_val);
}
if (args_cnt == 0 || jerry_value_is_error (ret_val))
{
jerry_port_print_char ('\n');
jerry_string_print (str_val);
jerry_value_free (str_val);
}
jerry_port_print_char ('\n');
return ret_val;
} /* jerryx_handler_print */

68
jerry-ext/handler/handler-register.c
View File

@ -19,24 +19,24 @@
* Register a JavaScript function in the global object.
*
* Note:
* returned value must be freed with jerry_release_value, when it is no longer needed.
* returned value must be freed with jerry_value_free, when it is no longer needed.
*
* @return true value - if the operation was successful,
* error - otherwise.
*/
jerry_value_t
jerryx_handler_register_global (const jerry_char_t *name_p, /**< name of the function */
jerryx_handler_register_global (const char *name_p, /**< name of the function */
jerry_external_handler_t handler_p) /**< function callback */
{
jerry_value_t global_obj_val = jerry_get_global_object ();
jerry_value_t function_name_val = jerry_create_string (name_p);
jerry_value_t function_val = jerry_create_external_function (handler_p);
jerry_value_t global_obj_val = jerry_current_realm ();
jerry_value_t function_name_val = jerry_string_sz (name_p);
jerry_value_t function_val = jerry_function_external (handler_p);
jerry_value_t result_val = jerry_set_property (global_obj_val, function_name_val, function_val);
jerry_value_t result_val = jerry_object_set (global_obj_val, function_name_val, function_val);
jerry_release_value (function_val);
jerry_release_value (function_name_val);
jerry_release_value (global_obj_val);
jerry_value_free (function_val);
jerry_value_free (function_name_val);
jerry_value_free (global_obj_val);
return result_val;
} /* jerryx_handler_register_global */
@ -66,20 +66,20 @@ jerryx_set_properties (const jerry_value_t target_object, /**< target object */
if (entries == NULL)
{
return JERRYX_SET_PROPERTIES_RESULT (jerry_create_undefined (), 0);
return JERRYX_SET_PROPERTIES_RESULT (jerry_undefined (), 0);
}
for (; (entries[idx].name != NULL); idx++)
{
const jerryx_property_entry *entry = &entries[idx];
jerry_value_t prop_name = jerry_create_string_from_utf8 ((const jerry_char_t *) entry->name);
jerry_value_t result = jerry_set_property (target_object, prop_name, entry->value);
jerry_value_t prop_name = jerry_string_sz (entry->name);
jerry_value_t result = jerry_object_set (target_object, prop_name, entry->value);
jerry_release_value (prop_name);
jerry_value_free (prop_name);
// By API definition:
// The jerry_set_property returns TRUE if there is no problem
// The jerry_object_set returns TRUE if there is no problem
// and error object if there is any problem.
// Thus there is no need to check if the boolean value is false or not.
if (!jerry_value_is_boolean (result))
@ -87,11 +87,11 @@ jerryx_set_properties (const jerry_value_t target_object, /**< target object */
return JERRYX_SET_PROPERTIES_RESULT (result, idx);
}
jerry_release_value (entry->value);
jerry_release_value (result);
jerry_value_free (entry->value);
jerry_value_free (result);
}
return JERRYX_SET_PROPERTIES_RESULT (jerry_create_undefined (), idx);
return JERRYX_SET_PROPERTIES_RESULT (jerry_undefined (), idx);
#undef JERRYX_SET_PROPERTIES_RESULT
} /* jerryx_set_properties */
@ -112,7 +112,7 @@ jerryx_release_property_entry (const jerryx_property_entry entries[], /**< list
for (uint32_t idx = register_result.registered; entries[idx].name != NULL; idx++)
{
jerry_release_value (entries[idx].value);
jerry_value_free (entries[idx].value);
}
} /* jerryx_release_property_entry */
@ -120,10 +120,10 @@ jerryx_release_property_entry (const jerryx_property_entry entries[], /**< list
* Set a property to a specified value with a given name.
*
* Notes:
* - The operation performed is the same as what the `jerry_set_property` method.
* - The operation performed is the same as what the `jerry_object_set` method.
* - The property name must be a zero terminated UTF-8 string.
* - There should be no '\0' (NULL) character in the name excluding the string terminator.
* - Returned value must be freed with jerry_release_value, when it is no longer needed.
* - Returned value must be freed with jerry_value_free, when it is no longer needed.
*
* @return true value - if the operation was successful
* thrown error - otherwise
@ -133,10 +133,10 @@ jerryx_set_property_str (const jerry_value_t target_object, /**< target object *
const char *name, /**< property name */
const jerry_value_t value) /**< value to set */
{
jerry_value_t property_name_val = jerry_create_string_from_utf8 ((const jerry_char_t *) name);
jerry_value_t result_val = jerry_set_property (target_object, property_name_val, value);
jerry_value_t property_name_val = jerry_string_sz (name);
jerry_value_t result_val = jerry_object_set (target_object, property_name_val, value);
jerry_release_value (property_name_val);
jerry_value_free (property_name_val);
return result_val;
} /* jerryx_set_property_str */
@ -145,10 +145,10 @@ jerryx_set_property_str (const jerry_value_t target_object, /**< target object *
* Get a property value of a specified object.
*
* Notes:
* - The operation performed is the same as what the `jerry_get_property` method.
* - The operation performed is the same as what the `jerry_object_get` method.
* - The property name must be a zero terminated UTF-8 string.
* - There should be no '\0' (NULL) character in the name excluding the string terminator.
* - Returned value must be freed with jerry_release_value, when it is no longer needed.
* - Returned value must be freed with jerry_value_free, when it is no longer needed.
*
* @return jerry_value_t - the property value
*/
@ -156,9 +156,9 @@ jerry_value_t
jerryx_get_property_str (const jerry_value_t target_object, /**< target object */
const char *name) /**< property name */
{
jerry_value_t prop_name = jerry_create_string_from_utf8 ((const jerry_char_t *) name);
jerry_value_t result_val = jerry_get_property (target_object, prop_name);
jerry_release_value (prop_name);
jerry_value_t prop_name = jerry_string_sz (name);
jerry_value_t result_val = jerry_object_get (target_object, prop_name);
jerry_value_free (prop_name);
return result_val;
} /* jerryx_get_property_str */
@ -167,7 +167,7 @@ jerryx_get_property_str (const jerry_value_t target_object, /**< target object *
* Check if a property exists on an object.
*
* Notes:
* - The operation performed is the same as what the `jerry_has_property` method.
* - The operation performed is the same as what the `jerry_object_has` method.
* - The property name must be a zero terminated UTF-8 string.
* - There should be no '\0' (NULL) character in the name excluding the string terminator.
*
@ -180,16 +180,16 @@ jerryx_has_property_str (const jerry_value_t target_object, /**< target object *
{
bool has_property = false;
jerry_value_t prop_name = jerry_create_string_from_utf8 ((const jerry_char_t *) name);
jerry_value_t has_prop_val = jerry_has_property (target_object, prop_name);
jerry_value_t prop_name = jerry_string_sz (name);
jerry_value_t has_prop_val = jerry_object_has (target_object, prop_name);
if (!jerry_value_is_error (has_prop_val))
if (!jerry_value_is_exception (has_prop_val))
{
has_property = jerry_value_is_true (has_prop_val);
}
jerry_release_value (has_prop_val);
jerry_release_value (prop_name);
jerry_value_free (has_prop_val);
jerry_value_free (prop_name);
return has_property;
} /* jerryx_has_property_str */

18
jerry-ext/handler/handler-resource-name.c
View File

@ -18,7 +18,7 @@
/**
* Get the resource name (usually a file name) of the currently executed script or the given function object
*
* Note: returned value must be freed with jerry_release_value, when it is no longer needed
* Note: returned value must be freed with jerry_value_free, when it is no longer needed
*
* @return JS string constructed from
* - the currently executed function object's resource name, if the given value is undefined
@ -26,15 +26,15 @@
* - "<anonymous>", otherwise
*/
jerry_value_t
jerryx_handler_resource_name (const jerry_call_info_t *call_info_p, /**< call information */
const jerry_value_t args_p[], /**< function arguments */
const jerry_length_t args_cnt) /**< number of function arguments */
jerryx_handler_source_name (const jerry_call_info_t *call_info_p, /**< call information */
const jerry_value_t args_p[], /**< function arguments */
const jerry_length_t args_cnt) /**< number of function arguments */
{
(void) call_info_p; /* unused */
jerry_value_t undefined_value = jerry_create_undefined ();
jerry_value_t resource_name = jerry_get_resource_name (args_cnt > 0 ? args_p[0] : undefined_value);
jerry_release_value (undefined_value);
jerry_value_t undefined_value = jerry_undefined ();
jerry_value_t source_name = jerry_source_name (args_cnt > 0 ? args_p[0] : undefined_value);
jerry_value_free (undefined_value);
return resource_name;
} /* jerryx_handler_resource_name */
return source_name;
} /* jerryx_handler_source_name */

10
jerry-ext/include/jerryscript-ext/autorelease.h
View File

@ -21,25 +21,25 @@ JERRY_C_API_BEGIN
#include "autorelease.impl.h"
/*
* Macro for `const jerry_value_t` for which jerry_release_value () is
* Macro for `const jerry_value_t` for which jerry_value_free () is
* automatically called when the variable goes out of scope.
*
* Example usage:
* static void foo (bool enable)
* {
* JERRYX_AR_VALUE_T bar = jerry_create_string (...);
* JERRYX_AR_VALUE_T bar = jerry_string (...);
*
* if (enable) {
* JERRYX_AR_VALUE_T baz = jerry_get_global_object ();
* JERRYX_AR_VALUE_T baz = jerry_current_realm ();
*
* // ...
*
* // jerry_release_value (baz) and jerry_release_value (bar) is called automatically before
* // jerry_value_free (baz) and jerry_value_free (bar) is called automatically before
* // returning, because `baz` and `bar` go out of scope.
* return;
* }
*
* // jerry_release_value (bar) is called automatically when the function returns,
* // jerry_value_free (bar) is called automatically when the function returns,
* // because `bar` goes out of scope.
* }
*/

4
jerry-ext/include/jerryscript-ext/autorelease.impl.h
View File

@ -20,7 +20,7 @@
#ifdef __GNUC__
/*
* Calls jerry_release_value (*value).
* Calls jerry_value_free (*value).
* The GCC __cleanup__ function must take a pointer to the variable to clean up.
*
* @return void
@ -28,7 +28,7 @@
static inline void
jerryx_autorelease_cleanup (const jerry_value_t *value) /**< jerry value */
{
jerry_release_value (*value);
jerry_value_free (*value);
} /* jerryx_autorelease_cleanup */
#define __JERRYX_AR_VALUE_T_IMPL const jerry_value_t __attribute__ ((__cleanup__ (jerryx_autorelease_cleanup)))

38
jerry-ext/include/jerryscript-ext/handler.h
View File

@ -24,7 +24,7 @@ JERRY_C_API_BEGIN
* Handler registration helper
*/
jerry_value_t jerryx_handler_register_global (const jerry_char_t *name_p, jerry_external_handler_t handler_p);
jerry_value_t jerryx_handler_register_global (const char *name_p, jerry_external_handler_t handler_p);
/*
* Common external function handlers
@ -44,9 +44,9 @@ jerryx_handler_gc (const jerry_call_info_t *call_info_p, const jerry_value_t arg
jerry_value_t jerryx_handler_print (const jerry_call_info_t *call_info_p,
const jerry_value_t args_p[],
const jerry_length_t args_cnt);
jerry_value_t jerryx_handler_resource_name (const jerry_call_info_t *call_info_p,
const jerry_value_t args_p[],
const jerry_length_t args_cnt);
jerry_value_t jerryx_handler_source_name (const jerry_call_info_t *call_info_p,
const jerry_value_t args_p[],
const jerry_length_t args_cnt);
/**
* Struct used by the `jerryx_set_functions` method to
@ -61,32 +61,32 @@ typedef struct
#define JERRYX_PROPERTY_NUMBER(NAME, NUMBER) \
(jerryx_property_entry) \
{ \
NAME, jerry_create_number (NUMBER) \
NAME, jerry_number (NUMBER) \
}
#define JERRYX_PROPERTY_STRING(NAME, STR) \
(jerryx_property_entry) \
{ \
NAME, jerry_create_string_from_utf8 ((const jerry_char_t *) STR) \
#define JERRYX_PROPERTY_STRING(NAME, STR, SIZE) \
(jerryx_property_entry) \
{ \
NAME, jerry_string ((const jerry_char_t *) STR, SIZE, JERRY_ENCODING_UTF8) \
}
#define JERRYX_PROPERTY_STRING_SZ(NAME, STR, SIZE) \
(jerryx_property_entry) \
{ \
NAME, jerry_create_string_sz_from_utf8 ((const jerry_char_t *) STR, SIZE) \
#define JERRYX_PROPERTY_STRING_SZ(NAME, STR) \
(jerryx_property_entry) \
{ \
NAME, jerry_string_sz (STR) \
}
#define JERRYX_PROPERTY_BOOLEAN(NAME, VALUE) \
(jerryx_property_entry) \
{ \
NAME, jerry_create_boolean (VALUE) \
NAME, jerry_boolean (VALUE) \
}
#define JERRYX_PROPERTY_FUNCTION(NAME, FUNC) \
(jerryx_property_entry) \
{ \
NAME, jerry_create_external_function (FUNC) \
#define JERRYX_PROPERTY_FUNCTION(NAME, FUNC) \
(jerryx_property_entry) \
{ \
NAME, jerry_function_external (FUNC) \
}
#define JERRYX_PROPERTY_UNDEFINED(NAME) \
(jerryx_property_entry) \
{ \
NAME, jerry_create_undefined () \
NAME, jerry_undefined () \
}
#define JERRYX_PROPERTY_LIST_END() \
(jerryx_property_entry) \

60
jerry-ext/module/module.c
View File

@ -19,9 +19,9 @@
#include "jerryscript.h"
static const jerry_char_t *module_name_property_name = (jerry_char_t *) "moduleName";
static const jerry_char_t *module_not_found = (jerry_char_t *) "Module not found";
static const jerry_char_t *module_name_not_string = (jerry_char_t *) "Module name is not a string";
static const char *module_name_property_name = "moduleName";
static const char *module_not_found = "Module not found";
static const char *module_name_not_string = "Module name is not a string";
/**
* Create an error related to modules
@ -33,19 +33,16 @@ static const jerry_char_t *module_name_not_string = (jerry_char_t *) "Module nam
*/
static jerry_value_t
jerryx_module_create_error (jerry_error_t error_type, /**< the type of error to create */
const jerry_char_t *message, /**< the error message */
const char *message, /**< the error message */
const jerry_value_t module_name) /**< the module name */
{
jerry_value_t ret = jerry_create_error (error_type, message);
jerry_value_t error_object = jerry_error_sz (error_type, message);
jerry_value_t property_name = jerry_string_sz (module_name_property_name);
jerry_value_t error_object = jerry_get_value_from_error (ret, false);
jerry_value_t property_name = jerry_create_string (module_name_property_name);
jerry_value_free (jerry_object_set (error_object, property_name, module_name));
jerry_release_value (jerry_set_property (error_object, property_name, module_name));
jerry_release_value (property_name);
jerry_release_value (error_object);
return ret;
jerry_value_free (property_name);
return jerry_throw_value (error_object, true);
} /* jerryx_module_create_error */
/**
@ -54,7 +51,7 @@ jerryx_module_create_error (jerry_error_t error_type, /**< the type of error to
static void
jerryx_module_manager_init (void *user_data_p)
{
*((jerry_value_t *) user_data_p) = jerry_create_object ();
*((jerry_value_t *) user_data_p) = jerry_object ();
} /* jerryx_module_manager_init */
/**
@ -63,7 +60,7 @@ jerryx_module_manager_init (void *user_data_p)
static void
jerryx_module_manager_deinit (void *user_data_p) /**< context pointer to deinitialize */
{
jerry_release_value (*(jerry_value_t *) user_data_p);
jerry_value_free (*(jerry_value_t *) user_data_p);
} /* jerryx_module_manager_deinit */
/**
@ -118,10 +115,10 @@ jerryx_module_check_cache (jerry_value_t cache, /**< cache from which to attempt
bool ret = false;
/* Check if the cache has the module. */
jerry_value_t js_has_property = jerry_has_property (cache, module_name);
jerry_value_t js_has_property = jerry_object_has (cache, module_name);
/* If we succeed in getting an answer, we examine the answer. */
if (!jerry_value_is_error (js_has_property))
if (!jerry_value_is_exception (js_has_property))
{
bool has_property = jerry_value_is_true (js_has_property);
@ -130,13 +127,13 @@ jerryx_module_check_cache (jerry_value_t cache, /**< cache from which to attempt
{
if (result != NULL)
{
(*result) = jerry_get_property (cache, module_name);
(*result) = jerry_object_get (cache, module_name);
}
ret = true;
}
}
jerry_release_value (js_has_property);
jerry_value_free (js_has_property);
return ret;
} /* jerryx_module_check_cache */
@ -152,22 +149,22 @@ jerryx_module_add_to_cache (jerry_value_t cache, /**< cache to which to add the
jerry_value_t module_name, /**< key at which to cache the module */
jerry_value_t module) /**< the module to cache */
{
jerry_value_t ret = jerry_set_property (cache, module_name, module);
jerry_value_t ret = jerry_object_set (cache, module_name, module);
if (jerry_value_is_error (ret))
if (jerry_value_is_exception (ret))
{
jerry_release_value (module);
jerry_value_free (module);
}
else
{
jerry_release_value (ret);
jerry_value_free (ret);
ret = module;
}
return ret;
} /* jerryx_module_add_to_cache */
static const jerry_char_t *on_resolve_absent = (jerry_char_t *) "Module on_resolve () must not be NULL";
static const char *on_resolve_absent = "Module on_resolve () must not be NULL";
/**
* Declare and define the default module resolver - one which examines what modules are defined in the above linker
@ -180,9 +177,9 @@ jerryx_resolve_native_module (const jerry_value_t canonical_name, /**< canonical
{
const jerryx_native_module_t *module_p = NULL;
jerry_size_t name_size = jerry_get_utf8_string_size (canonical_name);
jerry_size_t name_size = jerry_string_size (canonical_name, JERRY_ENCODING_UTF8);
JERRY_VLA (jerry_char_t, name_string, name_size);
jerry_string_to_utf8_char_buffer (canonical_name, name_string, name_size);
jerry_string_to_buffer (canonical_name, JERRY_ENCODING_UTF8, name_string, name_size);
/* Look for the module by its name in the list of module definitions. */
for (module_p = first_module_p; module_p != NULL; module_p = module_p->next_p)
@ -226,7 +223,7 @@ jerryx_module_resolve_local (const jerry_value_t name, /**< name of the module t
goto done;
}
instances = *(jerry_value_t *) jerry_get_context_data (&jerryx_module_manager);
instances = *(jerry_value_t *) jerry_context_data (&jerryx_module_manager);
/**
* Establish the canonical name for the requested module. Each resolver presents its own canonical name. If one of
@ -235,15 +232,14 @@ jerryx_module_resolve_local (const jerry_value_t name, /**< name of the module t
for (index = 0; index < resolver_count; index++)
{
get_canonical_name_p = (resolvers_p[index] == NULL ? NULL : resolvers_p[index]->get_canonical_name_p);
canonical_names[index] =
((get_canonical_name_p == NULL) ? jerry_acquire_value (name) : get_canonical_name_p (name));
canonical_names[index] = ((get_canonical_name_p == NULL) ? jerry_value_copy (name) : get_canonical_name_p (name));
canonical_names_used++;
if (jerryx_module_check_cache (instances, canonical_names[index], result))
{
/* A NULL for result indicates that we are to delete the module from the cache if found. Let's do that here.*/
if (result == NULL)
{
jerry_delete_property (instances, canonical_names[index]);
jerry_object_delete (instances, canonical_names[index]);
}
goto done;
}
@ -263,7 +259,7 @@ jerryx_module_resolve_local (const jerry_value_t name, /**< name of the module t
resolve_p = (resolvers_p[index] == NULL ? NULL : resolvers_p[index]->resolve_p);
if (resolve_p != NULL && resolve_p (canonical_names[index], result))
{
if (!jerry_value_is_error (*result))
if (!jerry_value_is_exception (*result))
{
*result = jerryx_module_add_to_cache (instances, canonical_names[index], *result);
}
@ -278,7 +274,7 @@ done:
/* Release the canonical names as returned by the various resolvers. */
for (index = 0; index < canonical_names_used; index++)
{
jerry_release_value (canonical_names[index]);
jerry_value_free (canonical_names[index]);
}
} /* jerryx_module_resolve_local */
@ -311,7 +307,7 @@ jerryx_module_clear_cache (const jerry_value_t name, /**< name of the module to
const jerryx_module_resolver_t **resolvers_p, /**< list of resolvers */
size_t resolver_count) /**< number of resolvers in @p resolvers */
{
void *instances_p = jerry_get_context_data (&jerryx_module_manager);
void *instances_p = jerry_context_data (&jerryx_module_manager);
if (jerry_value_is_undefined (name))
{

16
jerry-main/libfuzzer.c
View File

@ -23,20 +23,22 @@ LLVMFuzzerTestOneInput (const uint8_t *data, size_t size)
srand (0);
jerry_init (JERRY_INIT_EMPTY);
if (jerry_is_valid_utf8_string ((jerry_char_t *) data, (jerry_size_t) size))
if (jerry_validate_string ((jerry_char_t *) data, (jerry_size_t) size, JERRY_ENCODING_UTF8))
{
jerry_value_t parse_value = jerry_parse (NULL, 0, (jerry_char_t *) data, size, JERRY_PARSE_NO_OPTS);
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_NO_OPTS;
jerry_value_t parse_value = jerry_parse ((jerry_char_t *) data, size, &parse_options);
if (!jerry_value_is_error (parse_value))
if (!jerry_value_is_exception (parse_value))
{
jerry_value_t run_value = jerry_run (parse_value);
jerry_release_value (run_value);
jerry_value_free (run_value);
jerry_value_t run_queue_value = jerry_run_all_enqueued_jobs ();
jerry_release_value (run_queue_value);
run_value = jerry_run_jobs ();
jerry_value_free (run_value);
}
jerry_release_value (parse_value);
jerry_value_free (parse_value);
}
jerry_cleanup ();

58
jerry-main/main-jerry-snapshot.c
View File

@ -48,7 +48,7 @@ static const jerry_char_t *magic_string_items[JERRY_LITERAL_LENGTH];
#if defined(JERRY_EXTERNAL_CONTEXT) && (JERRY_EXTERNAL_CONTEXT == 1)
/**
* The alloc function passed to jerry_create_context
* The alloc function passed to jerry_context_create
*/
static void *
context_alloc (size_t size, void *cb_data_p)
@ -63,7 +63,7 @@ context_alloc (size_t size, void *cb_data_p)
static void
context_init (void)
{
jerry_context_t *context_p = jerry_create_context (JERRY_GLOBAL_HEAP_SIZE * 1024, context_alloc, NULL);
jerry_context_t *context_p = jerry_context_alloc (JERRY_GLOBAL_HEAP_SIZE * 1024, context_alloc, NULL);
jerry_port_default_set_current_context (context_p);
} /* context_init */
@ -79,7 +79,7 @@ static bool
check_feature (jerry_feature_t feature, /**< feature to check */
const char *option) /**< command line option that triggered this check */
{
if (!jerry_is_feature_enabled (feature))
if (!jerry_feature_enabled (feature))
{
jerry_port_default_set_log_level (JERRY_LOG_LEVEL_WARNING);
jerry_port_log (JERRY_LOG_LEVEL_WARNING, "Ignoring '%s' option because this feature is disabled!\n", option);
@ -159,34 +159,24 @@ read_file (uint8_t *input_pos_p, /**< next position in the input buffer */
static void
print_unhandled_exception (jerry_value_t error_value) /**< error value */
{
assert (!jerry_value_is_error (error_value));
assert (!jerry_value_is_exception (error_value));
jerry_value_t err_str_val = jerry_value_to_string (error_value);
if (jerry_value_is_error (err_str_val))
if (jerry_value_is_exception (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_utf8_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);
jerry_value_free (err_str_val);
return;
}
jerry_char_t err_str_buf[256];
jerry_size_t string_end = jerry_string_to_utf8_char_buffer (err_str_val, err_str_buf, err_str_size);
assert (string_end == err_str_size);
err_str_buf[string_end] = 0;
jerry_size_t bytes = jerry_string_to_buffer (err_str_val, JERRY_ENCODING_UTF8, err_str_buf, sizeof (err_str_buf) - 1);
err_str_buf[bytes] = '\0';
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Snapshot error: %s\n", (char *) err_str_buf);
jerry_release_value (err_str_val);
jerry_value_free (err_str_val);
} /* print_unhandled_exception */
/**
@ -333,7 +323,7 @@ process_generate (cli_state_t *cli_state_p, /**< cli state */
jerry_init (flags);
if (!jerry_is_valid_utf8_string (source_p, (jerry_size_t) source_length))
if (!jerry_validate_string (source_p, (jerry_size_t) source_length, JERRY_ENCODING_UTF8))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: Input must be a valid UTF-8 string.\n");
jerry_cleanup ();
@ -372,50 +362,52 @@ process_generate (cli_state_t *cli_state_p, /**< cli state */
}
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
parse_options.options = JERRY_PARSE_HAS_SOURCE_NAME;
/* To avoid cppcheck warning. */
parse_options.argument_list = 0;
parse_options.resource_name =
jerry_create_string_sz ((const jerry_char_t *) file_name_p, (jerry_size_t) strlen (file_name_p));
parse_options.source_name =
jerry_string ((const jerry_char_t *) file_name_p, (jerry_size_t) strlen (file_name_p), JERRY_ENCODING_UTF8);
if (function_args_p != NULL)
{
parse_options.options |= JERRY_PARSE_HAS_ARGUMENT_LIST;
parse_options.argument_list = jerry_create_string_from_utf8 ((const jerry_char_t *) function_args_p);
parse_options.argument_list = jerry_string ((const jerry_char_t *) function_args_p,
(jerry_size_t) strlen (function_args_p),
JERRY_ENCODING_UTF8);
}
jerry_value_t snapshot_result = jerry_parse ((jerry_char_t *) source_p, source_length, &parse_options);
if (!jerry_value_is_error (snapshot_result))
if (!jerry_value_is_exception (snapshot_result))
{
jerry_value_t parse_result = snapshot_result;
snapshot_result =
jerry_generate_snapshot (parse_result, snapshot_flags, output_buffer, sizeof (output_buffer) / sizeof (uint32_t));
jerry_release_value (parse_result);
jerry_value_free (parse_result);
}
if (parse_options.options & JERRY_PARSE_HAS_ARGUMENT_LIST)
{
jerry_release_value (parse_options.argument_list);
jerry_value_free (parse_options.argument_list);
}
jerry_release_value (parse_options.resource_name);
jerry_value_free (parse_options.source_name);
if (jerry_value_is_error (snapshot_result))
if (jerry_value_is_exception (snapshot_result))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: Generating snapshot failed!\n");
snapshot_result = jerry_get_value_from_error (snapshot_result, true);
snapshot_result = jerry_exception_value (snapshot_result, true);
print_unhandled_exception (snapshot_result);
jerry_release_value (snapshot_result);
jerry_value_free (snapshot_result);
jerry_cleanup ();
return JERRY_STANDALONE_EXIT_CODE_FAIL;
}
size_t snapshot_size = (size_t) jerry_get_number_value (snapshot_result);
jerry_release_value (snapshot_result);
size_t snapshot_size = (size_t) jerry_value_as_number (snapshot_result);
jerry_value_free (snapshot_result);
FILE *snapshot_file_p = fopen (output_file_name_p, "wb");
if (snapshot_file_p == NULL)

19
jerry-main/main-jerry-test.c
View File

@ -75,7 +75,7 @@ static JERRY_ATTR_NOINLINE int
run (void)
{
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t ret_value = jerry_create_undefined ();
jerry_value_t ret_value = jerry_undefined ();
for (int i = 1; i < argc; i++)
{
@ -86,33 +86,34 @@ run (void)
if (source_p == NULL)
{
ret_value = jerry_create_error (JERRY_ERROR_COMMON, (jerry_char_t *) "");
ret_value = jerry_throw_sz (JERRY_ERROR_COMMON, "");
break;
}
else
{
ret_value = jerry_parse (source_p, source_size, NULL);
if (!jerry_value_is_error (ret_value))
if (!jerry_value_is_exception (ret_value))
{
jerry_value_t func_val = ret_value;
ret_value = jerry_run (func_val);
jerry_release_value (func_val);
jerry_value_free (func_val);
}
}
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
break;
}
jerry_release_value (ret_value);
ret_value = jerry_create_undefined ();
jerry_value_free (ret_value);
ret_value = jerry_undefined ();
}
int ret_code = !jerry_value_is_error (ret_value) ? JERRY_STANDALONE_EXIT_CODE_OK : JERRY_STANDALONE_EXIT_CODE_FAIL;
int ret_code =
!jerry_value_is_exception (ret_value) ? JERRY_STANDALONE_EXIT_CODE_OK : JERRY_STANDALONE_EXIT_CODE_FAIL;
jerry_release_value (ret_value);
jerry_value_free (ret_value);
jerry_cleanup ();
return ret_code;

101
jerry-main/main-jerry.c
View File

@ -34,7 +34,7 @@
#if defined(JERRY_EXTERNAL_CONTEXT) && (JERRY_EXTERNAL_CONTEXT == 1)
/**
* The alloc function passed to jerry_create_context
* The alloc function passed to jerry_context_create
*/
static void *
context_alloc (size_t size, void *cb_data_p)
@ -62,7 +62,7 @@ main (int argc, char **argv)
main_parse_args (argc, argv, &arguments);
#if defined(JERRY_EXTERNAL_CONTEXT) && (JERRY_EXTERNAL_CONTEXT == 1)
jerry_context_t *context_p = jerry_create_context (JERRY_GLOBAL_HEAP_SIZE * 1024, context_alloc, NULL);
jerry_context_t *context_p = jerry_context_alloc (JERRY_GLOBAL_HEAP_SIZE * 1024, context_alloc, NULL);
jerry_port_default_set_current_context (context_p);
#endif /* defined (JERRY_EXTERNAL_CONTEXT) && (JERRY_EXTERNAL_CONTEXT == 1) */
@ -78,45 +78,46 @@ restart:
if (source_file_p->type == SOURCE_MODULE)
{
jerry_value_t specifier = jerry_create_string_from_utf8 ((const jerry_char_t *) file_path_p);
jerry_value_t referrer = jerry_create_undefined ();
jerry_value_t specifier =
jerry_string ((const jerry_char_t *) file_path_p, (jerry_size_t) strlen (file_path_p), JERRY_ENCODING_UTF8);
jerry_value_t referrer = jerry_undefined ();
ret_value = jerry_port_module_resolve (specifier, referrer, NULL);
jerry_release_value (referrer);
jerry_release_value (specifier);
jerry_value_free (referrer);
jerry_value_free (specifier);
if (!jerry_value_is_error (ret_value))
if (!jerry_value_is_exception (ret_value))
{
if (jerry_module_get_state (ret_value) != JERRY_MODULE_STATE_UNLINKED)
if (jerry_module_state (ret_value) != JERRY_MODULE_STATE_UNLINKED)
{
/* A module can be evaluated only once. */
jerry_release_value (ret_value);
jerry_value_free (ret_value);
continue;
}
jerry_value_t link_val = jerry_module_link (ret_value, NULL, NULL);
if (jerry_value_is_error (link_val))
if (jerry_value_is_exception (link_val))
{
jerry_release_value (ret_value);
jerry_value_free (ret_value);
ret_value = link_val;
}
else
{
jerry_release_value (link_val);
jerry_value_free (link_val);
jerry_value_t module_val = ret_value;
ret_value = jerry_module_evaluate (module_val);
jerry_release_value (module_val);
jerry_value_free (module_val);
}
}
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
main_print_unhandled_exception (ret_value);
goto exit;
}
jerry_release_value (ret_value);
jerry_value_free (ret_value);
continue;
}
@ -145,7 +146,7 @@ restart:
{
assert (source_file_p->type == SOURCE_SCRIPT || source_file_p->type == SOURCE_MODULE);
if (!jerry_is_valid_utf8_string ((jerry_char_t *) source_p, (jerry_size_t) source_size))
if (!jerry_validate_string ((jerry_char_t *) source_p, (jerry_size_t) source_size, JERRY_ENCODING_UTF8))
{
jerry_port_release_source (source_p);
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: Input must be a valid UTF-8 string.");
@ -153,27 +154,27 @@ restart:
}
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name =
jerry_create_string_sz ((const jerry_char_t *) file_path_p, (jerry_size_t) strlen (file_path_p));
parse_options.options = JERRY_PARSE_HAS_SOURCE_NAME;
parse_options.source_name =
jerry_string ((const jerry_char_t *) file_path_p, (jerry_size_t) strlen (file_path_p), JERRY_ENCODING_UTF8);
ret_value = jerry_parse (source_p, source_size, &parse_options);
jerry_release_value (parse_options.resource_name);
jerry_value_free (parse_options.source_name);
jerry_port_release_source (source_p);
if (!jerry_value_is_error (ret_value) && !(arguments.option_flags & OPT_FLAG_PARSE_ONLY))
if (!jerry_value_is_exception (ret_value) && !(arguments.option_flags & OPT_FLAG_PARSE_ONLY))
{
jerry_value_t func_val = ret_value;
ret_value = jerry_run (func_val);
jerry_release_value (func_val);
jerry_value_free (func_val);
}
break;
}
}
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
if (main_is_value_reset (ret_value))
{
@ -186,7 +187,7 @@ restart:
goto exit;
}
jerry_release_value (ret_value);
jerry_value_free (ret_value);
}
if (arguments.option_flags & OPT_FLAG_WAIT_SOURCE)
@ -218,7 +219,7 @@ restart:
}
assert (receive_status == JERRY_DEBUGGER_SOURCE_RECEIVED);
jerry_release_value (ret_value);
jerry_value_free (ret_value);
}
}
else if (arguments.option_flags & OPT_FLAG_USE_STDIN)
@ -241,7 +242,7 @@ restart:
ret_value = jerry_parse ((jerry_char_t *) source_p, source_size, NULL);
free (source_p);
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
main_print_unhandled_exception (ret_value);
goto exit;
@ -249,15 +250,15 @@ restart:
jerry_value_t func_val = ret_value;
ret_value = jerry_run (func_val);
jerry_release_value (func_val);
jerry_value_free (func_val);
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
main_print_unhandled_exception (ret_value);
goto exit;
}
jerry_release_value (ret_value);
jerry_value_free (ret_value);
}
else if (arguments.source_count == 0)
{
@ -282,7 +283,7 @@ restart:
continue;
}
if (!jerry_is_valid_utf8_string ((jerry_char_t *) str_p, (jerry_size_t) len))
if (!jerry_validate_string ((jerry_char_t *) str_p, (jerry_size_t) len, JERRY_ENCODING_UTF8))
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: Input must be a valid UTF-8 string.\n");
continue;
@ -290,7 +291,7 @@ restart:
ret_value = jerry_parse ((jerry_char_t *) str_p, len, NULL);
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
main_print_unhandled_exception (ret_value);
continue;
@ -298,9 +299,9 @@ restart:
jerry_value_t func_val = ret_value;
ret_value = jerry_run (func_val);
jerry_release_value (func_val);
jerry_value_free (func_val);
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
main_print_unhandled_exception (ret_value);
continue;
@ -308,53 +309,53 @@ restart:
const jerry_value_t args[] = { ret_value };
jerry_value_t ret_val_print = jerryx_handler_print (NULL, args, 1);
jerry_release_value (ret_val_print);
jerry_release_value (ret_value);
ret_value = jerry_run_all_enqueued_jobs ();
jerry_value_free (ret_val_print);
jerry_value_free (ret_value);
ret_value = jerry_run_jobs ();
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
main_print_unhandled_exception (ret_value);
continue;
}
jerry_release_value (ret_value);
jerry_value_free (ret_value);
}
}
ret_value = jerry_run_all_enqueued_jobs ();
ret_value = jerry_run_jobs ();
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
main_print_unhandled_exception (ret_value);
goto exit;
}
jerry_release_value (ret_value);
jerry_value_free (ret_value);
if (arguments.exit_cb_name_p != NULL)
{
jerry_value_t global = jerry_get_global_object ();
jerry_value_t name_str = jerry_create_string ((jerry_char_t *) arguments.exit_cb_name_p);
jerry_value_t callback_fn = jerry_get_property (global, name_str);
jerry_value_t global = jerry_current_realm ();
jerry_value_t name_str = jerry_string_sz (arguments.exit_cb_name_p);
jerry_value_t callback_fn = jerry_object_get (global, name_str);
jerry_release_value (global);
jerry_release_value (name_str);
jerry_value_free (global);
jerry_value_free (name_str);
if (jerry_value_is_function (callback_fn))
{
ret_value = jerry_call_function (callback_fn, jerry_create_undefined (), NULL, 0);
ret_value = jerry_call (callback_fn, jerry_undefined (), NULL, 0);
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
main_print_unhandled_exception (ret_value);
goto exit;
}
jerry_release_value (ret_value);
jerry_value_free (ret_value);
}
jerry_release_value (callback_fn);
jerry_value_free (callback_fn);
}
return_code = JERRY_STANDALONE_EXIT_CODE_OK;

4
jerry-main/main-options.c
View File

@ -131,7 +131,7 @@ static bool
check_feature (jerry_feature_t feature, /**< feature to check */
const char *option) /**< command line option that triggered this check */
{
if (!jerry_is_feature_enabled (feature))
if (!jerry_feature_enabled (feature))
{
jerry_port_default_set_log_level (JERRY_LOG_LEVEL_WARNING);
jerry_port_log (JERRY_LOG_LEVEL_WARNING, "Ignoring '%s' option because this feature is disabled!\n", option);
@ -184,7 +184,7 @@ main_parse_args (int argc, /**< argc */
}
case OPT_MEM_STATS:
{
if (check_feature (JERRY_FEATURE_MEM_STATS, cli_state.arg))
if (check_feature (JERRY_FEATURE_HEAP_STATS, cli_state.arg))
{
jerry_port_default_set_log_level (JERRY_LOG_LEVEL_DEBUG);
arguments_p->init_flags |= JERRY_INIT_MEM_STATS;

330
jerry-main/main-utils.c
View File

@ -40,9 +40,9 @@ static void
main_register_global_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);
assert (!jerry_value_is_error (result_val));
jerry_release_value (result_val);
jerry_value_t result_val = jerryx_handler_register_global (name_p, handler_p);
assert (!jerry_value_is_exception (result_val));
jerry_value_free (result_val);
} /* main_register_global_function */
static jerry_value_t
@ -53,7 +53,7 @@ main_create_realm (const jerry_call_info_t *call_info_p, /**< call information *
(void) call_info_p; /* unused */
(void) args_p; /* unused */
(void) args_cnt; /* unused */
return jerry_create_realm ();
return jerry_realm ();
} /* main_create_realm */
/**
@ -64,16 +64,16 @@ test262_register_function (jerry_value_t test262_obj, /** $262 object */
const char *name_p, /**< name of the function */
jerry_external_handler_t handler_p) /**< function callback */
{
jerry_value_t function_name_val = jerry_create_string ((const jerry_char_t *) name_p);
jerry_value_t function_val = jerry_create_external_function (handler_p);
jerry_value_t function_name_val = jerry_string_sz (name_p);
jerry_value_t function_val = jerry_function_external (handler_p);
jerry_value_t result_val = jerry_set_property (test262_obj, function_name_val, function_val);
jerry_value_t result_val = jerry_object_set (test262_obj, function_name_val, function_val);
jerry_release_value (function_val);
jerry_release_value (function_name_val);
jerry_value_free (function_val);
jerry_value_free (function_name_val);
assert (!jerry_value_is_error (result_val));
jerry_release_value (result_val);
assert (!jerry_value_is_exception (result_val));
jerry_value_free (result_val);
} /* test262_register_function */
/**
@ -93,12 +93,12 @@ test262_detach_array_buffer (const jerry_call_info_t *call_info_p, /**< call inf
if (args_cnt < 1 || !jerry_value_is_arraybuffer (args_p[0]))
{
return jerry_create_error (JERRY_ERROR_TYPE, (jerry_char_t *) "Expected an ArrayBuffer object");
return jerry_throw_sz (JERRY_ERROR_TYPE, "Expected an ArrayBuffer object");
}
/* TODO: support the optional 'key' argument */
return jerry_detach_arraybuffer (args_p[0]);
return jerry_arraybuffer_detach (args_p[0]);
} /* test262_detach_array_buffer */
/**
@ -117,25 +117,26 @@ test262_eval_script (const jerry_call_info_t *call_info_p, /**< call information
if (args_cnt < 1 || !jerry_value_is_string (args_p[0]))
{
return jerry_create_error (JERRY_ERROR_TYPE, (jerry_char_t *) "Expected a string");
return jerry_throw_sz (JERRY_ERROR_TYPE, "Expected a string");
}
jerry_size_t str_size = jerry_get_utf8_string_size (args_p[0]);
jerry_size_t str_size = jerry_string_size (args_p[0], JERRY_ENCODING_UTF8);
jerry_char_t *str_buf_p = malloc (str_size * sizeof (jerry_char_t));
if (str_buf_p == NULL || jerry_string_to_utf8_char_buffer (args_p[0], str_buf_p, str_size) != str_size)
if (str_buf_p == NULL)
{
free (str_buf_p);
return jerry_create_error (JERRY_ERROR_RANGE, (jerry_char_t *) "Internal error");
return jerry_throw_sz (JERRY_ERROR_RANGE, "Internal allocation error");
}
jerry_string_to_buffer (args_p[0], JERRY_ENCODING_UTF8, str_buf_p, str_size);
jerry_value_t ret_value = jerry_parse (str_buf_p, str_size, NULL);
if (!jerry_value_is_error (ret_value))
if (!jerry_value_is_exception (ret_value))
{
jerry_value_t func_val = ret_value;
ret_value = jerry_run (func_val);
jerry_release_value (func_val);
jerry_value_free (func_val);
}
free (str_buf_p);
@ -161,12 +162,12 @@ test262_create_realm (const jerry_call_info_t *call_info_p, /**< call informatio
(void) args_p; /* unused */
(void) args_cnt; /* unused */
jerry_value_t realm_object = jerry_create_realm ();
jerry_value_t realm_object = jerry_realm ();
jerry_value_t previous_realm = jerry_set_realm (realm_object);
assert (!jerry_value_is_error (previous_realm));
assert (!jerry_value_is_exception (previous_realm));
jerry_value_t test262_object = create_test262 (realm_object);
jerry_set_realm (previous_realm);
jerry_release_value (realm_object);
jerry_value_free (realm_object);
return test262_object;
} /* test262_create_realm */
@ -179,24 +180,26 @@ test262_create_realm (const jerry_call_info_t *call_info_p, /**< call informatio
static jerry_value_t
create_test262 (jerry_value_t global_obj) /**< global object */
{
jerry_value_t test262_object = jerry_create_object ();
jerry_value_t test262_object = jerry_object ();
test262_register_function (test262_object, "detachArrayBuffer", test262_detach_array_buffer);
test262_register_function (test262_object, "evalScript", test262_eval_script);
test262_register_function (test262_object, "createRealm", test262_create_realm);
test262_register_function (test262_object, "gc", jerryx_handler_gc);
jerry_value_t prop_name = jerry_create_string ((const jerry_char_t *) "global");
jerry_value_t result = jerry_set_property (test262_object, prop_name, global_obj);
assert (!jerry_value_is_error (result));
jerry_release_value (prop_name);
jerry_release_value (result);
prop_name = jerry_create_string ((const jerry_char_t *) "$262");
result = jerry_set_property (global_obj, prop_name, test262_object);
jerry_value_t prop_name = jerry_string_sz ("global");
jerry_value_t result = jerry_object_set (test262_object, prop_name, global_obj);
assert (!jerry_value_is_exception (result));
jerry_release_value (prop_name);
assert (!jerry_value_is_error (result));
jerry_release_value (result);
jerry_value_free (prop_name);
jerry_value_free (result);
prop_name = jerry_string_sz ("$262");
result = jerry_object_set (global_obj, prop_name, test262_object);
assert (!jerry_value_is_exception (result));
jerry_value_free (prop_name);
jerry_value_free (result);
return test262_object;
} /* create_test262 */
@ -216,12 +219,12 @@ promise_callback (jerry_promise_event_type_t event_type, /**< event type */
return;
}
jerry_value_t reason = jerry_get_promise_result (object);
jerry_value_t reason = jerry_promise_result (object);
jerry_value_t reason_to_string = jerry_value_to_string (reason);
if (!jerry_value_is_error (reason_to_string))
if (!jerry_value_is_exception (reason_to_string))
{
jerry_size_t buffer_size = jerry_get_utf8_string_size (reason_to_string);
jerry_size_t buffer_size = jerry_string_size (reason_to_string, JERRY_ENCODING_UTF8);
if (buffer_size > max_allowed_size)
{
@ -229,7 +232,7 @@ promise_callback (jerry_promise_event_type_t event_type, /**< event type */
}
JERRY_VLA (jerry_char_t, str_buf_p, buffer_size + 1);
jerry_string_to_utf8_char_buffer (reason_to_string, str_buf_p, buffer_size);
jerry_string_to_buffer (reason_to_string, JERRY_ENCODING_UTF8, str_buf_p, buffer_size);
str_buf_p[buffer_size] = '\0';
jerry_port_log (JERRY_LOG_LEVEL_WARNING, "Uncaught Promise rejection: %s\n", str_buf_p);
@ -239,8 +242,8 @@ promise_callback (jerry_promise_event_type_t event_type, /**< event type */
jerry_port_log (JERRY_LOG_LEVEL_WARNING, "Uncaught Promise rejection (reason cannot be converted to string)\n");
}
jerry_release_value (reason_to_string);
jerry_release_value (reason);
jerry_value_free (reason_to_string);
jerry_value_free (reason);
} /* promise_callback */
/**
@ -251,7 +254,7 @@ main_init_engine (main_args_t *arguments_p) /**< main arguments */
{
jerry_init (arguments_p->init_flags);
jerry_promise_set_callback (JERRY_PROMISE_EVENT_FILTER_ERROR, promise_callback, NULL);
jerry_promise_on_event (JERRY_PROMISE_EVENT_FILTER_ERROR, promise_callback, NULL);
if (arguments_p->option_flags & OPT_FLAG_DEBUG_SERVER)
{
@ -279,15 +282,15 @@ main_init_engine (main_args_t *arguments_p) /**< main arguments */
}
if (arguments_p->option_flags & OPT_FLAG_TEST262_OBJECT)
{
jerry_value_t global_obj = jerry_get_global_object ();
jerry_value_t global_obj = jerry_current_realm ();
jerry_value_t test262_object = create_test262 (global_obj);
jerry_release_value (test262_object);
jerry_release_value (global_obj);
jerry_value_free (test262_object);
jerry_value_free (global_obj);
}
main_register_global_function ("assert", jerryx_handler_assert);
main_register_global_function ("gc", jerryx_handler_gc);
main_register_global_function ("print", jerryx_handler_print);
main_register_global_function ("resourceName", jerryx_handler_resource_name);
main_register_global_function ("resourceName", jerryx_handler_source_name);
main_register_global_function ("createRealm", main_create_realm);
} /* main_init_engine */
@ -299,129 +302,118 @@ main_init_engine (main_args_t *arguments_p) /**< main arguments */
void
main_print_unhandled_exception (jerry_value_t error_value) /**< error value */
{
assert (jerry_value_is_error (error_value));
error_value = jerry_get_value_from_error (error_value, true);
assert (jerry_value_is_exception (error_value));
error_value = jerry_exception_value (error_value, true);
jerry_char_t err_str_buf[256];
jerry_value_t err_str_val = jerry_value_to_string (error_value);
jerry_size_t err_str_size = jerry_get_utf8_string_size (err_str_val);
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 + 1);
}
else
{
jerry_size_t string_end = jerry_string_to_utf8_char_buffer (err_str_val, err_str_buf, err_str_size);
assert (string_end == err_str_size);
err_str_buf[string_end] = 0;
jerry_size_t string_end =
jerry_string_to_buffer (err_str_val, JERRY_ENCODING_UTF8, err_str_buf, sizeof (err_str_buf) - 1);
err_str_buf[string_end] = '\0';
if (jerry_is_feature_enabled (JERRY_FEATURE_ERROR_MESSAGES)
&& jerry_get_error_type (error_value) == JERRY_ERROR_SYNTAX)
if (jerry_feature_enabled (JERRY_FEATURE_ERROR_MESSAGES) && jerry_error_type (error_value) == JERRY_ERROR_SYNTAX)
{
jerry_char_t *string_end_p = err_str_buf + string_end;
unsigned int err_line = 0;
unsigned int err_col = 0;
char *path_str_p = NULL;
char *path_str_end_p = NULL;
/* 1. parse column and line information */
for (jerry_char_t *current_p = err_str_buf; current_p < string_end_p; current_p++)
{
jerry_char_t *string_end_p = err_str_buf + string_end;
unsigned int err_line = 0;
unsigned int err_col = 0;
char *path_str_p = NULL;
char *path_str_end_p = NULL;
/* 1. parse column and line information */
for (jerry_char_t *current_p = err_str_buf; current_p < string_end_p; current_p++)
if (*current_p == '[')
{
if (*current_p == '[')
current_p++;
if (*current_p == '<')
{
current_p++;
if (*current_p == '<')
{
break;
}
path_str_p = (char *) current_p;
while (current_p < string_end_p && *current_p != ':')
{
current_p++;
}
path_str_end_p = (char *) current_p++;
err_line = (unsigned int) strtol ((char *) current_p, (char **) &current_p, 10);
current_p++;
err_col = (unsigned int) strtol ((char *) current_p, NULL, 10);
break;
}
} /* for */
if (err_line != 0 && err_col > 0 && err_col < SYNTAX_ERROR_MAX_LINE_LENGTH)
{
/* Temporarily modify the error message, so we can use the path. */
*path_str_end_p = '\0';
size_t source_size;
uint8_t *source_p = jerry_port_read_source (path_str_p, &source_size);
/* Revert the error message. */
*path_str_end_p = ':';
if (source_p != NULL)
path_str_p = (char *) current_p;
while (current_p < string_end_p && *current_p != ':')
{
uint32_t curr_line = 1;
uint32_t pos = 0;
/* 2. seek and print */
while (pos < source_size && curr_line < err_line)
{
if (source_p[pos] == '\n')
{
curr_line++;
}
pos++;
}
/* Print character if:
* - The max line length is not reached.
* - The current position is valid (it is not the end of the source).
* - The current character is not a newline.
**/
for (uint32_t char_count = 0;
(char_count < SYNTAX_ERROR_MAX_LINE_LENGTH) && (pos < source_size) && (source_p[pos] != '\n');
char_count++, pos++)
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "%c", source_p[pos]);
}
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "\n");
jerry_port_release_source (source_p);
while (--err_col)
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "~");
}
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "^\n\n");
current_p++;
}
path_str_end_p = (char *) current_p++;
err_line = (unsigned int) strtol ((char *) current_p, (char **) &current_p, 10);
current_p++;
err_col = (unsigned int) strtol ((char *) current_p, NULL, 10);
break;
}
} /* for */
if (err_line != 0 && err_col > 0 && err_col < SYNTAX_ERROR_MAX_LINE_LENGTH)
{
/* Temporarily modify the error message, so we can use the path. */
*path_str_end_p = '\0';
size_t source_size;
uint8_t *source_p = jerry_port_read_source (path_str_p, &source_size);
/* Revert the error message. */
*path_str_end_p = ':';
if (source_p != NULL)
{
uint32_t curr_line = 1;
uint32_t pos = 0;
/* 2. seek and print */
while (pos < source_size && curr_line < err_line)
{
if (source_p[pos] == '\n')
{
curr_line++;
}
pos++;
}
/* Print character if:
* - The max line length is not reached.
* - The current position is valid (it is not the end of the source).
* - The current character is not a newline.
**/
for (uint32_t char_count = 0;
(char_count < SYNTAX_ERROR_MAX_LINE_LENGTH) && (pos < source_size) && (source_p[pos] != '\n');
char_count++, pos++)
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "%c", source_p[pos]);
}
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "\n");
jerry_port_release_source (source_p);
while (--err_col)
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "~");
}
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "^\n\n");
}
}
}
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "%s\n", err_str_buf);
jerry_release_value (err_str_val);
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Unhandled exception: %s\n", err_str_buf);
jerry_value_free (err_str_val);
if (jerry_value_is_object (error_value))
{
jerry_value_t stack_str = jerry_create_string ((const jerry_char_t *) "stack");
jerry_value_t backtrace_val = jerry_get_property (error_value, stack_str);
jerry_release_value (stack_str);
jerry_value_t stack_str = jerry_string_sz ("stack");
jerry_value_t backtrace_val = jerry_object_get (error_value, stack_str);
jerry_value_free (stack_str);
if (jerry_value_is_array (backtrace_val))
{
uint32_t length = jerry_get_array_length (backtrace_val);
uint32_t length = jerry_array_length (backtrace_val);
/* This length should be enough. */
if (length > 32)
@ -431,34 +423,24 @@ main_print_unhandled_exception (jerry_value_t error_value) /**< error value */
for (uint32_t i = 0; i < length; i++)
{
jerry_value_t item_val = jerry_get_property_by_index (backtrace_val, i);
jerry_value_t item_val = jerry_object_get_index (backtrace_val, i);
if (jerry_value_is_string (item_val))
{
jerry_size_t str_size = jerry_get_utf8_string_size (item_val);
string_end = jerry_string_to_buffer (item_val, JERRY_ENCODING_UTF8, err_str_buf, sizeof (err_str_buf) - 1);
err_str_buf[string_end] = '\0';
if (str_size >= 256)
{
printf ("%6u: [Backtrace string too long]\n", i);
}
else
{
jerry_size_t string_end = jerry_string_to_utf8_char_buffer (item_val, err_str_buf, str_size);
assert (string_end == str_size);
err_str_buf[string_end] = 0;
printf ("%6u: %s\n", i, err_str_buf);
}
printf ("%6u: %s\n", i, err_str_buf);
}
jerry_release_value (item_val);
jerry_value_free (item_val);
}
}
jerry_release_value (backtrace_val);
jerry_value_free (backtrace_val);
}
jerry_release_value (error_value);
jerry_value_free (error_value);
} /* main_print_unhandled_exception */
/**
@ -467,8 +449,8 @@ main_print_unhandled_exception (jerry_value_t error_value) /**< error value */
* @return result fo the source code execution
*/
jerry_value_t
main_wait_for_source_callback (const jerry_char_t *resource_name_p, /**< resource name */
size_t resource_name_size, /**< size of resource name */
main_wait_for_source_callback (const jerry_char_t *source_name_p, /**< resource name */
size_t source_name_size, /**< size of resource name */
const jerry_char_t *source_p, /**< source code */
size_t source_size, /**< source code size */
void *user_p) /**< user pointer */
@ -476,18 +458,18 @@ main_wait_for_source_callback (const jerry_char_t *resource_name_p, /**< resourc
(void) user_p; /* unused */
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name = jerry_create_string_sz (resource_name_p, (jerry_size_t) resource_name_size);
parse_options.options = JERRY_PARSE_HAS_SOURCE_NAME;
parse_options.source_name = jerry_string (source_name_p, (jerry_size_t) source_name_size, JERRY_ENCODING_UTF8);
jerry_value_t ret_val = jerry_parse (source_p, source_size, &parse_options);
jerry_release_value (parse_options.resource_name);
jerry_value_free (parse_options.source_name);
if (!jerry_value_is_error (ret_val))
if (!jerry_value_is_exception (ret_val))
{
jerry_value_t func_val = ret_val;
ret_val = jerry_run (func_val);
jerry_release_value (func_val);
jerry_value_free (func_val);
}
return ret_val;
@ -509,32 +491,32 @@ main_is_value_reset (jerry_value_t value) /**< jerry value */
return false;
}
jerry_value_t abort_value = jerry_get_value_from_error (value, false);
jerry_value_t abort_value = jerry_exception_value (value, false);
if (!jerry_value_is_string (abort_value))
{
jerry_release_value (abort_value);
jerry_value_free (abort_value);
return false;
}
static const char restart_str[] = "r353t";
jerry_size_t str_size = jerry_get_string_size (abort_value);
jerry_size_t str_size = jerry_string_size (abort_value, JERRY_ENCODING_CESU8);
bool is_reset = false;
if (str_size == sizeof (restart_str) - 1)
{
JERRY_VLA (jerry_char_t, str_buf, str_size);
jerry_string_to_char_buffer (abort_value, str_buf, str_size);
jerry_string_to_buffer (abort_value, JERRY_ENCODING_CESU8, str_buf, str_size);
is_reset = memcmp (restart_str, (char *) (str_buf), str_size) == 0;
if (is_reset)
{
jerry_release_value (value);
jerry_value_free (value);
}
}
jerry_release_value (abort_value);
jerry_value_free (abort_value);
return is_reset;
} /* main_is_value_reset */

4
jerry-main/main-utils.h
View File

@ -29,8 +29,8 @@
void main_init_engine (main_args_t *arguments_p);
void main_print_unhandled_exception (jerry_value_t error_value);
jerry_value_t main_wait_for_source_callback (const jerry_char_t *resource_name_p,
size_t resource_name_size,
jerry_value_t main_wait_for_source_callback (const jerry_char_t *source_name_p,
size_t source_name_size,
const jerry_char_t *source_p,
size_t source_size,
void *user_p);

46
jerry-port/default/default-module.c
View File

@ -250,8 +250,8 @@ jerry_port_module_free (jerry_port_module_manager_t *manager_p, /**< module mana
if (release_all || module_p->realm == realm)
{
free (module_p->path_p);
jerry_release_value (module_p->realm);
jerry_release_value (module_p->module);
jerry_value_free (module_p->realm);
jerry_value_free (module_p->module);
free (module_p);
@ -288,9 +288,9 @@ jerry_port_module_manager_init (void *user_data_p)
static void
jerry_port_module_manager_deinit (void *user_data_p) /**< context pointer to deinitialize */
{
jerry_value_t undef = jerry_create_undefined ();
jerry_value_t undef = jerry_undefined ();
jerry_port_module_free ((jerry_port_module_manager_t *) user_data_p, undef);
jerry_release_value (undef);
jerry_value_free (undef);
} /* jerry_port_module_manager_deinit */
/**
@ -313,32 +313,32 @@ jerry_port_module_resolve (const jerry_value_t specifier, /**< module specifier
{
(void) user_p;
jerry_port_module_t *module_p;
const jerry_char_t *base_path_p = NULL;
size_t base_path_length = 0;
jerry_port_module_t *module_p = jerry_object_get_native_ptr (referrer, &jerry_port_module_native_info);
if (jerry_get_object_native_pointer (referrer, (void **) &module_p, &jerry_port_module_native_info))
if (module_p != NULL)
{
base_path_p = module_p->path_p;
base_path_length = module_p->base_path_length;
}
jerry_size_t in_path_length = jerry_get_utf8_string_size (specifier);
jerry_size_t in_path_length = jerry_string_size (specifier, JERRY_ENCODING_UTF8);
jerry_char_t *in_path_p = (jerry_char_t *) malloc (in_path_length + 1);
jerry_string_to_utf8_char_buffer (specifier, in_path_p, in_path_length);
jerry_string_to_buffer (specifier, JERRY_ENCODING_UTF8, in_path_p, in_path_length);
in_path_p[in_path_length] = '\0';
jerry_char_t *path_p = jerry_port_normalize_path (in_path_p, in_path_length, base_path_p, base_path_length);
if (path_p == NULL)
{
return jerry_create_error (JERRY_ERROR_COMMON, (const jerry_char_t *) "Out of memory");
return jerry_throw_sz (JERRY_ERROR_COMMON, "Out of memory");
}
jerry_value_t realm = jerry_get_global_object ();
jerry_value_t realm = jerry_current_realm ();
jerry_port_module_manager_t *manager_p;
manager_p = (jerry_port_module_manager_t *) jerry_get_context_data (&jerry_port_module_manager);
manager_p = (jerry_port_module_manager_t *) jerry_context_data (&jerry_port_module_manager);
module_p = manager_p->module_head_p;
@ -348,8 +348,8 @@ jerry_port_module_resolve (const jerry_value_t specifier, /**< module specifier
{
free (path_p);
free (in_path_p);
jerry_release_value (realm);
return jerry_acquire_value (module_p->module);
jerry_value_free (realm);
return jerry_value_copy (module_p->module);
}
module_p = module_p->next_p;
@ -362,26 +362,26 @@ jerry_port_module_resolve (const jerry_value_t specifier, /**< module specifier
{
free (path_p);
free (in_path_p);
jerry_release_value (realm);
jerry_value_free (realm);
/* TODO: This is incorrect, but makes test262 module tests pass
* (they should throw SyntaxError, but not because the module cannot be found). */
return jerry_create_error (JERRY_ERROR_SYNTAX, (const jerry_char_t *) "Module file not found");
return jerry_throw_sz (JERRY_ERROR_SYNTAX, "Module file not found");
}
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_MODULE | JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name = jerry_create_string_sz ((const jerry_char_t *) in_path_p, in_path_length);
parse_options.options = JERRY_PARSE_MODULE | JERRY_PARSE_HAS_SOURCE_NAME;
parse_options.source_name = jerry_string (in_path_p, in_path_length, JERRY_ENCODING_UTF8);
jerry_value_t ret_value = jerry_parse (source_p, source_size, &parse_options);
jerry_release_value (parse_options.resource_name);
jerry_value_free (parse_options.source_name);
jerry_port_release_source (source_p);
free (in_path_p);
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
free (path_p);
jerry_release_value (realm);
jerry_value_free (realm);
return ret_value;
}
@ -391,9 +391,9 @@ jerry_port_module_resolve (const jerry_value_t specifier, /**< module specifier
module_p->path_p = path_p;
module_p->base_path_length = jerry_port_get_directory_end (module_p->path_p);
module_p->realm = realm;
module_p->module = jerry_acquire_value (ret_value);
module_p->module = jerry_value_copy (ret_value);
jerry_set_object_native_pointer (ret_value, module_p, &jerry_port_module_native_info);
jerry_object_set_native_ptr (ret_value, &jerry_port_module_native_info, module_p);
manager_p->module_head_p = module_p;
return ret_value;
@ -406,5 +406,5 @@ void
jerry_port_module_release (const jerry_value_t realm) /**< if this argument is object, release only those modules,
* which realm value is equal to this argument. */
{
jerry_port_module_free ((jerry_port_module_manager_t *) jerry_get_context_data (&jerry_port_module_manager), realm);
jerry_port_module_free ((jerry_port_module_manager_t *) jerry_context_data (&jerry_port_module_manager), realm);
} /* jerry_port_module_release */

88
targets/curie_bsp/jerry_app/quark/main.c
View File

@ -13,59 +13,58 @@
* limitations under the License.
*/
#include <stdio.h>
#include <stdint.h>
#include <stdio.h>
#include <string.h>
/* Infra */
#include "infra/bsp.h"
#include "infra/reboot.h"
#include "infra/log.h"
#include "infra/time.h"
#include "infra/system_events.h"
#include "infra/tcmd/handler.h"
#include "jerryscript-port.h"
#include "jerryscript.h"
#include "cfw/cfw.h"
/* Watchdog helper */
#include "infra/bsp.h"
#include "infra/log.h"
#include "infra/reboot.h"
#include "infra/system_events.h"
#include "infra/tcmd/handler.h"
#include "infra/time.h"
#include "infra/wdt_helper.h"
#include "jerryscript.h"
#include "jerryscript-port.h"
#include "string.h"
#include "zephyr.h"
#include "microkernel/task.h"
#include "os/os.h"
#include "misc/printk.h"
#include "os/os.h"
#include "string.h"
#include "zephyr.h"
static T_QUEUE queue;
jerry_value_t print_function;
void jerry_resolve_error (jerry_value_t ret_value)
void
jerry_resolve_error (jerry_value_t ret_value)
{
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
ret_value = jerry_get_value_from_error (ret_value, true);
ret_value = jerry_exception_value (ret_value, true);
jerry_value_t err_str_val = jerry_value_to_string (ret_value);
jerry_size_t err_str_size = jerry_get_utf8_string_size (err_str_val);
jerry_size_t err_str_size = jerry_string_size (err_str_val, JERRY_ENCODING_UTF8);
jerry_char_t *err_str_buf = (jerry_char_t *) balloc (err_str_size, NULL);
jerry_size_t sz = jerry_string_to_utf8_char_buffer (err_str_val, err_str_buf, err_str_size);
jerry_size_t sz = jerry_string_to_buffer (err_str_val, JERRY_ENCODING_UTF8, 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);
bfree (err_str_buf);
jerry_value_free (err_str_val);
}
}
void help ()
void
help ()
{
printk ("Usage:\n");
printk ("js e 'JavaScript Command'\n");
printk ("eg. js e print ('Hello World');\n");
}
void eval_jerry_script (int argc, char *argv[], struct tcmd_handler_ctx *ctx)
void
eval_jerry_script (int argc, char *argv[], struct tcmd_handler_ctx *ctx)
{
if (argc < 3)
{
@ -77,7 +76,7 @@ void eval_jerry_script (int argc, char *argv[], struct tcmd_handler_ctx *ctx)
{
OS_ERR_TYPE err;
size_t str_total_length = 0;
size_t *str_lens = (size_t *) balloc ((argc - 2) * sizeof(size_t), &err);
size_t *str_lens = (size_t *) balloc ((argc - 2) * sizeof (size_t), &err);
if (str_lens == NULL || err != E_OS_OK)
{
printk ("%s: allocate memory failed!", __func__);
@ -101,7 +100,7 @@ void eval_jerry_script (int argc, char *argv[], struct tcmd_handler_ctx *ctx)
char *p = buffer;
for (int i = 2; i < argc; ++i)
{
for (int j =0; j < str_lens[i - 2]; ++j)
for (int j = 0; j < str_lens[i - 2]; ++j)
{
*p = argv[i][j];
++p;
@ -113,41 +112,44 @@ void eval_jerry_script (int argc, char *argv[], struct tcmd_handler_ctx *ctx)
jerry_value_t eval_ret = jerry_eval (buffer, str_total_length - 1, JERRY_PARSE_NO_OPTS);
if (jerry_value_is_error (eval_ret))
if (jerry_value_is_exception (eval_ret))
{
jerry_resolve_error (eval_ret);
TCMD_RSP_ERROR (ctx, NULL);
}
else
{
jerry_value_t args[] = {eval_ret};
jerry_value_t ret_val_print = jerry_call_function (print_function,
jerry_create_undefined (),
args,
1);
jerry_release_value (ret_val_print);
jerry_value_t args[] = { eval_ret };
jerry_value_t ret_val_print = jerry_call (print_function, jerry_undefined (), args, 1);
jerry_value_free (ret_val_print);
TCMD_RSP_FINAL (ctx, NULL);
}
jerry_release_value (eval_ret);
jerry_value_free (eval_ret);
bfree (buffer);
bfree (str_lens);
}
}
void jerry_start ()
void
jerry_start ()
{
union { double d; unsigned u; } now = { .d = jerry_port_get_current_time () };
union
{
double d;
unsigned u;
} now = { .d = jerry_port_get_current_time () };
srand (now.u);
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);
jerry_value_t global_obj_val = jerry_current_realm ();
jerry_value_t print_func_name_val = jerry_string_sz ("print");
print_function = jerry_object_get (global_obj_val, print_func_name_val);
jerry_value_free (print_func_name_val);
jerry_value_free (global_obj_val);
}
/* Application main entry point */
void main_task (void *param)
void
main_task (void *param)
{
/* Init BSP (also init BSP on ARC core) */
queue = bsp_init ();

73
targets/esp-idf/jerry_module.c
View File

@ -14,12 +14,12 @@
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "jerryscript.h"
#include "jerryscript-port.h"
#include "jerryscript.h"
/**
* Computes the end of the directory part of a path.
@ -102,8 +102,7 @@ typedef struct jerry_port_module_t
/**
* Native info descriptor for modules.
*/
static const jerry_object_native_info_t jerry_port_module_native_info =
{
static const jerry_object_native_info_t jerry_port_module_native_info = {
.free_cb = NULL,
};
@ -136,8 +135,8 @@ jerry_port_module_free (jerry_port_module_manager_t *manager_p, /**< module mana
if (release_all || module_p->realm == realm)
{
free (module_p->path_p);
jerry_release_value (module_p->realm);
jerry_release_value (module_p->module);
jerry_value_free (module_p->realm);
jerry_value_free (module_p->module);
free (module_p);
@ -174,20 +173,18 @@ jerry_port_module_manager_init (void *user_data_p)
static void
jerry_port_module_manager_deinit (void *user_data_p) /**< context pointer to deinitialize */
{
jerry_value_t undef = jerry_create_undefined ();
jerry_value_t undef = jerry_undefined ();
jerry_port_module_free ((jerry_port_module_manager_t *) user_data_p, undef);
jerry_release_value (undef);
jerry_value_free (undef);
} /* jerry_port_module_manager_deinit */
/**
* Declare the context data manager for modules.
*/
static const jerry_context_data_manager_t jerry_port_module_manager =
{
.init_cb = jerry_port_module_manager_init,
.deinit_cb = jerry_port_module_manager_deinit,
.bytes_needed = sizeof (jerry_port_module_manager_t)
};
static const jerry_context_data_manager_t jerry_port_module_manager = { .init_cb = jerry_port_module_manager_init,
.deinit_cb = jerry_port_module_manager_deinit,
.bytes_needed =
sizeof (jerry_port_module_manager_t) };
/**
* Default module resolver.
@ -201,44 +198,43 @@ jerry_port_module_resolve (const jerry_value_t specifier, /**< module specifier
{
(void) user_p;
jerry_port_module_t *module_p;
const jerry_char_t *base_path_p = NULL;
size_t base_path_length = 0;
jerry_port_module_t *module_p = jerry_object_get_native_ptr (referrer, &jerry_port_module_native_info);
if (jerry_get_object_native_pointer (referrer, (void **) &module_p, &jerry_port_module_native_info))
if (module_p != NULL)
{
base_path_p = module_p->path_p;
base_path_length = module_p->base_path_length;
}
jerry_size_t in_path_length = jerry_get_utf8_string_size (specifier);
jerry_size_t in_path_length = jerry_string_size (specifier, JERRY_ENCODING_UTF8);
jerry_char_t *in_path_p = (jerry_char_t *) malloc (in_path_length + 1);
jerry_string_to_utf8_char_buffer (specifier, in_path_p, in_path_length);
jerry_string_to_buffer (specifier, JERRY_ENCODING_UTF8, in_path_p, in_path_length);
in_path_p[in_path_length] = '\0';
jerry_char_t *path_p = jerry_port_normalize_path (in_path_p, in_path_length, base_path_p, base_path_length);
if (path_p == NULL)
{
return jerry_create_error (JERRY_ERROR_COMMON, (const jerry_char_t *) "Out of memory");
return jerry_throw_sz (JERRY_ERROR_COMMON, "Out of memory");
}
jerry_value_t realm = jerry_get_global_object ();
jerry_value_t realm = jerry_current_realm ();
jerry_port_module_manager_t *manager_p;
manager_p = (jerry_port_module_manager_t *) jerry_get_context_data (&jerry_port_module_manager);
manager_p = (jerry_port_module_manager_t *) jerry_context_data (&jerry_port_module_manager);
module_p = manager_p->module_head_p;
while (module_p != NULL)
{
if (module_p->realm == realm
&& strcmp ((const char *) module_p->path_p, (const char *) path_p) == 0)
if (module_p->realm == realm && strcmp ((const char *) module_p->path_p, (const char *) path_p) == 0)
{
free (path_p);
free (in_path_p);
jerry_release_value (realm);
return jerry_acquire_value (module_p->module);
jerry_value_free (realm);
return jerry_value_copy (module_p->module);
}
module_p = module_p->next_p;
@ -251,28 +247,24 @@ jerry_port_module_resolve (const jerry_value_t specifier, /**< module specifier
{
free (path_p);
free (in_path_p);
jerry_release_value (realm);
/* TODO: This is incorrect, but makes test262 module tests pass
* (they should throw SyntaxError, but not because the module cannot be found). */
return jerry_create_error (JERRY_ERROR_SYNTAX, (const jerry_char_t *) "Module file not found");
jerry_value_free (realm);
return jerry_throw_sz (JERRY_ERROR_SYNTAX, "Module file not found");
}
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_MODULE | JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name = jerry_create_string_sz ((const jerry_char_t *) in_path_p, in_path_length);
parse_options.options = JERRY_PARSE_MODULE | JERRY_PARSE_HAS_SOURCE_NAME;
parse_options.source_name = jerry_string ((const jerry_char_t *) in_path_p, in_path_length, JERRY_ENCODING_UTF8);
jerry_value_t ret_value = jerry_parse (source_p,
source_size,
&parse_options);
jerry_value_t ret_value = jerry_parse (source_p, source_size, &parse_options);
jerry_release_value (parse_options.resource_name);
jerry_value_free (parse_options.source_name);
jerry_port_release_source (source_p);
free (in_path_p);
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
free (path_p);
jerry_release_value (realm);
jerry_value_free (realm);
return ret_value;
}
@ -282,9 +274,9 @@ jerry_port_module_resolve (const jerry_value_t specifier, /**< module specifier
module_p->path_p = path_p;
module_p->base_path_length = jerry_port_get_directory_end (module_p->path_p);
module_p->realm = realm;
module_p->module = jerry_acquire_value (ret_value);
module_p->module = jerry_value_copy (ret_value);
jerry_set_object_native_pointer (ret_value, module_p, &jerry_port_module_native_info);
jerry_object_set_native_ptr (ret_value, &jerry_port_module_native_info, module_p);
manager_p->module_head_p = module_p;
return ret_value;
@ -297,6 +289,5 @@ void
jerry_port_module_release (const jerry_value_t realm) /**< if this argument is object, release only those modules,
* which realm value is equal to this argument. */
{
jerry_port_module_free ((jerry_port_module_manager_t *) jerry_get_context_data (&jerry_port_module_manager),
realm);
jerry_port_module_free ((jerry_port_module_manager_t *) jerry_context_data (&jerry_port_module_manager), realm);
} /* jerry_port_module_release */

150
targets/esp8266/user/jerry_extapi.c
View File

@ -13,67 +13,64 @@
* limitations under the License.
*/
#include <stdlib.h>
#include "jerry_extapi.h"
#include <stdio.h>
#include <stdlib.h>
#include "jerryscript.h"
#include "c_types.h"
#include "gpio.h"
#include "jerryscript.h"
#include "jerry_extapi.h"
#define __UNUSED__ __attribute__ ((unused))
#define __UNUSED__ __attribute__((unused))
#define DELCARE_HANDLER(NAME) \
static jerry_value_t NAME##_handler (const jerry_call_info_t *call_info_p __UNUSED__, \
const jerry_value_t args_p[], \
const jerry_length_t args_cnt)
#define DELCARE_HANDLER(NAME) \
static jerry_value_t \
NAME ## _handler (const jerry_call_info_t *call_info_p __UNUSED__, \
const jerry_value_t args_p[], \
const jerry_length_t args_cnt)
#define REGISTER_HANDLER(NAME) register_native_function (#NAME, NAME##_handler)
#define REGISTER_HANDLER(NAME) \
register_native_function ( # NAME, NAME ## _handler)
DELCARE_HANDLER(assert) {
if (args_cnt == 1
&& jerry_value_is_true (args_p[0]))
DELCARE_HANDLER (assert)
{
if (args_cnt == 1 && jerry_value_is_true (args_p[0]))
{
printf (">> Jerry assert true\r\n");
return jerry_create_boolean (true);
return jerry_boolean (true);
}
printf ("Script assertion failed\n");
exit (JERRY_STANDALONE_EXIT_CODE_FAIL);
return jerry_create_boolean (false);
return jerry_boolean (false);
} /* assert */
DELCARE_HANDLER(print) {
DELCARE_HANDLER (print)
{
if (args_cnt)
{
for (jerry_length_t cc = 0; cc < args_cnt; cc++)
{
if (jerry_value_is_string (args_p[cc]))
{
jerry_size_t size = jerry_get_utf8_string_size (args_p[0]);
jerry_size_t size = jerry_string_size (args_p[0], JERRY_ENCODING_UTF8);
char *buffer;
buffer = (char *) malloc(size + 1);
buffer = (char *) malloc (size + 1);
if(!buffer)
if (!buffer)
{
// not enough memory for this string.
printf("[<too-long-string>]");
continue;
// not enough memory for this string.
printf ("[<too-long-string>]");
continue;
}
jerry_string_to_utf8_char_buffer (args_p[cc],
(jerry_char_t *) buffer,
size);
*(buffer + size) = 0;
printf("%s ", buffer);
jerry_string_to_buffer (args_p[cc], JERRY_ENCODING_UTF8, (jerry_char_t *) buffer, size);
buffer[size] = '\0';
printf ("%s ", buffer);
free (buffer);
}
else if (jerry_value_is_number (args_p[cc]))
{
double number = jerry_get_number_value (args_p[cc]);
double number = jerry_value_as_number (args_p[cc]);
if ((int) number == number)
{
printf ("%d", (int) number);
@ -81,106 +78,105 @@ DELCARE_HANDLER(print) {
else
{
char buff[50];
sprintf(buff, "%.10f", number);
printf("%s", buff);
sprintf (buff, "%.10f", number);
printf ("%s", buff);
}
}
}
printf ("\r\n");
}
return jerry_create_boolean (true);
return jerry_boolean (true);
} /* print */
DELCARE_HANDLER(gpio_dir) {
DELCARE_HANDLER (gpio_dir)
{
if (args_cnt < 2)
{
return jerry_create_boolean (false);
return jerry_boolean (false);
}
int port = (int) jerry_get_number_value (args_p[0]);
int value = (int) jerry_get_number_value (args_p[1]);
int port = (int) jerry_value_as_number (args_p[0]);
int value = (int) jerry_value_as_number (args_p[1]);
if (value)
{
GPIO_AS_OUTPUT(1 << port);
GPIO_AS_OUTPUT (1 << port);
}
else
{
GPIO_AS_INPUT(1 << port);
GPIO_AS_INPUT (1 << port);
}
return jerry_create_boolean (true);
return jerry_boolean (true);
} /* gpio_dir */
DELCARE_HANDLER(gpio_set) {
DELCARE_HANDLER (gpio_set)
{
if (args_cnt < 2)
{
return jerry_create_boolean (false);
return jerry_boolean (false);
}
int port = (int) jerry_get_number_value (args_p[0]);
int value = (int) jerry_get_number_value (args_p[1]);
int port = (int) jerry_value_as_number (args_p[0]);
int value = (int) jerry_value_as_number (args_p[1]);
GPIO_OUTPUT_SET(port, value);
GPIO_OUTPUT_SET (port, value);
return jerry_create_boolean (true);
return jerry_boolean (true);
} /* gpio_set */
DELCARE_HANDLER(gpio_get) {
DELCARE_HANDLER (gpio_get)
{
if (args_cnt < 1)
{
return jerry_create_boolean (false);
return jerry_boolean (false);
}
int port = (int) jerry_get_number_value (args_p[0]);
int value = GPIO_INPUT_GET(port) ? 1 : 0;
int port = (int) jerry_value_as_number (args_p[0]);
int value = GPIO_INPUT_GET (port) ? 1 : 0;
return jerry_create_number ((double) value);
return jerry_number ((double) value);
} /* gpio_get */
static bool
register_native_function (const char* name,
jerry_external_handler_t handler)
register_native_function (const char *name, jerry_external_handler_t handler)
{
jerry_value_t global_obj_val = jerry_get_global_object ();
jerry_value_t reg_func_val = jerry_create_external_function (handler);
bool bok = true;
jerry_value_t global_obj_val = jerry_current_realm ();
jerry_value_t reg_func_val = jerry_function_external (handler);
if (!(jerry_value_is_function (reg_func_val)
&& jerry_value_is_constructor (reg_func_val)))
if (!(jerry_value_is_function (reg_func_val) && jerry_value_is_constructor (reg_func_val)))
{
printf ("!!! create_external_function failed !!!\r\n");
jerry_release_value (reg_func_val);
jerry_release_value (global_obj_val);
jerry_value_free (reg_func_val);
jerry_value_free (global_obj_val);
return false;
}
jerry_value_t prop_name_val = jerry_create_string ((const jerry_char_t *) name);
jerry_value_t res = jerry_set_property (global_obj_val, prop_name_val, reg_func_val);
jerry_value_t prop_name_val = jerry_string_sz (name);
jerry_value_t res = jerry_object_set (global_obj_val, prop_name_val, reg_func_val);
jerry_release_value (reg_func_val);
jerry_release_value (global_obj_val);
jerry_release_value (prop_name_val);
jerry_value_free (reg_func_val);
jerry_value_free (global_obj_val);
jerry_value_free (prop_name_val);
if (jerry_value_is_error (res))
if (jerry_value_is_exception (res))
{
printf ("!!! register_native_function failed: [%s]\r\n", name);
jerry_release_value (res);
jerry_value_free (res);
return false;
}
jerry_release_value (res);
jerry_value_free (res);
return true;
} /* register_native_function */
void js_register_functions (void)
void
js_register_functions (void)
{
REGISTER_HANDLER(assert);
REGISTER_HANDLER(print);
REGISTER_HANDLER(gpio_dir);
REGISTER_HANDLER(gpio_set);
REGISTER_HANDLER(gpio_get);
REGISTER_HANDLER (assert);
REGISTER_HANDLER (print);
REGISTER_HANDLER (gpio_dir);
REGISTER_HANDLER (gpio_set);
REGISTER_HANDLER (gpio_get);
} /* js_register_functions */

87
targets/esp8266/user/jerry_run.c
View File

@ -13,88 +13,97 @@
* limitations under the License.
*/
#include <stdlib.h>
#include <stdio.h>
#include "jerry_extapi.h"
#include "jerry_run.h"
#include "jerryscript.h"
#include <stdio.h>
#include <stdlib.h>
#include "jerryscript-port.h"
#include "jerryscript.h"
static const char* fn_sys_loop_name = "sysloop";
#include "jerry_extapi.h"
void js_entry ()
static const char *fn_sys_loop_name = "sysloop";
void
js_entry ()
{
union { double d; unsigned u; } now = { .d = jerry_port_get_current_time () };
union
{
double d;
unsigned u;
} now = { .d = jerry_port_get_current_time () };
srand (now.u);
jerry_init (JERRY_INIT_EMPTY);
js_register_functions ();
}
int js_eval (const char *source_p, const size_t source_size)
int
js_eval (const char *source_p, const size_t source_size)
{
jerry_value_t res = jerry_eval ((jerry_char_t *) source_p,
source_size,
JERRY_PARSE_NO_OPTS);
if (jerry_value_is_error (res)) {
jerry_release_value (res);
jerry_value_t res = jerry_eval ((jerry_char_t *) source_p, source_size, JERRY_PARSE_NO_OPTS);
if (jerry_value_is_exception (res))
{
jerry_value_free (res);
return -1;
}
jerry_release_value (res);
jerry_value_free (res);
return 0;
}
int js_loop (uint32_t ticknow)
int
js_loop (uint32_t ticknow)
{
jerry_value_t global_obj_val = jerry_get_global_object ();
jerry_value_t prop_name_val = jerry_create_string ((const jerry_char_t *) fn_sys_loop_name);
jerry_value_t sysloop_func = jerry_get_property (global_obj_val, prop_name_val);
jerry_release_value (prop_name_val);
jerry_value_t global_obj_val = jerry_current_realm ();
jerry_value_t prop_name_val = jerry_string_sz (fn_sys_loop_name);
jerry_value_t sysloop_func = jerry_object_get (global_obj_val, prop_name_val);
jerry_value_free (prop_name_val);
if (jerry_value_is_error (sysloop_func)) {
if (jerry_value_is_exception (sysloop_func))
{
printf ("Error: '%s' not defined!!!\r\n", fn_sys_loop_name);
jerry_release_value (sysloop_func);
jerry_release_value (global_obj_val);
jerry_value_free (sysloop_func);
jerry_value_free (global_obj_val);
return -1;
}
if (!jerry_value_is_function (sysloop_func)) {
if (!jerry_value_is_function (sysloop_func))
{
printf ("Error: '%s' is not a function!!!\r\n", fn_sys_loop_name);
jerry_release_value (sysloop_func);
jerry_release_value (global_obj_val);
jerry_value_free (sysloop_func);
jerry_value_free (global_obj_val);
return -2;
}
jerry_value_t val_args[] = { jerry_create_number (ticknow) };
jerry_value_t val_args[] = { jerry_number (ticknow) };
uint16_t val_argv = sizeof (val_args) / sizeof (jerry_value_t);
jerry_value_t res = jerry_call_function (sysloop_func,
global_obj_val,
val_args,
val_argv);
jerry_value_t res = jerry_call (sysloop_func, global_obj_val, val_args, val_argv);
for (uint16_t i = 0; i < val_argv; i++) {
jerry_release_value (val_args[i]);
for (uint16_t i = 0; i < val_argv; i++)
{
jerry_value_free (val_args[i]);
}
jerry_release_value (sysloop_func);
jerry_release_value (global_obj_val);
jerry_value_free (sysloop_func);
jerry_value_free (global_obj_val);
if (jerry_value_is_error (res)) {
jerry_release_value (res);
if (jerry_value_is_exception (res))
{
jerry_value_free (res);
return -3;
}
jerry_release_value (res);
jerry_value_free (res);
return 0;
}
void js_exit (void)
void
js_exit (void)
{
jerry_cleanup ();
}

91
targets/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/AnalogIn-js.cpp
View File

@ -12,9 +12,8 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "jerryscript-mbed-util/logging.h"
#include "jerryscript-mbed-library-registry/wrap_tools.h"
#include "jerryscript-mbed-util/logging.h"
#include "mbed.h"
/**
@ -22,9 +21,11 @@
*
* Called if/when the AnalogIn is GC'ed.
*/
void NAME_FOR_CLASS_NATIVE_DESTRUCTOR(AnalogIn)(void* void_ptr, jerry_object_native_info_t *info_p) {
(void) info_p;
delete static_cast<AnalogIn*>(void_ptr);
void
NAME_FOR_CLASS_NATIVE_DESTRUCTOR (AnalogIn) (void* void_ptr, jerry_object_native_info_t* info_p)
{
(void) info_p;
delete static_cast<AnalogIn*> (void_ptr);
}
/**
@ -32,9 +33,8 @@ void NAME_FOR_CLASS_NATIVE_DESTRUCTOR(AnalogIn)(void* void_ptr, jerry_object_nat
*
* Set AnalogIn#destructor as the free callback.
*/
static const jerry_object_native_info_t native_obj_type_info = {
.free_cb = NAME_FOR_CLASS_NATIVE_DESTRUCTOR(AnalogIn)
};
static const jerry_object_native_info_t native_obj_type_info = { .free_cb =
NAME_FOR_CLASS_NATIVE_DESTRUCTOR (AnalogIn) };
/**
* AnalogIn#read (native JavaScript method)
@ -43,22 +43,22 @@ static const jerry_object_native_info_t native_obj_type_info = {
*
* @returns A floating-point value representing the current input voltage, measured as a percentage
*/
DECLARE_CLASS_FUNCTION(AnalogIn, read) {
CHECK_ARGUMENT_COUNT(AnalogIn, read, (args_count == 0));
DECLARE_CLASS_FUNCTION (AnalogIn, read)
{
CHECK_ARGUMENT_COUNT (AnalogIn, read, (args_count == 0));
// Extract native AnalogIn pointer
void* void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Extract native AnalogIn pointer
void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native AnalogIn pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native AnalogIn pointer");
}
AnalogIn* native_ptr = static_cast<AnalogIn*>(void_ptr);
AnalogIn* native_ptr = static_cast<AnalogIn*> (void_ptr);
float result = native_ptr->read();
return jerry_create_number(result);
float result = native_ptr->read ();
return jerry_number (result);
}
/**
@ -68,22 +68,22 @@ DECLARE_CLASS_FUNCTION(AnalogIn, read) {
*
* @returns 16-bit unsigned short representing the current input voltage, normalised to a 16-bit value
*/
DECLARE_CLASS_FUNCTION(AnalogIn, read_u16) {
CHECK_ARGUMENT_COUNT(AnalogIn, read_u16, (args_count == 0));
DECLARE_CLASS_FUNCTION (AnalogIn, read_u16)
{
CHECK_ARGUMENT_COUNT (AnalogIn, read_u16, (args_count == 0));
// Extract native AnalogIn pointer
void* void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Extract native AnalogIn pointer
void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native AnalogIn pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native AnalogIn pointer");
}
AnalogIn* native_ptr = static_cast<AnalogIn*>(void_ptr);
AnalogIn* native_ptr = static_cast<AnalogIn*> (void_ptr);
uint16_t result = native_ptr->read_u16();
return jerry_create_number(result);
uint16_t result = native_ptr->read_u16 ();
return jerry_number (result);
}
/**
@ -92,22 +92,23 @@ DECLARE_CLASS_FUNCTION(AnalogIn, read_u16) {
* @param pin_name mbed pin to connect the AnalogIn to.
* @returns a JavaScript object representing a AnalogIn.
*/
DECLARE_CLASS_CONSTRUCTOR(AnalogIn) {
CHECK_ARGUMENT_COUNT(AnalogIn, __constructor, args_count == 1);
CHECK_ARGUMENT_TYPE_ALWAYS(AnalogIn, __constructor, 0, number);
DECLARE_CLASS_CONSTRUCTOR (AnalogIn)
{
CHECK_ARGUMENT_COUNT (AnalogIn, __constructor, args_count == 1);
CHECK_ARGUMENT_TYPE_ALWAYS (AnalogIn, __constructor, 0, number);
PinName pin_name = PinName(jerry_get_number_value(args[0]));
PinName pin_name = PinName (jerry_value_as_number (args[0]));
// create native object
AnalogIn* native_ptr = new AnalogIn(pin_name);
// create native object
AnalogIn* native_ptr = new AnalogIn (pin_name);
// create the jerryscript object
jerry_value_t js_object = jerry_create_object();
jerry_set_object_native_pointer(js_object, native_ptr, &native_obj_type_info);
// create the jerryscript object
jerry_value_t js_object = jerry_object ();
jerry_object_set_native_ptr (js_object, &native_obj_type_info, native_ptr);
// attach methods
ATTACH_CLASS_FUNCTION(js_object, AnalogIn, read);
ATTACH_CLASS_FUNCTION(js_object, AnalogIn, read_u16);
// attach methods
ATTACH_CLASS_FUNCTION (js_object, AnalogIn, read);
ATTACH_CLASS_FUNCTION (js_object, AnalogIn, read_u16);
return js_object;
return js_object;
}

144
targets/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/DigitalOut-js.cpp
View File

@ -12,9 +12,8 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "jerryscript-mbed-util/logging.h"
#include "jerryscript-mbed-library-registry/wrap_tools.h"
#include "jerryscript-mbed-util/logging.h"
#include "mbed.h"
/**
@ -22,9 +21,11 @@
*
* Called if/when the DigitalOut is GC'ed.
*/
void NAME_FOR_CLASS_NATIVE_DESTRUCTOR(DigitalOut)(void* void_ptr, jerry_object_native_info_t *info_p) {
(void) info_p;
delete static_cast<DigitalOut*>(void_ptr);
void
NAME_FOR_CLASS_NATIVE_DESTRUCTOR (DigitalOut) (void* void_ptr, jerry_object_native_info_t* info_p)
{
(void) info_p;
delete static_cast<DigitalOut*> (void_ptr);
}
/**
@ -32,9 +33,8 @@ void NAME_FOR_CLASS_NATIVE_DESTRUCTOR(DigitalOut)(void* void_ptr, jerry_object_n
*
* Set DigitalOut#destructor as the free callback.
*/
static const jerry_object_native_info_t native_obj_type_info = {
.free_cb = NAME_FOR_CLASS_NATIVE_DESTRUCTOR(DigitalOut)
};
static const jerry_object_native_info_t native_obj_type_info = { .free_cb =
NAME_FOR_CLASS_NATIVE_DESTRUCTOR (DigitalOut) };
/**
* DigitalOut#write (native JavaScript method)
@ -45,25 +45,25 @@ static const jerry_object_native_info_t native_obj_type_info = {
* respectively
* @returns undefined, or an error if invalid arguments are provided.
*/
DECLARE_CLASS_FUNCTION(DigitalOut, write) {
CHECK_ARGUMENT_COUNT(DigitalOut, write, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS(DigitalOut, write, 0, number);
DECLARE_CLASS_FUNCTION (DigitalOut, write)
{
CHECK_ARGUMENT_COUNT (DigitalOut, write, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS (DigitalOut, write, 0, number);
// Extract native DigitalOut pointer
void* void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Extract native DigitalOut pointer
void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native DigitalOut pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native DigitalOut pointer");
}
DigitalOut* native_ptr = static_cast<DigitalOut*>(void_ptr);
DigitalOut* native_ptr = static_cast<DigitalOut*> (void_ptr);
int arg0 = jerry_get_number_value(args[0]);
native_ptr->write(arg0);
int arg0 = jerry_value_as_number (args[0]);
native_ptr->write (arg0);
return jerry_create_undefined();
return jerry_undefined ();
}
/**
@ -73,22 +73,22 @@ DECLARE_CLASS_FUNCTION(DigitalOut, write) {
*
* @returns 1 if the pin is currently high, or 0 if the pin is currently low.
*/
DECLARE_CLASS_FUNCTION(DigitalOut, read) {
CHECK_ARGUMENT_COUNT(DigitalOut, read, (args_count == 0));
DECLARE_CLASS_FUNCTION (DigitalOut, read)
{
CHECK_ARGUMENT_COUNT (DigitalOut, read, (args_count == 0));
// Extract native DigitalOut pointer
void* void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Extract native DigitalOut pointer
void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native DigitalOut pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native DigitalOut pointer");
}
DigitalOut* native_ptr = static_cast<DigitalOut*>(void_ptr);
DigitalOut* native_ptr = static_cast<DigitalOut*> (void_ptr);
int result = native_ptr->read();
return jerry_create_number(result);
int result = native_ptr->read ();
return jerry_number (result);
}
/**
@ -97,22 +97,22 @@ DECLARE_CLASS_FUNCTION(DigitalOut, read) {
* @returns 0 if the DigitalOut is set to NC, or 1 if it is connected to an
* actual pin
*/
DECLARE_CLASS_FUNCTION(DigitalOut, is_connected) {
CHECK_ARGUMENT_COUNT(DigitalOut, is_connected, (args_count == 0));
DECLARE_CLASS_FUNCTION (DigitalOut, is_connected)
{
CHECK_ARGUMENT_COUNT (DigitalOut, is_connected, (args_count == 0));
// Extract native DigitalOut pointer
void* void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Extract native DigitalOut pointer
void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native DigitalOut pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native DigitalOut pointer");
}
DigitalOut* native_ptr = static_cast<DigitalOut*>(void_ptr);
DigitalOut* native_ptr = static_cast<DigitalOut*> (void_ptr);
int result = native_ptr->is_connected();
return jerry_create_number(result);
int result = native_ptr->is_connected ();
return jerry_number (result);
}
/**
@ -122,35 +122,37 @@ DECLARE_CLASS_FUNCTION(DigitalOut, is_connected) {
* @param value (optional) Initial value of the DigitalOut.
* @returns a JavaScript object representing a DigitalOut.
*/
DECLARE_CLASS_CONSTRUCTOR(DigitalOut) {
CHECK_ARGUMENT_COUNT(DigitalOut, __constructor, (args_count == 1 || args_count == 2));
CHECK_ARGUMENT_TYPE_ALWAYS(DigitalOut, __constructor, 0, number);
CHECK_ARGUMENT_TYPE_ON_CONDITION(DigitalOut, __constructor, 1, number, (args_count == 2));
DECLARE_CLASS_CONSTRUCTOR (DigitalOut)
{
CHECK_ARGUMENT_COUNT (DigitalOut, __constructor, (args_count == 1 || args_count == 2));
CHECK_ARGUMENT_TYPE_ALWAYS (DigitalOut, __constructor, 0, number);
CHECK_ARGUMENT_TYPE_ON_CONDITION (DigitalOut, __constructor, 1, number, (args_count == 2));
DigitalOut* native_ptr;
DigitalOut* native_ptr;
// Call correct overload of DigitalOut::DigitalOut depending on the
// arguments passed.
PinName pin_name = PinName(jerry_get_number_value(args[0]));
// Call correct overload of DigitalOut::DigitalOut depending on the
// arguments passed.
PinName pin_name = PinName (jerry_value_as_number (args[0]));
switch (args_count) {
case 1:
native_ptr = new DigitalOut(pin_name);
break;
case 2:
int value = static_cast<int>(jerry_get_number_value(args[1]));
native_ptr = new DigitalOut(pin_name, value);
break;
}
switch (args_count)
{
case 1:
native_ptr = new DigitalOut (pin_name);
break;
case 2:
int value = static_cast<int> (jerry_value_as_number (args[1]));
native_ptr = new DigitalOut (pin_name, value);
break;
}
// create the jerryscript object
jerry_value_t js_object = jerry_create_object();
jerry_set_object_native_pointer(js_object, native_ptr, &native_obj_type_info);
// create the jerryscript object
jerry_value_t js_object = jerry_object ();
jerry_object_set_native_ptr (js_object, &native_obj_type_info, native_ptr);
// attach methods
ATTACH_CLASS_FUNCTION(js_object, DigitalOut, write);
ATTACH_CLASS_FUNCTION(js_object, DigitalOut, read);
ATTACH_CLASS_FUNCTION(js_object, DigitalOut, is_connected);
// attach methods
ATTACH_CLASS_FUNCTION (js_object, DigitalOut, write);
ATTACH_CLASS_FUNCTION (js_object, DigitalOut, read);
ATTACH_CLASS_FUNCTION (js_object, DigitalOut, is_connected);
return js_object;
return js_object;
}

379
targets/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/I2C-js.cpp
View File

@ -12,10 +12,10 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "jerryscript-mbed-util/logging.h"
#include "jerryscript-mbed-drivers/I2C-js.h"
#include "jerryscript-mbed-library-registry/wrap_tools.h"
#include "jerryscript-mbed-library-registry/wrap_tools.h"
#include "jerryscript-mbed-util/logging.h"
#include "mbed.h"
/**
@ -23,9 +23,11 @@
*
* Called if/when the I2C object is GC'ed.
*/
void NAME_FOR_CLASS_NATIVE_DESTRUCTOR(I2C) (void *void_ptr, jerry_object_native_info_t *info_p) {
(void) info_p;
delete static_cast<I2C*>(void_ptr);
void
NAME_FOR_CLASS_NATIVE_DESTRUCTOR (I2C) (void *void_ptr, jerry_object_native_info_t *info_p)
{
(void) info_p;
delete static_cast<I2C *> (void_ptr);
}
/**
@ -33,9 +35,7 @@ void NAME_FOR_CLASS_NATIVE_DESTRUCTOR(I2C) (void *void_ptr, jerry_object_native_
*
* Set I2C#destructor as the free callback.
*/
static const jerry_object_native_info_t native_obj_type_info = {
.free_cb = NAME_FOR_CLASS_NATIVE_DESTRUCTOR(I2C)
};
static const jerry_object_native_info_t native_obj_type_info = { .free_cb = NAME_FOR_CLASS_NATIVE_DESTRUCTOR (I2C) };
/**
* I2C#frequency (native JavaScript method)
@ -44,25 +44,25 @@ static const jerry_object_native_info_t native_obj_type_info = {
*
* @param frequency New I2C Frequency
*/
DECLARE_CLASS_FUNCTION(I2C, frequency) {
CHECK_ARGUMENT_COUNT(I2C, frequency, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS(I2C, frequency, 0, number);
DECLARE_CLASS_FUNCTION (I2C, frequency)
{
CHECK_ARGUMENT_COUNT (I2C, frequency, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS (I2C, frequency, 0, number);
// Unwrap native I2C object
void *void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Unwrap native I2C object
void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native I2C pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native I2C pointer");
}
I2C *native_ptr = static_cast<I2C*>(void_ptr);
I2C *native_ptr = static_cast<I2C *> (void_ptr);
int hz = jerry_get_number_value(args[0]);
native_ptr->frequency(hz);
int hz = jerry_value_as_number (args[0]);
native_ptr->frequency (hz);
return jerry_create_undefined();
return jerry_undefined ();
}
/**
@ -86,77 +86,84 @@ DECLARE_CLASS_FUNCTION(I2C, frequency) {
*
* @returns array: Data read from the I2C bus
*/
DECLARE_CLASS_FUNCTION(I2C, read) {
CHECK_ARGUMENT_COUNT(I2C, read, (args_count == 1 || args_count == 3 || args_count == 4));
DECLARE_CLASS_FUNCTION (I2C, read)
{
CHECK_ARGUMENT_COUNT (I2C, read, (args_count == 1 || args_count == 3 || args_count == 4));
if (args_count == 1) {
CHECK_ARGUMENT_TYPE_ALWAYS(I2C, read, 0, number);
void *void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
if (args_count == 1)
{
CHECK_ARGUMENT_TYPE_ALWAYS (I2C, read, 0, number);
void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native I2C pointer");
}
I2C *native_ptr = static_cast<I2C*>(void_ptr);
int data = jerry_get_number_value(args[0]);
int result = native_ptr->read(data);
return jerry_create_number(result);
} else {
CHECK_ARGUMENT_TYPE_ALWAYS(I2C, read, 0, number);
CHECK_ARGUMENT_TYPE_ALWAYS(I2C, read, 1, array);
CHECK_ARGUMENT_TYPE_ALWAYS(I2C, read, 2, number);
CHECK_ARGUMENT_TYPE_ON_CONDITION(I2C, read, 3, boolean, (args_count == 4));
void *void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native I2C pointer");
}
I2C *native_ptr = static_cast<I2C*>(void_ptr);
const uint32_t data_len = jerry_get_array_length(args[1]);
int address = jerry_get_number_value(args[0]);
int length = jerry_get_number_value(args[2]);
char *data = new char[data_len];
bool repeated = false;
if (args_count == 4) {
repeated = jerry_value_is_true(args[3]);
}
int result = native_ptr->read(address, data, length, repeated);
jerry_value_t out_array = jerry_create_array(data_len);
for (uint32_t i = 0; i < data_len; i++) {
jerry_value_t val = jerry_create_number(double(data[i]));
jerry_release_value(jerry_set_property_by_index(out_array, i, val));
jerry_release_value(val);
}
delete[] data;
if (result == 0) {
// ACK
return out_array;
} else {
// NACK
const char *error_msg = "NACK received from I2C bus";
jerry_release_value(out_array);
return jerry_create_error(JERRY_ERROR_COMMON, reinterpret_cast<const jerry_char_t *>(error_msg));
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native I2C pointer");
}
I2C *native_ptr = static_cast<I2C *> (void_ptr);
int data = jerry_value_as_number (args[0]);
int result = native_ptr->read (data);
return jerry_number (result);
}
else
{
CHECK_ARGUMENT_TYPE_ALWAYS (I2C, read, 0, number);
CHECK_ARGUMENT_TYPE_ALWAYS (I2C, read, 1, array);
CHECK_ARGUMENT_TYPE_ALWAYS (I2C, read, 2, number);
CHECK_ARGUMENT_TYPE_ON_CONDITION (I2C, read, 3, boolean, (args_count == 4));
void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native I2C pointer");
}
I2C *native_ptr = static_cast<I2C *> (void_ptr);
const uint32_t data_len = jerry_array_length (args[1]);
int address = jerry_value_as_number (args[0]);
int length = jerry_value_as_number (args[2]);
char *data = new char[data_len];
bool repeated = false;
if (args_count == 4)
{
repeated = jerry_value_is_true (args[3]);
}
int result = native_ptr->read (address, data, length, repeated);
jerry_value_t out_array = jerry_array (data_len);
for (uint32_t i = 0; i < data_len; i++)
{
jerry_value_t val = jerry_number (double (data[i]));
jerry_value_free (jerry_object_set_index (out_array, i, val));
jerry_value_free (val);
}
delete[] data;
if (result == 0)
{
// ACK
return out_array;
}
else
{
// NACK
const char *error_msg = "NACK received from I2C bus";
jerry_value_free (out_array);
return jerry_throw_sz (JERRY_ERROR_COMMON, error_msg);
}
}
}
/**
@ -179,65 +186,68 @@ DECLARE_CLASS_FUNCTION(I2C, read) {
*
* @returns 0 on success, non-0 on failure
*/
DECLARE_CLASS_FUNCTION(I2C, write) {
CHECK_ARGUMENT_COUNT(I2C, write, (args_count == 1 || args_count == 3 || args_count == 4));
DECLARE_CLASS_FUNCTION (I2C, write)
{
CHECK_ARGUMENT_COUNT (I2C, write, (args_count == 1 || args_count == 3 || args_count == 4));
if (args_count == 1) {
CHECK_ARGUMENT_TYPE_ALWAYS(I2C, write, 0, number);
if (args_count == 1)
{
CHECK_ARGUMENT_TYPE_ALWAYS (I2C, write, 0, number);
// Extract native I2C object
void *void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Extract native I2C object
void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native I2C pointer");
}
I2C *native_ptr = static_cast<I2C*>(void_ptr);
// Unwrap arguments
int data = jerry_get_number_value(args[0]);
int result = native_ptr->write(data);
return jerry_create_number(result);
} else {
// 3 or 4
CHECK_ARGUMENT_TYPE_ALWAYS(I2C, write, 0, number);
CHECK_ARGUMENT_TYPE_ALWAYS(I2C, write, 1, array);
CHECK_ARGUMENT_TYPE_ALWAYS(I2C, write, 2, number);
CHECK_ARGUMENT_TYPE_ON_CONDITION(I2C, write, 3, boolean, (args_count == 4));
// Extract native I2C object
void *void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native I2C pointer");
}
I2C *native_ptr = static_cast<I2C*>(void_ptr);
// Unwrap arguments
int address = jerry_get_number_value(args[0]);
const uint32_t data_len = jerry_get_array_length(args[1]);
int length = jerry_get_number_value(args[2]);
bool repeated = args_count == 4 && jerry_value_is_true(args[3]);
// Construct data byte array
char *data = new char[data_len];
for (uint32_t i = 0; i < data_len; i++) {
data[i] = jerry_get_number_value(jerry_get_property_by_index(args[1], i));
}
int result = native_ptr->write(address, data, length, repeated);
// free dynamically allocated resources
delete[] data;
return jerry_create_number(result);
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native I2C pointer");
}
I2C *native_ptr = static_cast<I2C *> (void_ptr);
// Unwrap arguments
int data = jerry_value_as_number (args[0]);
int result = native_ptr->write (data);
return jerry_number (result);
}
else
{
// 3 or 4
CHECK_ARGUMENT_TYPE_ALWAYS (I2C, write, 0, number);
CHECK_ARGUMENT_TYPE_ALWAYS (I2C, write, 1, array);
CHECK_ARGUMENT_TYPE_ALWAYS (I2C, write, 2, number);
CHECK_ARGUMENT_TYPE_ON_CONDITION (I2C, write, 3, boolean, (args_count == 4));
// Extract native I2C object
void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (void_ptr != NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native I2C pointer");
}
I2C *native_ptr = static_cast<I2C *> (void_ptr);
// Unwrap arguments
int address = jerry_value_as_number (args[0]);
const uint32_t data_len = jerry_array_length (args[1]);
int length = jerry_value_as_number (args[2]);
bool repeated = args_count == 4 && jerry_value_is_true (args[3]);
// Construct data byte array
char *data = new char[data_len];
for (uint32_t i = 0; i < data_len; i++)
{
data[i] = jerry_value_as_number (jerry_object_get_index (args[1], i));
}
int result = native_ptr->write (address, data, length, repeated);
// free dynamically allocated resources
delete[] data;
return jerry_number (result);
}
}
/**
@ -245,22 +255,22 @@ DECLARE_CLASS_FUNCTION(I2C, write) {
*
* Creates a start condition on the I2C bus.
*/
DECLARE_CLASS_FUNCTION(I2C, start) {
CHECK_ARGUMENT_COUNT(I2C, start, (args_count == 0));
DECLARE_CLASS_FUNCTION (I2C, start)
{
CHECK_ARGUMENT_COUNT (I2C, start, (args_count == 0));
// Extract native I2C object
void *void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Extract native I2C object
void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native I2C pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native I2C pointer");
}
I2C *native_ptr = static_cast<I2C*>(void_ptr);
I2C *native_ptr = static_cast<I2C *> (void_ptr);
native_ptr->start();
return jerry_create_undefined();
native_ptr->start ();
return jerry_undefined ();
}
/**
@ -268,22 +278,22 @@ DECLARE_CLASS_FUNCTION(I2C, start) {
*
* Creates a stop condition on the I2C bus.
*/
DECLARE_CLASS_FUNCTION(I2C, stop) {
CHECK_ARGUMENT_COUNT(I2C, stop, (args_count == 0));
DECLARE_CLASS_FUNCTION (I2C, stop)
{
CHECK_ARGUMENT_COUNT (I2C, stop, (args_count == 0));
// Extract native I2C object
void *void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Extract native I2C object
void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native I2C pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native I2C pointer");
}
I2C *native_ptr = static_cast<I2C*>(void_ptr);
I2C *native_ptr = static_cast<I2C *> (void_ptr);
native_ptr->stop();
return jerry_create_undefined();
native_ptr->stop ();
return jerry_undefined ();
}
/**
@ -293,24 +303,25 @@ DECLARE_CLASS_FUNCTION(I2C, stop) {
* @param scl mbed pin for I2C clock
* @returns a JavaScript object representing the I2C bus.
*/
DECLARE_CLASS_CONSTRUCTOR(I2C) {
CHECK_ARGUMENT_COUNT(I2C, __constructor, (args_count == 2));
CHECK_ARGUMENT_TYPE_ALWAYS(I2C, __constructor, 0, number);
CHECK_ARGUMENT_TYPE_ALWAYS(I2C, __constructor, 1, number);
DECLARE_CLASS_CONSTRUCTOR (I2C)
{
CHECK_ARGUMENT_COUNT (I2C, __constructor, (args_count == 2));
CHECK_ARGUMENT_TYPE_ALWAYS (I2C, __constructor, 0, number);
CHECK_ARGUMENT_TYPE_ALWAYS (I2C, __constructor, 1, number);
int sda = jerry_get_number_value(args[0]);
int scl = jerry_get_number_value(args[1]);
int sda = jerry_value_as_number (args[0]);
int scl = jerry_value_as_number (args[1]);
I2C *native_ptr = new I2C((PinName)sda, (PinName)scl);
I2C *native_ptr = new I2C ((PinName) sda, (PinName) scl);
jerry_value_t js_object = jerry_create_object();
jerry_set_object_native_pointer(js_object, native_ptr, &native_obj_type_info);
jerry_value_t js_object = jerry_object ();
jerry_object_set_native_ptr (js_object, &native_obj_type_info, native_ptr);
ATTACH_CLASS_FUNCTION(js_object, I2C, frequency);
ATTACH_CLASS_FUNCTION(js_object, I2C, read);
ATTACH_CLASS_FUNCTION(js_object, I2C, write);
ATTACH_CLASS_FUNCTION(js_object, I2C, start);
ATTACH_CLASS_FUNCTION(js_object, I2C, stop);
ATTACH_CLASS_FUNCTION (js_object, I2C, frequency);
ATTACH_CLASS_FUNCTION (js_object, I2C, read);
ATTACH_CLASS_FUNCTION (js_object, I2C, write);
ATTACH_CLASS_FUNCTION (js_object, I2C, start);
ATTACH_CLASS_FUNCTION (js_object, I2C, stop);
return js_object;
return js_object;
}

297
targets/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/InterruptIn-js.cpp
View File

@ -12,10 +12,9 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "jerryscript-mbed-util/logging.h"
#include "jerryscript-mbed-event-loop/EventLoop.h"
#include "jerryscript-mbed-library-registry/wrap_tools.h"
#include "jerryscript-mbed-util/logging.h"
#include "mbed.h"
/**
@ -23,13 +22,15 @@
*
* Called if/when the InterruptIn object is GC'ed.
*/
void NAME_FOR_CLASS_NATIVE_DESTRUCTOR(InterruptIn) (void *void_ptr, jerry_object_native_info_t *info_p) {
(void) info_p;
InterruptIn *native_ptr = static_cast<InterruptIn*>(void_ptr);
void
NAME_FOR_CLASS_NATIVE_DESTRUCTOR (InterruptIn) (void *void_ptr, jerry_object_native_info_t *info_p)
{
(void) info_p;
InterruptIn *native_ptr = static_cast<InterruptIn *> (void_ptr);
native_ptr->rise(0);
native_ptr->fall(0);
delete native_ptr;
native_ptr->rise (0);
native_ptr->fall (0);
delete native_ptr;
}
/**
@ -37,9 +38,8 @@ void NAME_FOR_CLASS_NATIVE_DESTRUCTOR(InterruptIn) (void *void_ptr, jerry_object
*
* Set InterruptIn#destructor as the free callback.
*/
static const jerry_object_native_info_t native_obj_type_info = {
.free_cb = NAME_FOR_CLASS_NATIVE_DESTRUCTOR(InterruptIn)
};
static const jerry_object_native_info_t native_obj_type_info = { .free_cb =
NAME_FOR_CLASS_NATIVE_DESTRUCTOR (InterruptIn) };
/**
* InterruptIn#rise (native JavaScript method)
@ -48,62 +48,63 @@ static const jerry_object_native_info_t native_obj_type_info = {
*
* @param cb Callback function, or null to detach previously attached callback.
*/
DECLARE_CLASS_FUNCTION(InterruptIn, rise) {
CHECK_ARGUMENT_COUNT(InterruptIn, rise, (args_count == 1));
DECLARE_CLASS_FUNCTION (InterruptIn, rise)
{
CHECK_ARGUMENT_COUNT (InterruptIn, rise, (args_count == 1));
// Detach the rise callback when InterruptIn::rise(null) is called
if (jerry_value_is_null(args[0])) {
void *void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Detach the rise callback when InterruptIn::rise(null) is called
if (jerry_value_is_null (args[0]))
{
void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native InterruptIn pointer");
}
InterruptIn *native_ptr = static_cast<InterruptIn*>(void_ptr);
jerry_value_t property_name = jerry_create_string((const jerry_char_t*)"cb_rise");
jerry_value_t cb_func = jerry_get_property(call_info_p->this_value, property_name);
jerry_release_value(property_name);
// Only drop the callback if it exists
if (jerry_value_is_function(cb_func)) {
// Ensure that the EventLoop frees memory used by the callback.
mbed::js::EventLoop::getInstance().dropCallback(cb_func);
}
jerry_release_value(cb_func);
native_ptr->rise(0);
return jerry_create_undefined();
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native InterruptIn pointer");
}
// Assuming we actually have a callback now...
CHECK_ARGUMENT_TYPE_ALWAYS(InterruptIn, rise, 0, function);
InterruptIn *native_ptr = static_cast<InterruptIn *> (void_ptr);
void *void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
jerry_value_t property_name = jerry_string_sz ("cb_rise");
jerry_value_t cb_func = jerry_object_get (call_info_p->this_value, property_name);
jerry_value_free (property_name);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native InterruptIn pointer");
// Only drop the callback if it exists
if (jerry_value_is_function (cb_func))
{
// Ensure that the EventLoop frees memory used by the callback.
mbed::js::EventLoop::getInstance ().dropCallback (cb_func);
}
jerry_value_free (cb_func);
InterruptIn *native_ptr = static_cast<InterruptIn*>(void_ptr);
native_ptr->rise (0);
jerry_value_t f = args[0];
return jerry_undefined ();
}
// Pass the function to EventLoop.
mbed::Callback<void()> cb = mbed::js::EventLoop::getInstance().wrapFunction(f);
native_ptr->rise(cb);
// Assuming we actually have a callback now...
CHECK_ARGUMENT_TYPE_ALWAYS (InterruptIn, rise, 0, function);
// Keep track of our callback internally.
jerry_value_t property_name = jerry_create_string((const jerry_char_t*)"cb_rise");
jerry_release_value(jerry_set_property(call_info_p->this_value, property_name, f));
jerry_release_value(property_name);
void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
return jerry_create_undefined();
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native InterruptIn pointer");
}
InterruptIn *native_ptr = static_cast<InterruptIn *> (void_ptr);
jerry_value_t f = args[0];
// Pass the function to EventLoop.
mbed::Callback<void ()> cb = mbed::js::EventLoop::getInstance ().wrapFunction (f);
native_ptr->rise (cb);
// Keep track of our callback internally.
jerry_value_t property_name = jerry_string_sz ("cb_rise");
jerry_value_free (jerry_object_set (call_info_p->this_value, property_name, f));
jerry_value_free (property_name);
return jerry_undefined ();
}
/**
@ -113,62 +114,63 @@ DECLARE_CLASS_FUNCTION(InterruptIn, rise) {
*
* @param cb Callback function, or null to detach previously attached callback.
*/
DECLARE_CLASS_FUNCTION(InterruptIn, fall) {
CHECK_ARGUMENT_COUNT(InterruptIn, fall, (args_count == 1));
DECLARE_CLASS_FUNCTION (InterruptIn, fall)
{
CHECK_ARGUMENT_COUNT (InterruptIn, fall, (args_count == 1));
// Detach the fall callback when InterruptIn::fall(null) is called
if (jerry_value_is_null(args[0])) {
void *void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Detach the fall callback when InterruptIn::fall(null) is called
if (jerry_value_is_null (args[0]))
{
void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native InterruptIn pointer");
}
InterruptIn *native_ptr = static_cast<InterruptIn*>(void_ptr);
jerry_value_t property_name = jerry_create_string((const jerry_char_t*)"cb_fall");
jerry_value_t cb_func = jerry_get_property(call_info_p->this_value, property_name);
jerry_release_value(property_name);
// Only drop the callback if it exists
if (jerry_value_is_function(cb_func)) {
// Ensure that the EventLoop frees memory used by the callback.
mbed::js::EventLoop::getInstance().dropCallback(cb_func);
}
jerry_release_value(cb_func);
native_ptr->fall(0);
return jerry_create_undefined();
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native InterruptIn pointer");
}
// Assuming we actually have a callback now...
CHECK_ARGUMENT_TYPE_ALWAYS(InterruptIn, fall, 0, function);
InterruptIn *native_ptr = static_cast<InterruptIn *> (void_ptr);
void *void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
jerry_value_t property_name = jerry_string_sz ("cb_fall");
jerry_value_t cb_func = jerry_object_get (call_info_p->this_value, property_name);
jerry_value_free (property_name);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native InterruptIn pointer");
// Only drop the callback if it exists
if (jerry_value_is_function (cb_func))
{
// Ensure that the EventLoop frees memory used by the callback.
mbed::js::EventLoop::getInstance ().dropCallback (cb_func);
}
jerry_value_free (cb_func);
InterruptIn *native_ptr = static_cast<InterruptIn*>(void_ptr);
native_ptr->fall (0);
jerry_value_t f = args[0];
return jerry_undefined ();
}
// Pass the function to EventLoop.
mbed::Callback<void()> cb = mbed::js::EventLoop::getInstance().wrapFunction(f);
native_ptr->fall(cb);
// Assuming we actually have a callback now...
CHECK_ARGUMENT_TYPE_ALWAYS (InterruptIn, fall, 0, function);
// Keep track of our callback internally.
jerry_value_t property_name = jerry_create_string((const jerry_char_t*)"cb_fall");
jerry_release_value(jerry_set_property(call_info_p->this_value, property_name, f));
jerry_release_value(property_name);
void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
return jerry_create_undefined();
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native InterruptIn pointer");
}
InterruptIn *native_ptr = static_cast<InterruptIn *> (void_ptr);
jerry_value_t f = args[0];
// Pass the function to EventLoop.
mbed::Callback<void ()> cb = mbed::js::EventLoop::getInstance ().wrapFunction (f);
native_ptr->fall (cb);
// Keep track of our callback internally.
jerry_value_t property_name = jerry_string_sz ("cb_fall");
jerry_value_free (jerry_object_set (call_info_p->this_value, property_name, f));
jerry_value_free (property_name);
return jerry_undefined ();
}
/**
@ -178,24 +180,24 @@ DECLARE_CLASS_FUNCTION(InterruptIn, fall) {
*
* @param mode PullUp, PullDown, PullNone
*/
DECLARE_CLASS_FUNCTION(InterruptIn, mode) {
CHECK_ARGUMENT_COUNT(InterruptIn, mode, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS(InterruptIn, mode, 0, number);
DECLARE_CLASS_FUNCTION (InterruptIn, mode)
{
CHECK_ARGUMENT_COUNT (InterruptIn, mode, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS (InterruptIn, mode, 0, number);
void *void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native InterruptIn pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native InterruptIn pointer");
}
InterruptIn *native_ptr = static_cast<InterruptIn*>(void_ptr);
InterruptIn *native_ptr = static_cast<InterruptIn *> (void_ptr);
int pull = jerry_get_number_value(args[0]);
native_ptr->mode((PinMode)pull);
int pull = jerry_value_as_number (args[0]);
native_ptr->mode ((PinMode) pull);
return jerry_create_undefined();
return jerry_undefined ();
}
/**
@ -203,21 +205,21 @@ DECLARE_CLASS_FUNCTION(InterruptIn, mode) {
*
* Disable IRQ. See InterruptIn.h in mbed-os sources for more details.
*/
DECLARE_CLASS_FUNCTION(InterruptIn, disable_irq) {
CHECK_ARGUMENT_COUNT(InterruptIn, disable_irq, (args_count == 0));
DECLARE_CLASS_FUNCTION (InterruptIn, disable_irq)
{
CHECK_ARGUMENT_COUNT (InterruptIn, disable_irq, (args_count == 0));
void *void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native InterruptIn pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native InterruptIn pointer");
}
InterruptIn *native_ptr = static_cast<InterruptIn*>(void_ptr);
InterruptIn *native_ptr = static_cast<InterruptIn *> (void_ptr);
native_ptr->disable_irq();
return jerry_create_undefined();
native_ptr->disable_irq ();
return jerry_undefined ();
}
/**
@ -225,21 +227,21 @@ DECLARE_CLASS_FUNCTION(InterruptIn, disable_irq) {
*
* Enable IRQ. See InterruptIn.h in mbed-os sources for more details.
*/
DECLARE_CLASS_FUNCTION(InterruptIn, enable_irq) {
CHECK_ARGUMENT_COUNT(InterruptIn, enable_irq, (args_count == 0));
DECLARE_CLASS_FUNCTION (InterruptIn, enable_irq)
{
CHECK_ARGUMENT_COUNT (InterruptIn, enable_irq, (args_count == 0));
void *void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
void *void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native InterruptIn pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native InterruptIn pointer");
}
InterruptIn *native_ptr = static_cast<InterruptIn*>(void_ptr);
InterruptIn *native_ptr = static_cast<InterruptIn *> (void_ptr);
native_ptr->enable_irq();
return jerry_create_undefined();
native_ptr->enable_irq ();
return jerry_undefined ();
}
/**
@ -249,21 +251,22 @@ DECLARE_CLASS_FUNCTION(InterruptIn, enable_irq) {
*
* @returns JavaScript object wrapping InterruptIn native object
*/
DECLARE_CLASS_CONSTRUCTOR(InterruptIn) {
CHECK_ARGUMENT_COUNT(InterruptIn, __constructor, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS(InterruptIn, __constructor, 0, number);
int pin = jerry_get_number_value(args[0]);
DECLARE_CLASS_CONSTRUCTOR (InterruptIn)
{
CHECK_ARGUMENT_COUNT (InterruptIn, __constructor, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS (InterruptIn, __constructor, 0, number);
int pin = jerry_value_as_number (args[0]);
InterruptIn *native_ptr = new InterruptIn((PinName)pin);
jerry_value_t js_object = jerry_create_object();
InterruptIn *native_ptr = new InterruptIn ((PinName) pin);
jerry_value_t js_object = jerry_object ();
jerry_set_object_native_pointer(js_object, native_ptr, &native_obj_type_info);
jerry_object_set_native_ptr (js_object, &native_obj_type_info, native_ptr);
ATTACH_CLASS_FUNCTION(js_object, InterruptIn, rise);
ATTACH_CLASS_FUNCTION(js_object, InterruptIn, fall);
ATTACH_CLASS_FUNCTION(js_object, InterruptIn, mode);
ATTACH_CLASS_FUNCTION(js_object, InterruptIn, enable_irq);
ATTACH_CLASS_FUNCTION(js_object, InterruptIn, disable_irq);
ATTACH_CLASS_FUNCTION (js_object, InterruptIn, rise);
ATTACH_CLASS_FUNCTION (js_object, InterruptIn, fall);
ATTACH_CLASS_FUNCTION (js_object, InterruptIn, mode);
ATTACH_CLASS_FUNCTION (js_object, InterruptIn, enable_irq);
ATTACH_CLASS_FUNCTION (js_object, InterruptIn, disable_irq);
return js_object;
return js_object;
}

274
targets/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/PwmOut-js.cpp
View File

@ -12,9 +12,8 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include "jerryscript-mbed-util/logging.h"
#include "jerryscript-mbed-library-registry/wrap_tools.h"
#include "jerryscript-mbed-util/logging.h"
#include "mbed.h"
/**
@ -22,9 +21,11 @@
*
* Called if/when the PwmOut is GC'ed.
*/
void NAME_FOR_CLASS_NATIVE_DESTRUCTOR(PwmOut)(void* void_ptr, jerry_object_native_info_t *info_p) {
(void) info_p;
delete static_cast<PwmOut*>(void_ptr);
void
NAME_FOR_CLASS_NATIVE_DESTRUCTOR (PwmOut) (void* void_ptr, jerry_object_native_info_t* info_p)
{
(void) info_p;
delete static_cast<PwmOut*> (void_ptr);
}
/**
@ -32,9 +33,7 @@ void NAME_FOR_CLASS_NATIVE_DESTRUCTOR(PwmOut)(void* void_ptr, jerry_object_nativ
*
* Set PwmOut#destructor as the free callback.
*/
static const jerry_object_native_info_t native_obj_type_info = {
.free_cb = NAME_FOR_CLASS_NATIVE_DESTRUCTOR(PwmOut)
};
static const jerry_object_native_info_t native_obj_type_info = { .free_cb = NAME_FOR_CLASS_NATIVE_DESTRUCTOR (PwmOut) };
/**
* PwmOut#write (native JavaScript method)
@ -47,25 +46,25 @@ static const jerry_object_native_info_t native_obj_type_info = {
* Values outside this range will be saturated to 0.0f or 1.0f
* @returns undefined
*/
DECLARE_CLASS_FUNCTION(PwmOut, write) {
CHECK_ARGUMENT_COUNT(PwmOut, write, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS(PwmOut, write, 0, number);
DECLARE_CLASS_FUNCTION (PwmOut, write)
{
CHECK_ARGUMENT_COUNT (PwmOut, write, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS (PwmOut, write, 0, number);
// Extract native PwmOut pointer
void* void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Extract native PwmOut pointer
void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native PwmOut pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native PwmOut pointer");
}
PwmOut* native_ptr = static_cast<PwmOut*>(void_ptr);
PwmOut* native_ptr = static_cast<PwmOut*> (void_ptr);
double arg0 = jerry_get_number_value(args[0]);
native_ptr->write(static_cast<float>(arg0));
double arg0 = jerry_value_as_number (args[0]);
native_ptr->write (static_cast<float> (arg0));
return jerry_create_undefined();
return jerry_undefined ();
}
/**
@ -81,22 +80,22 @@ DECLARE_CLASS_FUNCTION(PwmOut, write) {
* @note
* This value may not match exactly the value set by a previous <write>.
*/
DECLARE_CLASS_FUNCTION(PwmOut, read) {
CHECK_ARGUMENT_COUNT(PwmOut, read, (args_count == 0));
DECLARE_CLASS_FUNCTION (PwmOut, read)
{
CHECK_ARGUMENT_COUNT (PwmOut, read, (args_count == 0));
// Extract native PwmOut pointer
void* void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Extract native PwmOut pointer
void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native PwmOut pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native PwmOut pointer");
}
PwmOut* native_ptr = static_cast<PwmOut*>(void_ptr);
PwmOut* native_ptr = static_cast<PwmOut*> (void_ptr);
float result = native_ptr->read();
return jerry_create_number(result);
float result = native_ptr->read ();
return jerry_number (result);
}
/**
@ -108,25 +107,25 @@ DECLARE_CLASS_FUNCTION(PwmOut, read) {
* The resolution is currently in microseconds; periods smaller than this
* will be set to zero.
*/
DECLARE_CLASS_FUNCTION(PwmOut, period) {
CHECK_ARGUMENT_COUNT(PwmOut, period, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS(PwmOut, period, 0, number);
DECLARE_CLASS_FUNCTION (PwmOut, period)
{
CHECK_ARGUMENT_COUNT (PwmOut, period, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS (PwmOut, period, 0, number);
// Extract native PwmOut pointer
void* void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Extract native PwmOut pointer
void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native PwmOut pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native PwmOut pointer");
}
PwmOut* native_ptr = static_cast<PwmOut*>(void_ptr);
PwmOut* native_ptr = static_cast<PwmOut*> (void_ptr);
double arg0 = jerry_get_number_value(args[0]);
native_ptr->period(static_cast<float>(arg0));
double arg0 = jerry_value_as_number (args[0]);
native_ptr->period (static_cast<float> (arg0));
return jerry_create_undefined();
return jerry_undefined ();
}
/**
@ -134,25 +133,25 @@ DECLARE_CLASS_FUNCTION(PwmOut, period) {
*
* Set the PWM period, specified in milli-seconds (int), keeping the duty cycle the same.
*/
DECLARE_CLASS_FUNCTION(PwmOut, period_ms) {
CHECK_ARGUMENT_COUNT(PwmOut, period_ms, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS(PwmOut, period_ms, 0, number);
DECLARE_CLASS_FUNCTION (PwmOut, period_ms)
{
CHECK_ARGUMENT_COUNT (PwmOut, period_ms, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS (PwmOut, period_ms, 0, number);
// Extract native PwmOut pointer
void* void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Extract native PwmOut pointer
void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native PwmOut pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native PwmOut pointer");
}
PwmOut* native_ptr = static_cast<PwmOut*>(void_ptr);
PwmOut* native_ptr = static_cast<PwmOut*> (void_ptr);
double arg0 = jerry_get_number_value(args[0]);
native_ptr->period_ms(static_cast<int>(arg0));
double arg0 = jerry_value_as_number (args[0]);
native_ptr->period_ms (static_cast<int> (arg0));
return jerry_create_undefined();
return jerry_undefined ();
}
/**
@ -160,25 +159,25 @@ DECLARE_CLASS_FUNCTION(PwmOut, period_ms) {
*
* Set the PWM period, specified in micro-seconds (int), keeping the duty cycle the same.
*/
DECLARE_CLASS_FUNCTION(PwmOut, period_us) {
CHECK_ARGUMENT_COUNT(PwmOut, period_us, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS(PwmOut, period_us, 0, number);
DECLARE_CLASS_FUNCTION (PwmOut, period_us)
{
CHECK_ARGUMENT_COUNT (PwmOut, period_us, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS (PwmOut, period_us, 0, number);
// Extract native PwmOut pointer
void* void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Extract native PwmOut pointer
void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native PwmOut pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native PwmOut pointer");
}
PwmOut* native_ptr = static_cast<PwmOut*>(void_ptr);
PwmOut* native_ptr = static_cast<PwmOut*> (void_ptr);
double arg0 = jerry_get_number_value(args[0]);
native_ptr->period_us(static_cast<int>(arg0));
double arg0 = jerry_value_as_number (args[0]);
native_ptr->period_us (static_cast<int> (arg0));
return jerry_create_undefined();
return jerry_undefined ();
}
/**
@ -186,25 +185,25 @@ DECLARE_CLASS_FUNCTION(PwmOut, period_us) {
*
* Set the PWM pulsewidth, specified in seconds (float), keeping the period the same.
*/
DECLARE_CLASS_FUNCTION(PwmOut, pulsewidth) {
CHECK_ARGUMENT_COUNT(PwmOut, pulsewidth, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS(PwmOut, pulsewidth, 0, number);
DECLARE_CLASS_FUNCTION (PwmOut, pulsewidth)
{
CHECK_ARGUMENT_COUNT (PwmOut, pulsewidth, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS (PwmOut, pulsewidth, 0, number);
// Extract native PwmOut pointer
void* void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Extract native PwmOut pointer
void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native PwmOut pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native PwmOut pointer");
}
PwmOut* native_ptr = static_cast<PwmOut*>(void_ptr);
PwmOut* native_ptr = static_cast<PwmOut*> (void_ptr);
double arg0 = jerry_get_number_value(args[0]);
native_ptr->pulsewidth(static_cast<float>(arg0));
double arg0 = jerry_value_as_number (args[0]);
native_ptr->pulsewidth (static_cast<float> (arg0));
return jerry_create_undefined();
return jerry_undefined ();
}
/**
@ -212,25 +211,25 @@ DECLARE_CLASS_FUNCTION(PwmOut, pulsewidth) {
*
* Set the PWM pulsewidth, specified in milli-seconds (int), keeping the period the same.
*/
DECLARE_CLASS_FUNCTION(PwmOut, pulsewidth_ms) {
CHECK_ARGUMENT_COUNT(PwmOut, pulsewidth_ms, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS(PwmOut, pulsewidth_ms, 0, number);
DECLARE_CLASS_FUNCTION (PwmOut, pulsewidth_ms)
{
CHECK_ARGUMENT_COUNT (PwmOut, pulsewidth_ms, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS (PwmOut, pulsewidth_ms, 0, number);
// Extract native PwmOut pointer
void* void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Extract native PwmOut pointer
void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native PwmOut pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native PwmOut pointer");
}
PwmOut* native_ptr = static_cast<PwmOut*>(void_ptr);
PwmOut* native_ptr = static_cast<PwmOut*> (void_ptr);
double arg0 = jerry_get_number_value(args[0]);
native_ptr->pulsewidth_ms(static_cast<int>(arg0));
double arg0 = jerry_value_as_number (args[0]);
native_ptr->pulsewidth_ms (static_cast<int> (arg0));
return jerry_create_undefined();
return jerry_undefined ();
}
/**
@ -238,25 +237,25 @@ DECLARE_CLASS_FUNCTION(PwmOut, pulsewidth_ms) {
*
* Set the PWM pulsewidth, specified in micro-seconds (int), keeping the period the same.
*/
DECLARE_CLASS_FUNCTION(PwmOut, pulsewidth_us) {
CHECK_ARGUMENT_COUNT(PwmOut, pulsewidth_us, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS(PwmOut, pulsewidth_us, 0, number);
DECLARE_CLASS_FUNCTION (PwmOut, pulsewidth_us)
{
CHECK_ARGUMENT_COUNT (PwmOut, pulsewidth_us, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS (PwmOut, pulsewidth_us, 0, number);
// Extract native PwmOut pointer
void* void_ptr;
bool has_ptr = jerry_get_object_native_pointer(call_info_p->this_value, &void_ptr, &native_obj_type_info);
// Extract native PwmOut pointer
void* void_ptr = jerry_object_get_native_ptr (call_info_p->this_value, &native_obj_type_info);
if (!has_ptr) {
return jerry_create_error(JERRY_ERROR_TYPE,
(const jerry_char_t *) "Failed to get native PwmOut pointer");
}
if (void_ptr == NULL)
{
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to get native PwmOut pointer");
}
PwmOut* native_ptr = static_cast<PwmOut*>(void_ptr);
PwmOut* native_ptr = static_cast<PwmOut*> (void_ptr);
double arg0 = jerry_get_number_value(args[0]);
native_ptr->pulsewidth_us(static_cast<int>(arg0));
double arg0 = jerry_value_as_number (args[0]);
native_ptr->pulsewidth_us (static_cast<int> (arg0));
return jerry_create_undefined();
return jerry_undefined ();
}
/**
@ -265,28 +264,29 @@ DECLARE_CLASS_FUNCTION(PwmOut, pulsewidth_us) {
* @param pin_name mbed pin to connect the PwmOut to.
* @returns a JavaScript object representing a PwmOut.
*/
DECLARE_CLASS_CONSTRUCTOR(PwmOut) {
CHECK_ARGUMENT_COUNT(PwmOut, __constructor, args_count == 1);
CHECK_ARGUMENT_TYPE_ALWAYS(PwmOut, __constructor, 0, number);
DECLARE_CLASS_CONSTRUCTOR (PwmOut)
{
CHECK_ARGUMENT_COUNT (PwmOut, __constructor, args_count == 1);
CHECK_ARGUMENT_TYPE_ALWAYS (PwmOut, __constructor, 0, number);
PinName pin_name = PinName(jerry_get_number_value(args[0]));
PinName pin_name = PinName (jerry_value_as_number (args[0]));
// Create the native object
PwmOut* native_ptr = new PwmOut(pin_name);
// Create the native object
PwmOut* native_ptr = new PwmOut (pin_name);
// create the jerryscript object
jerry_value_t js_object = jerry_create_object();
jerry_set_object_native_pointer(js_object, native_ptr, &native_obj_type_info);
// create the jerryscript object
jerry_value_t js_object = jerry_object ();
jerry_object_set_native_ptr (js_object, &native_obj_type_info, native_ptr);
// attach methods
ATTACH_CLASS_FUNCTION(js_object, PwmOut, write);
ATTACH_CLASS_FUNCTION(js_object, PwmOut, read);
ATTACH_CLASS_FUNCTION(js_object, PwmOut, period);
ATTACH_CLASS_FUNCTION(js_object, PwmOut, period_ms);
ATTACH_CLASS_FUNCTION(js_object, PwmOut, period_us);
ATTACH_CLASS_FUNCTION(js_object, PwmOut, pulsewidth);
ATTACH_CLASS_FUNCTION(js_object, PwmOut, pulsewidth_ms);
ATTACH_CLASS_FUNCTION(js_object, PwmOut, pulsewidth_us);
// attach methods
ATTACH_CLASS_FUNCTION (js_object, PwmOut, write);
ATTACH_CLASS_FUNCTION (js_object, PwmOut, read);
ATTACH_CLASS_FUNCTION (js_object, PwmOut, period);
ATTACH_CLASS_FUNCTION (js_object, PwmOut, period_ms);
ATTACH_CLASS_FUNCTION (js_object, PwmOut, period_us);
ATTACH_CLASS_FUNCTION (js_object, PwmOut, pulsewidth);
ATTACH_CLASS_FUNCTION (js_object, PwmOut, pulsewidth_ms);
ATTACH_CLASS_FUNCTION (js_object, PwmOut, pulsewidth_us);
return js_object;
return js_object;
}

63
targets/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/setInterval-js.cpp
View File

@ -13,6 +13,7 @@
* limitations under the License.
*/
#include "jerryscript-mbed-drivers/setInterval-js.h"
#include "jerryscript-mbed-event-loop/EventLoop.h"
/**
@ -23,26 +24,33 @@
* @param function Function to call
* @param interval Time between function calls, in ms.
*/
DECLARE_GLOBAL_FUNCTION(setInterval) {
CHECK_ARGUMENT_COUNT(global, setInterval, (args_count == 2));
CHECK_ARGUMENT_TYPE_ALWAYS(global, setInterval, 0, function);
CHECK_ARGUMENT_TYPE_ALWAYS(global, setInterval, 1, number);
DECLARE_GLOBAL_FUNCTION (setInterval)
{
CHECK_ARGUMENT_COUNT (global, setInterval, (args_count == 2));
CHECK_ARGUMENT_TYPE_ALWAYS (global, setInterval, 0, function);
CHECK_ARGUMENT_TYPE_ALWAYS (global, setInterval, 1, number);
int interval = int(jerry_get_number_value(args[1]));
int interval = int (jerry_value_as_number (args[1]));
int id = mbed::js::EventLoop::getInstance().getQueue().call_every(interval, jerry_call_function, args[0], jerry_create_null(), (jerry_value_t*)NULL, 0);
int id = mbed::js::EventLoop::getInstance ().getQueue ().call_every (interval,
jerry_call,
args[0],
jerry_null (),
(jerry_value_t*) NULL,
0);
jerry_value_t result = jerry_set_property_by_index(call_info_p->function, id, args[0]);
jerry_value_t result = jerry_object_set_index (call_info_p->function, id, args[0]);
if (jerry_value_is_error(result)) {
jerry_release_value(result);
mbed::js::EventLoop::getInstance().getQueue().cancel(id);
if (jerry_value_is_exception (result))
{
jerry_value_free (result);
mbed::js::EventLoop::getInstance ().getQueue ().cancel (id);
return jerry_create_error(JERRY_ERROR_TYPE, (const jerry_char_t *) "Failed to run setInterval");
}
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to run setInterval");
}
jerry_release_value(result);
return jerry_create_number(id);
jerry_value_free (result);
return jerry_number (id);
}
/**
@ -52,22 +60,23 @@ DECLARE_GLOBAL_FUNCTION(setInterval) {
*
* @param id ID of the timeout event, returned by setInterval.
*/
DECLARE_GLOBAL_FUNCTION(clearInterval) {
CHECK_ARGUMENT_COUNT(global, clearInterval, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS(global, clearInterval, 0, number);
DECLARE_GLOBAL_FUNCTION (clearInterval)
{
CHECK_ARGUMENT_COUNT (global, clearInterval, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS (global, clearInterval, 0, number);
int id = int(jerry_get_number_value(args[0]));
int id = int (jerry_value_as_number (args[0]));
mbed::js::EventLoop::getInstance().getQueue().cancel(id);
mbed::js::EventLoop::getInstance ().getQueue ().cancel (id);
jerry_value_t global_obj = jerry_get_global_object();
jerry_value_t prop_name = jerry_create_string((const jerry_char_t*)"setInterval");
jerry_value_t func_obj = jerry_get_property(global_obj, prop_name);
jerry_release_value(prop_name);
jerry_value_t global_obj = jerry_current_realm ();
jerry_value_t prop_name = jerry_string_sz ("setInterval");
jerry_value_t func_obj = jerry_object_get (global_obj, prop_name);
jerry_value_free (prop_name);
jerry_delete_property_by_index(func_obj, id);
jerry_release_value(func_obj);
jerry_release_value(global_obj);
jerry_object_delete_index (func_obj, id);
jerry_value_free (func_obj);
jerry_value_free (global_obj);
return jerry_create_undefined();
return jerry_undefined ();
}

63
targets/mbedos5/jerryscript-mbed/jerryscript-mbed-drivers/source/setTimeout-js.cpp
View File

@ -13,6 +13,7 @@
* limitations under the License.
*/
#include "jerryscript-mbed-drivers/setTimeout-js.h"
#include "jerryscript-mbed-event-loop/EventLoop.h"
/**
@ -23,26 +24,33 @@
* @param function Function to call
* @param wait_time Time before function is called, in ms.
*/
DECLARE_GLOBAL_FUNCTION(setTimeout) {
CHECK_ARGUMENT_COUNT(global, setTimeout, (args_count == 2));
CHECK_ARGUMENT_TYPE_ALWAYS(global, setTimeout, 0, function);
CHECK_ARGUMENT_TYPE_ALWAYS(global, setTimeout, 1, number);
DECLARE_GLOBAL_FUNCTION (setTimeout)
{
CHECK_ARGUMENT_COUNT (global, setTimeout, (args_count == 2));
CHECK_ARGUMENT_TYPE_ALWAYS (global, setTimeout, 0, function);
CHECK_ARGUMENT_TYPE_ALWAYS (global, setTimeout, 1, number);
int interval = int(jerry_get_number_value(args[1]));
int interval = int (jerry_value_as_number (args[1]));
int id = mbed::js::EventLoop::getInstance().getQueue().call_in(interval, jerry_call_function, args[0], jerry_create_null(), (jerry_value_t*)NULL, 0);
int id = mbed::js::EventLoop::getInstance ().getQueue ().call_in (interval,
jerry_call,
args[0],
jerry_null (),
(jerry_value_t*) NULL,
0);
jerry_value_t result = jerry_set_property_by_index(call_info_p->function, id, args[0]);
jerry_value_t result = jerry_object_set_index (call_info_p->function, id, args[0]);
if (jerry_value_is_error(result)) {
jerry_release_value(result);
mbed::js::EventLoop::getInstance().getQueue().cancel(id);
if (jerry_value_is_exception (result))
{
jerry_value_free (result);
mbed::js::EventLoop::getInstance ().getQueue ().cancel (id);
return jerry_create_error(JERRY_ERROR_TYPE, (const jerry_char_t *) "Failed to run setTimeout");
}
return jerry_throw_sz (JERRY_ERROR_TYPE, "Failed to run setTimeout");
}
jerry_release_value(result);
return jerry_create_number(id);
jerry_value_free (result);
return jerry_number (id);
}
/**
@ -52,22 +60,23 @@ DECLARE_GLOBAL_FUNCTION(setTimeout) {
*
* @param id ID of the timeout event, returned by setTimeout.
*/
DECLARE_GLOBAL_FUNCTION(clearTimeout) {
CHECK_ARGUMENT_COUNT(global, clearTimeout, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS(global, clearTimeout, 0, number);
DECLARE_GLOBAL_FUNCTION (clearTimeout)
{
CHECK_ARGUMENT_COUNT (global, clearTimeout, (args_count == 1));
CHECK_ARGUMENT_TYPE_ALWAYS (global, clearTimeout, 0, number);
int id = int(jerry_get_number_value(args[0]));
int id = int (jerry_value_as_number (args[0]));
mbed::js::EventLoop::getInstance().getQueue().cancel(id);
mbed::js::EventLoop::getInstance ().getQueue ().cancel (id);
jerry_value_t global_obj = jerry_get_global_object();
jerry_value_t prop_name = jerry_create_string((const jerry_char_t*)"setTimeout");
jerry_value_t func_obj = jerry_get_property(global_obj, prop_name);
jerry_release_value(prop_name);
jerry_value_t global_obj = jerry_current_realm ();
jerry_value_t prop_name = jerry_string_sz ("setTimeout");
jerry_value_t func_obj = jerry_object_get (global_obj, prop_name);
jerry_value_free (prop_name);
jerry_delete_property_by_index(func_obj, id);
jerry_release_value(func_obj);
jerry_release_value(global_obj);
jerry_object_delete_index (func_obj, id);
jerry_value_free (func_obj);
jerry_value_free (global_obj);
return jerry_create_undefined();
return jerry_undefined ();
}

2
targets/mbedos5/jerryscript-mbed/jerryscript-mbed-event-loop/EventLoop.h
View File

@ -73,7 +73,7 @@ class EventLoop {
}
void callback(jerry_value_t f) {
queue.call(jerry_call_function, f, jerry_create_null(), (const jerry_value_t*)NULL, 0);
queue.call(jerry_call, f, jerry_null(), (const jerry_value_t*)NULL, 0);
}
void nativeCallback(Callback<void()> cb) {

12
targets/mbedos5/jerryscript-mbed/jerryscript-mbed-launcher/source/launcher.cpp
View File

@ -44,24 +44,24 @@ static int load_javascript() {
jerry_value_t parsed_code = jerry_parse(code, length, NULL);
if (jerry_value_is_error(parsed_code)) {
if (jerry_value_is_exception(parsed_code)) {
LOG_PRINT_ALWAYS("jerry_parse failed [%s]\r\n", js_codes[src].name);
jerry_release_value(parsed_code);
jerry_value_free(parsed_code);
jsmbed_js_exit();
return -1;
}
jerry_value_t returned_value = jerry_run(parsed_code);
jerry_release_value(parsed_code);
jerry_value_free(parsed_code);
if (jerry_value_is_error(returned_value)) {
if (jerry_value_is_exception(returned_value)) {
LOG_PRINT_ALWAYS("jerry_run failed [%s]\r\n", js_codes[src].name);
jerry_release_value(returned_value);
jerry_value_free(returned_value);
jsmbed_js_exit();
return -1;
}
jerry_release_value(returned_value);
jerry_value_free(returned_value);
}
return 0;

45
targets/mbedos5/jerryscript-mbed/jerryscript-mbed-launcher/source/setup.cpp
View File

@ -12,38 +12,43 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdlib.h>
#include <stdio.h>
#include "jerryscript-mbed-launcher/setup.h"
#include <stdio.h>
#include <stdlib.h>
#include "jerryscript-mbed-util/logging.h"
extern uint32_t jsmbed_js_magic_string_count;
extern uint32_t jsmbed_js_magic_string_values[];
extern const jerry_char_t *jsmbed_js_magic_strings[];
extern const char *jsmbed_js_magic_strings[];
extern const jerry_length_t jsmbed_js_magic_string_lengths[];
void jsmbed_js_load_magic_strings() {
if (jsmbed_js_magic_string_count == 0) {
return;
}
void
jsmbed_js_load_magic_strings ()
{
if (jsmbed_js_magic_string_count == 0)
{
return;
}
jerry_register_magic_strings(jsmbed_js_magic_strings,
jsmbed_js_magic_string_count,
jsmbed_js_magic_string_lengths);
jerry_register_magic_strings ((const jerry_char_t **) jsmbed_js_magic_strings,
jsmbed_js_magic_string_count,
jsmbed_js_magic_string_lengths);
jerry_value_t global = jerry_get_global_object();
jerry_value_t global = jerry_current_realm ();
for (unsigned int idx = 0; idx < jsmbed_js_magic_string_count; idx++) {
jerry_value_t constant_value = jerry_create_number(jsmbed_js_magic_string_values[idx]);
jerry_value_t magic_string = jerry_create_string(jsmbed_js_magic_strings[idx]);
for (unsigned int idx = 0; idx < jsmbed_js_magic_string_count; idx++)
{
jerry_value_t constant_value = jerry_number (jsmbed_js_magic_string_values[idx]);
jerry_value_t magic_string = jerry_string_sz (jsmbed_js_magic_strings[idx]);
jerry_release_value(jerry_set_property(global, magic_string, constant_value));
jerry_value_free (jerry_object_set (global, magic_string, constant_value));
jerry_release_value(constant_value);
jerry_release_value(magic_string);
}
jerry_value_free (constant_value);
jerry_value_free (magic_string);
}
jerry_release_value(global);
jerry_value_free (global);
}

105
targets/mbedos5/jerryscript-mbed/jerryscript-mbed-library-registry/source/wrap_tools.cpp
View File

@ -12,66 +12,73 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <stdlib.h>
#include <stdio.h>
#include "jerryscript-mbed-library-registry/wrap_tools.h"
bool jsmbed_wrap_register_global_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);
#include <stdio.h>
#include <stdlib.h>
bool is_ok = true;
bool
jsmbed_wrap_register_global_function (const char* name, jerry_external_handler_t handler)
{
jerry_value_t global_object_val = jerry_current_realm ();
jerry_value_t reg_function = jerry_function_external (handler);
if (!(jerry_value_is_function(reg_function)
&& jerry_value_is_constructor(reg_function))) {
is_ok = false;
LOG_PRINT_ALWAYS("Error: jerry_create_external_function failed!\r\n");
jerry_release_value(global_object_val);
jerry_release_value(reg_function);
return is_ok;
}
if (jerry_value_is_error(reg_function)) {
is_ok = false;
LOG_PRINT_ALWAYS("Error: jerry_create_external_function has error flag! \r\n");
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_is_error(set_result)) {
is_ok = false;
LOG_PRINT_ALWAYS("Error: jerry_create_external_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);
bool is_ok = true;
if (!(jerry_value_is_function (reg_function) && jerry_value_is_constructor (reg_function)))
{
is_ok = false;
LOG_PRINT_ALWAYS ("Error: jerry_function_external failed!\r\n");
jerry_value_free (global_object_val);
jerry_value_free (reg_function);
return is_ok;
}
if (jerry_value_is_exception (reg_function))
{
is_ok = false;
LOG_PRINT_ALWAYS ("Error: jerry_function_external has error flag! \r\n");
jerry_value_free (global_object_val);
jerry_value_free (reg_function);
return is_ok;
}
jerry_value_t jerry_name = jerry_string_sz (name);
jerry_value_t set_result = jerry_object_set (global_object_val, jerry_name, reg_function);
if (jerry_value_is_exception (set_result))
{
is_ok = false;
LOG_PRINT_ALWAYS ("Error: jerry_function_external failed: [%s]\r\n", name);
}
jerry_value_free (jerry_name);
jerry_value_free (global_object_val);
jerry_value_free (reg_function);
jerry_value_free (set_result);
return is_ok;
}
bool jsmbed_wrap_register_class_constructor(const char* name, jerry_external_handler_t handler) {
// Register class constructor as a global function
return jsmbed_wrap_register_global_function(name, handler);
bool
jsmbed_wrap_register_class_constructor (const char* name, jerry_external_handler_t handler)
{
// Register class constructor as a global function
return jsmbed_wrap_register_global_function (name, handler);
}
bool jsmbed_wrap_register_class_function(jerry_value_t this_obj, const char* name, jerry_external_handler_t handler) {
jerry_value_t property_name = jerry_create_string(reinterpret_cast<const jerry_char_t *>(name));
jerry_value_t handler_obj = jerry_create_external_function(handler);
bool
jsmbed_wrap_register_class_function (jerry_value_t this_obj, const char* name, jerry_external_handler_t handler)
{
jerry_value_t property_name = jerry_string_sz (name);
jerry_value_t handler_obj = jerry_function_external (handler);
jerry_release_value(jerry_set_property(this_obj, property_name, handler_obj));
jerry_value_free (jerry_object_set (this_obj, property_name, handler_obj));
jerry_release_value(handler_obj);
jerry_release_value(property_name);
jerry_value_free (handler_obj);
jerry_value_free (property_name);
// TODO: check for errors, and return false in the case of errors
return true;
// TODO: check for errors, and return false in the case of errors
return true;
}

92
targets/mbedos5/jerryscript-mbed/jerryscript-mbed-util/wrappers.h
View File

@ -19,75 +19,73 @@
* Used in header/source files for wrappers, to declare the signature of the
* registration function.
*/
#define DECLARE_JS_WRAPPER_REGISTRATION(NAME) \
void jsmbed_wrap_registry_entry__ ## NAME (void)
#define DECLARE_JS_WRAPPER_REGISTRATION(NAME) void jsmbed_wrap_registry_entry__##NAME (void)
//
// 2. Wrapper function declaration/use macros
//
// Global functions
#define DECLARE_GLOBAL_FUNCTION(NAME) \
jerry_value_t \
NAME_FOR_GLOBAL_FUNCTION(NAME) (const jerry_call_info_t *call_info_p, \
const jerry_value_t args[], \
const jerry_length_t args_count)
#define DECLARE_GLOBAL_FUNCTION(NAME) \
jerry_value_t NAME_FOR_GLOBAL_FUNCTION ( \
NAME) (const jerry_call_info_t* call_info_p, const jerry_value_t args[], const jerry_length_t args_count)
#define REGISTER_GLOBAL_FUNCTION(NAME) \
jsmbed_wrap_register_global_function ( # NAME, NAME_FOR_GLOBAL_FUNCTION(NAME) )
#define REGISTER_GLOBAL_FUNCTION(NAME) jsmbed_wrap_register_global_function (#NAME, NAME_FOR_GLOBAL_FUNCTION (NAME))
#define REGISTER_GLOBAL_FUNCTION_WITH_HANDLER(NAME, HANDLER) \
jsmbed_wrap_register_global_function ( # NAME, HANDLER )
#define REGISTER_GLOBAL_FUNCTION_WITH_HANDLER(NAME, HANDLER) jsmbed_wrap_register_global_function (#NAME, HANDLER)
// Class constructors
#define DECLARE_CLASS_CONSTRUCTOR(CLASS) \
jerry_value_t \
NAME_FOR_CLASS_CONSTRUCTOR(CLASS) (const jerry_call_info_t *call_info_p, \
const jerry_value_t args[], \
const jerry_length_t args_count)
#define DECLARE_CLASS_CONSTRUCTOR(CLASS) \
jerry_value_t NAME_FOR_CLASS_CONSTRUCTOR ( \
CLASS) (const jerry_call_info_t* call_info_p, const jerry_value_t args[], const jerry_length_t args_count)
#define REGISTER_CLASS_CONSTRUCTOR(CLASS) \
jsmbed_wrap_register_class_constructor ( # CLASS, NAME_FOR_CLASS_CONSTRUCTOR(CLASS) )
jsmbed_wrap_register_class_constructor (#CLASS, NAME_FOR_CLASS_CONSTRUCTOR (CLASS))
// Class functions
#define DECLARE_CLASS_FUNCTION(CLASS, NAME) \
jerry_value_t \
NAME_FOR_CLASS_FUNCTION(CLASS, NAME) (const jerry_call_info_t *call_info_p, \
const jerry_value_t args[], \
const jerry_length_t args_count)
#define DECLARE_CLASS_FUNCTION(CLASS, NAME) \
jerry_value_t NAME_FOR_CLASS_FUNCTION (CLASS, NAME) (const jerry_call_info_t* call_info_p, \
const jerry_value_t args[], \
const jerry_length_t args_count)
#define ATTACH_CLASS_FUNCTION(OBJECT, CLASS, NAME) \
jsmbed_wrap_register_class_function (OBJECT, # NAME, NAME_FOR_CLASS_FUNCTION(CLASS, NAME) )
jsmbed_wrap_register_class_function (OBJECT, #NAME, NAME_FOR_CLASS_FUNCTION (CLASS, NAME))
//
// 3. Argument checking macros
//
#define CHECK_ARGUMENT_COUNT(CLASS, NAME, EXPR) \
if (!(EXPR)) { \
const char* error_msg = "ERROR: wrong argument count for " # CLASS "." # NAME ", expected " # EXPR "."; \
return jerry_create_error(JERRY_ERROR_TYPE, reinterpret_cast<const jerry_char_t*>(error_msg)); \
}
#define CHECK_ARGUMENT_COUNT(CLASS, NAME, EXPR) \
if (!(EXPR)) \
{ \
const char* error_msg = "ERROR: wrong argument count for " #CLASS "." #NAME ", expected " #EXPR "."; \
return jerry_throw_sz (JERRY_ERROR_TYPE, error_msg); \
}
#define CHECK_ARGUMENT_TYPE_ALWAYS(CLASS, NAME, INDEX, TYPE) \
if (!jerry_value_is_ ## TYPE (args[INDEX])) { \
const char* error_msg = "ERROR: wrong argument type for " # CLASS "." # NAME ", expected argument " # INDEX " to be a " # TYPE ".\n"; \
return jerry_create_error(JERRY_ERROR_TYPE, reinterpret_cast<const jerry_char_t*>(error_msg)); \
}
#define CHECK_ARGUMENT_TYPE_ALWAYS(CLASS, NAME, INDEX, TYPE) \
if (!jerry_value_is_##TYPE (args[INDEX])) \
{ \
const char* error_msg = \
"ERROR: wrong argument type for " #CLASS "." #NAME ", expected argument " #INDEX " to be a " #TYPE ".\n"; \
return jerry_throw_sz (JERRY_ERROR_TYPE, error_msg); \
}
#define CHECK_ARGUMENT_TYPE_ON_CONDITION(CLASS, NAME, INDEX, TYPE, EXPR) \
if ((EXPR)) { \
if (!jerry_value_is_ ## TYPE (args[INDEX])) { \
const char* error_msg = "ERROR: wrong argument type for " # CLASS "." # NAME ", expected argument " # INDEX " to be a " # TYPE ".\n"; \
return jerry_create_error(JERRY_ERROR_TYPE, reinterpret_cast<const jerry_char_t*>(error_msg)); \
} \
}
#define CHECK_ARGUMENT_TYPE_ON_CONDITION(CLASS, NAME, INDEX, TYPE, EXPR) \
if ((EXPR)) \
{ \
if (!jerry_value_is_##TYPE (args[INDEX])) \
{ \
const char* error_msg = \
"ERROR: wrong argument type for " #CLASS "." #NAME ", expected argument " #INDEX " to be a " #TYPE ".\n"; \
return jerry_throw_sz (JERRY_ERROR_TYPE, error_msg); \
} \
}
#define NAME_FOR_GLOBAL_FUNCTION(NAME) __gen_jsmbed_global_func_ ## NAME
#define NAME_FOR_CLASS_CONSTRUCTOR(CLASS) __gen_jsmbed_class_constructor_ ## CLASS
#define NAME_FOR_CLASS_FUNCTION(CLASS, NAME) __gen_jsmbed_func_c_ ## CLASS ## _f_ ## NAME
#define NAME_FOR_GLOBAL_FUNCTION(NAME) __gen_jsmbed_global_func_##NAME
#define NAME_FOR_CLASS_CONSTRUCTOR(CLASS) __gen_jsmbed_class_constructor_##CLASS
#define NAME_FOR_CLASS_FUNCTION(CLASS, NAME) __gen_jsmbed_func_c_##CLASS##_f_##NAME
#define NAME_FOR_CLASS_NATIVE_CONSTRUCTOR(CLASS, TYPELIST) __gen_native_jsmbed_ ## CLASS ## __Special_create_ ## TYPELIST
#define NAME_FOR_CLASS_NATIVE_DESTRUCTOR(CLASS) __gen_native_jsmbed_ ## CLASS ## __Special_destroy
#define NAME_FOR_CLASS_NATIVE_FUNCTION(CLASS, NAME) __gen_native_jsmbed_ ## CLASS ## _ ## NAME
#define NAME_FOR_CLASS_NATIVE_CONSTRUCTOR(CLASS, TYPELIST) __gen_native_jsmbed_##CLASS##__Special_create_##TYPELIST
#define NAME_FOR_CLASS_NATIVE_DESTRUCTOR(CLASS) __gen_native_jsmbed_##CLASS##__Special_destroy
#define NAME_FOR_CLASS_NATIVE_FUNCTION(CLASS, NAME) __gen_native_jsmbed_##CLASS##_##NAME
#endif // _JERRYSCRIPT_MBED_UTIL_WRAPPERS_H
#endif // _JERRYSCRIPT_MBED_UTIL_WRAPPERS_H

247
targets/nuttx-stm32f4/jerry_main.c
View File

@ -15,13 +15,14 @@
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <string.h>
#include "jerryscript-port.h"
#include "jerryscript.h"
#include "jerryscript-ext/debugger.h"
#include "jerryscript-ext/handler.h"
#include "jerryscript-port.h"
#include "setjmp.h"
/**
@ -111,7 +112,7 @@ read_file (const char *file_name, /**< source code */
if (!bytes_read || bytes_read != script_len)
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Error: failed to read file: %s\n", file_name);
free ((void*) buffer);
free ((void *) buffer);
fclose (file);
return NULL;
@ -132,7 +133,7 @@ static uint32_t
str_to_uint (const char *num_str_p, /**< string to convert */
char **out_p) /**< [out] end of the number */
{
assert (jerry_is_feature_enabled (JERRY_FEATURE_ERROR_MESSAGES));
assert (jerry_feature_enabled (JERRY_FEATURE_ERROR_MESSAGES));
uint32_t result = 0;
@ -157,124 +158,111 @@ str_to_uint (const char *num_str_p, /**< string to convert */
static void
print_unhandled_exception (jerry_value_t error_value) /**< error value */
{
assert (jerry_value_is_error (error_value));
assert (jerry_value_is_exception (error_value));
error_value = jerry_get_value_from_error (error_value, false);
error_value = jerry_exception_value (error_value, false);
jerry_value_t err_str_val = jerry_value_to_string (error_value);
jerry_size_t err_str_size = jerry_get_utf8_string_size (err_str_val);
jerry_char_t err_str_buf[256];
jerry_release_value (error_value);
jerry_value_free (error_value);
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_utf8_char_buffer (err_str_val, err_str_buf, err_str_size);
assert (sz == err_str_size);
err_str_buf[err_str_size] = 0;
jerry_size_t sz = jerry_string_to_buffer (err_str_val, JERRY_ENCODING_UTF8, err_str_buf, sizeof (err_str_buf) - 1);
err_str_buf[sz] = '\0';
if (jerry_is_feature_enabled (JERRY_FEATURE_ERROR_MESSAGES)
&& jerry_get_error_type (error_value) == JERRY_ERROR_SYNTAX)
if (jerry_feature_enabled (JERRY_FEATURE_ERROR_MESSAGES) && jerry_error_type (error_value) == JERRY_ERROR_SYNTAX)
{
jerry_char_t *string_end_p = err_str_buf + sz;
uint32_t err_line = 0;
uint32_t err_col = 0;
char *path_str_p = NULL;
char *path_str_end_p = NULL;
/* 1. parse column and line information */
for (jerry_char_t *current_p = err_str_buf; current_p < string_end_p; current_p++)
{
jerry_char_t *string_end_p = err_str_buf + sz;
uint32_t err_line = 0;
uint32_t err_col = 0;
char *path_str_p = NULL;
char *path_str_end_p = NULL;
/* 1. parse column and line information */
for (jerry_char_t *current_p = err_str_buf; current_p < string_end_p; current_p++)
if (*current_p == '[')
{
if (*current_p == '[')
current_p++;
if (*current_p == '<')
{
current_p++;
if (*current_p == '<')
{
break;
}
path_str_p = (char *) current_p;
while (current_p < string_end_p && *current_p != ':')
{
current_p++;
}
path_str_end_p = (char *) current_p++;
err_line = str_to_uint ((char *) current_p, (char **) &current_p);
current_p++;
err_col = str_to_uint ((char *) current_p, NULL);
break;
}
} /* for */
if (err_line != 0 && err_col != 0)
{
uint32_t curr_line = 1;
bool is_printing_context = false;
uint32_t pos = 0;
/* Temporarily modify the error message, so we can use the path. */
*path_str_end_p = '\0';
size_t source_size;
const jerry_char_t *source_p = read_file (path_str_p, &source_size);
/* Revert the error message. */
*path_str_end_p = ':';
/* 2. seek and print */
while (source_p[pos] != '\0')
path_str_p = (char *) current_p;
while (current_p < string_end_p && *current_p != ':')
{
if (source_p[pos] == '\n')
{
curr_line++;
}
if (err_line < SYNTAX_ERROR_CONTEXT_SIZE
|| (err_line >= curr_line
&& (err_line - curr_line) <= SYNTAX_ERROR_CONTEXT_SIZE))
{
/* context must be printed */
is_printing_context = true;
}
if (curr_line > err_line)
{
break;
}
if (is_printing_context)
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "%c", source_p[pos]);
}
pos++;
current_p++;
}
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "\n");
path_str_end_p = (char *) current_p++;
while (--err_col)
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "~");
}
err_line = str_to_uint ((char *) current_p, (char **) &current_p);
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "^\n");
current_p++;
err_col = str_to_uint ((char *) current_p, NULL);
break;
}
} /* for */
if (err_line != 0 && err_col != 0)
{
uint32_t curr_line = 1;
bool is_printing_context = false;
uint32_t pos = 0;
/* Temporarily modify the error message, so we can use the path. */
*path_str_end_p = '\0';
size_t source_size;
const jerry_char_t *source_p = read_file (path_str_p, &source_size);
/* Revert the error message. */
*path_str_end_p = ':';
/* 2. seek and print */
while (source_p[pos] != '\0')
{
if (source_p[pos] == '\n')
{
curr_line++;
}
if (err_line < SYNTAX_ERROR_CONTEXT_SIZE
|| (err_line >= curr_line && (err_line - curr_line) <= SYNTAX_ERROR_CONTEXT_SIZE))
{
/* context must be printed */
is_printing_context = true;
}
if (curr_line > err_line)
{
break;
}
if (is_printing_context)
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "%c", source_p[pos]);
}
pos++;
}
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "\n");
while (--err_col)
{
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "~");
}
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "^\n");
}
}
jerry_port_log (JERRY_LOG_LEVEL_ERROR, "Script Error: %s\n", err_str_buf);
jerry_release_value (err_str_val);
jerry_value_free (err_str_val);
} /* print_unhandled_exception */
/**
@ -284,26 +272,27 @@ 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);
jerry_value_t result_val = jerryx_handler_register_global (name_p, handler_p);
if (jerry_value_is_error (result_val))
if (jerry_value_is_exception (result_val))
{
jerry_port_log (JERRY_LOG_LEVEL_WARNING, "Warning: failed to register '%s' method.", name_p);
}
jerry_release_value (result_val);
jerry_value_free (result_val);
} /* register_js_function */
/**
* Main program.
*
* @return 0 if success, error code otherwise
*/
#ifdef CONFIG_BUILD_KERNEL
int main (int argc, FAR char *argv[])
int
main (int argc, FAR char *argv[])
#else /* !defined(CONFIG_BUILD_KERNEL) */
int jerry_main (int argc, char *argv[])
int
jerry_main (int argc, char *argv[])
#endif /* defined(CONFIG_BUILD_KERNEL) */
{
if (argc > JERRY_MAX_COMMAND_LINE_ARGS)
@ -335,11 +324,6 @@ int jerry_main (int argc, char *argv[])
flags |= JERRY_INIT_MEM_STATS;
set_log_level (JERRY_LOG_LEVEL_DEBUG);
}
else if (!strcmp ("--mem-stats-separate", argv[i]))
{
flags |= JERRY_INIT_MEM_STATS_SEPARATE;
set_log_level (JERRY_LOG_LEVEL_DEBUG);
}
else if (!strcmp ("--show-opcodes", argv[i]))
{
flags |= JERRY_INIT_SHOW_OPCODES | JERRY_INIT_SHOW_REGEXP_OPCODES;
@ -347,7 +331,7 @@ int jerry_main (int argc, char *argv[])
}
else if (!strcmp ("--log-level", argv[i]))
{
if (++i < argc && strlen (argv[i]) == 1 && argv[i][0] >='0' && argv[i][0] <= '3')
if (++i < argc && strlen (argv[i]) == 1 && argv[i][0] >= '0' && argv[i][0] <= '3')
{
set_log_level (argv[i][0] - '0');
}
@ -383,15 +367,14 @@ int jerry_main (int argc, char *argv[])
if (start_debug_server)
{
jerryx_debugger_after_connect (jerryx_debugger_tcp_create (debug_port)
&& jerryx_debugger_ws_create ());
jerryx_debugger_after_connect (jerryx_debugger_tcp_create (debug_port) && jerryx_debugger_ws_create ());
}
register_js_function ("assert", jerryx_handler_assert);
register_js_function ("gc", jerryx_handler_gc);
register_js_function ("print", jerryx_handler_print);
jerry_value_t ret_value = jerry_create_undefined ();
jerry_value_t ret_value = jerry_undefined ();
if (files_counter == 0)
{
@ -400,7 +383,7 @@ int jerry_main (int argc, char *argv[])
ret_value = jerry_parse (script, sizeof (script) - 1, NULL);
if (!jerry_value_is_error (ret_value))
if (!jerry_value_is_exception (ret_value))
{
ret_value = jerry_run (ret_value);
}
@ -419,50 +402,48 @@ int jerry_main (int argc, char *argv[])
}
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name = jerry_create_string ((const jerry_char_t *) file_names[i]);
parse_options.options = JERRY_PARSE_HAS_SOURCE_NAME;
parse_options.source_name = jerry_string_sz (file_names[i]);
ret_value = jerry_parse (source_p,
source_size,
&parse_options);
jerry_release_value (parse_options.resource_name);
free ((void*) source_p);
ret_value = jerry_parse (source_p, source_size, &parse_options);
jerry_value_free (parse_options.source_name);
free ((void *) source_p);
if (!jerry_value_is_error (ret_value))
if (!jerry_value_is_exception (ret_value))
{
jerry_value_t func_val = ret_value;
ret_value = jerry_run (func_val);
jerry_release_value (func_val);
jerry_value_free (func_val);
}
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
print_unhandled_exception (ret_value);
break;
}
jerry_release_value (ret_value);
ret_value = jerry_create_undefined ();
jerry_value_free (ret_value);
ret_value = jerry_undefined ();
}
}
int ret_code = JERRY_STANDALONE_EXIT_CODE_OK;
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
ret_code = JERRY_STANDALONE_EXIT_CODE_FAIL;
}
jerry_release_value (ret_value);
jerry_value_free (ret_value);
ret_value = jerry_run_all_enqueued_jobs ();
ret_value = jerry_run_jobs ();
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
ret_code = JERRY_STANDALONE_EXIT_CODE_FAIL;
}
jerry_release_value (ret_value);
jerry_value_free (ret_value);
jerry_cleanup ();
return ret_code;

74
targets/nuttx-stm32f4/jerry_module.c
View File

@ -14,12 +14,12 @@
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "jerryscript.h"
#include "jerryscript-port.h"
#include "jerryscript.h"
/**
* Computes the end of the directory part of a path.
@ -102,8 +102,7 @@ typedef struct jerry_port_module_t
/**
* Native info descriptor for modules.
*/
static const jerry_object_native_info_t jerry_port_module_native_info =
{
static const jerry_object_native_info_t jerry_port_module_native_info = {
.free_cb = NULL,
};
@ -136,8 +135,8 @@ jerry_port_module_free (jerry_port_module_manager_t *manager_p, /**< module mana
if (release_all || module_p->realm == realm)
{
free (module_p->path_p);
jerry_release_value (module_p->realm);
jerry_release_value (module_p->module);
jerry_value_free (module_p->realm);
jerry_value_free (module_p->module);
free (module_p);
@ -174,20 +173,18 @@ jerry_port_module_manager_init (void *user_data_p)
static void
jerry_port_module_manager_deinit (void *user_data_p) /**< context pointer to deinitialize */
{
jerry_value_t undef = jerry_create_undefined ();
jerry_value_t undef = jerry_undefined ();
jerry_port_module_free ((jerry_port_module_manager_t *) user_data_p, undef);
jerry_release_value (undef);
jerry_value_free (undef);
} /* jerry_port_module_manager_deinit */
/**
* Declare the context data manager for modules.
*/
static const jerry_context_data_manager_t jerry_port_module_manager =
{
.init_cb = jerry_port_module_manager_init,
.deinit_cb = jerry_port_module_manager_deinit,
.bytes_needed = sizeof (jerry_port_module_manager_t)
};
static const jerry_context_data_manager_t jerry_port_module_manager = { .init_cb = jerry_port_module_manager_init,
.deinit_cb = jerry_port_module_manager_deinit,
.bytes_needed =
sizeof (jerry_port_module_manager_t) };
/**
* Default module resolver.
@ -201,44 +198,43 @@ jerry_port_module_resolve (const jerry_value_t specifier, /**< module specifier
{
(void) user_p;
jerry_port_module_t *module_p;
const jerry_char_t *base_path_p = NULL;
size_t base_path_length = 0;
jerry_port_module_t *module_p = jerry_object_get_native_ptr (referrer, &jerry_port_module_native_info);
if (jerry_get_object_native_pointer (referrer, (void **) &module_p, &jerry_port_module_native_info))
if (module_p != NULL)
{
base_path_p = module_p->path_p;
base_path_length = module_p->base_path_length;
}
jerry_size_t in_path_length = jerry_get_utf8_string_size (specifier);
jerry_size_t in_path_length = jerry_string_size (specifier, JERRY_ENCODING_UTF8);
jerry_char_t *in_path_p = (jerry_char_t *) malloc (in_path_length + 1);
jerry_string_to_utf8_char_buffer (specifier, in_path_p, in_path_length);
jerry_string_to_buffer (specifier, JERRY_ENCODING_UTF8, in_path_p, in_path_length);
in_path_p[in_path_length] = '\0';
jerry_char_t *path_p = jerry_port_normalize_path (in_path_p, in_path_length, base_path_p, base_path_length);
if (path_p == NULL)
{
return jerry_create_error (JERRY_ERROR_COMMON, (const jerry_char_t *) "Out of memory");
return jerry_throw_sz (JERRY_ERROR_COMMON, "Out of memory");
}
jerry_value_t realm = jerry_get_global_object ();
jerry_value_t realm = jerry_current_realm ();
jerry_port_module_manager_t *manager_p;
manager_p = (jerry_port_module_manager_t *) jerry_get_context_data (&jerry_port_module_manager);
manager_p = (jerry_port_module_manager_t *) jerry_context_data (&jerry_port_module_manager);
module_p = manager_p->module_head_p;
while (module_p != NULL)
{
if (module_p->realm == realm
&& strcmp ((const char *) module_p->path_p, (const char *) path_p) == 0)
if (module_p->realm == realm && strcmp ((const char *) module_p->path_p, (const char *) path_p) == 0)
{
free (path_p);
free (in_path_p);
jerry_release_value (realm);
return jerry_acquire_value (module_p->module);
jerry_value_free (realm);
return jerry_value_copy (module_p->module);
}
module_p = module_p->next_p;
@ -251,28 +247,25 @@ jerry_port_module_resolve (const jerry_value_t specifier, /**< module specifier
{
free (path_p);
free (in_path_p);
jerry_release_value (realm);
/* TODO: This is incorrect, but makes test262 module tests pass
* (they should throw SyntaxError, but not because the module cannot be found). */
return jerry_create_error (JERRY_ERROR_SYNTAX, (const jerry_char_t *) "Module file not found");
jerry_value_free (realm);
return jerry_throw_sz (JERRY_ERROR_SYNTAX, "Module file not found");
}
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_MODULE | JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name = jerry_create_string_sz ((const jerry_char_t *) in_path_p, in_path_length);
parse_options.options = JERRY_PARSE_MODULE | JERRY_PARSE_HAS_SOURCE_NAME;
parse_options.source_name = jerry_string (in_path_p, in_path_length, JERRY_ENCODING_UTF8);
jerry_value_t ret_value = jerry_parse (source_p,
source_size,
&parse_options);
jerry_value_t ret_value = jerry_parse (source_p, source_size, &parse_options);
jerry_release_value (parse_options.resource_name);
jerry_value_free (parse_options.source_name);
jerry_port_release_source (source_p);
free (in_path_p);
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
free (path_p);
jerry_release_value (realm);
jerry_value_free (realm);
return ret_value;
}
@ -282,9 +275,9 @@ jerry_port_module_resolve (const jerry_value_t specifier, /**< module specifier
module_p->path_p = path_p;
module_p->base_path_length = jerry_port_get_directory_end (module_p->path_p);
module_p->realm = realm;
module_p->module = jerry_acquire_value (ret_value);
module_p->module = jerry_value_copy (ret_value);
jerry_set_object_native_pointer (ret_value, module_p, &jerry_port_module_native_info);
jerry_object_set_native_ptr (ret_value, &jerry_port_module_native_info, module_p);
manager_p->module_head_p = module_p;
return ret_value;
@ -297,6 +290,5 @@ void
jerry_port_module_release (const jerry_value_t realm) /**< if this argument is object, release only those modules,
* which realm value is equal to this argument. */
{
jerry_port_module_free ((jerry_port_module_manager_t *) jerry_get_context_data (&jerry_port_module_manager),
realm);
jerry_port_module_free ((jerry_port_module_manager_t *) jerry_context_data (&jerry_port_module_manager), realm);
} /* jerry_port_module_release */

48
targets/particle/source/main.cpp
View File

@ -30,16 +30,16 @@ set_led (const jerry_value_t func_value, /**< function object */
if (args_cnt != 2)
{
Serial.println ("Wrong arguments count in 'test.setLed' function.");
return jerry_create_boolean (false);
return jerry_boolean (false);
}
int ledPin = jerry_get_number_value (args_p[0]);
int ledPin = jerry_value_as_number (args_p[0]);
bool value = jerry_value_is_true (args_p[1]);
pinMode (ledPin, OUTPUT);
digitalWrite (ledPin, value);
return jerry_create_boolean (true);
return jerry_boolean (true);
} /* set_led */
/**
@ -54,14 +54,14 @@ js_delay (const jerry_value_t func_value, /**< function object */
if (args_cnt != 1)
{
Serial.println ("Wrong arguments count in 'test.delay' function.");
return jerry_create_boolean (false);
return jerry_boolean (false);
}
int millisec = jerry_get_number_value (args_p[0]);
int millisec = jerry_value_as_number (args_p[0]);
delay (millisec);
return jerry_create_boolean (true);
return jerry_boolean (true);
} /* js_delay */
/*
@ -73,32 +73,32 @@ init_jerry ()
jerry_init (JERRY_INIT_EMPTY);
/* Create an empty JS object */
jerry_value_t object = jerry_create_object ();
jerry_value_t object = jerry_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_release_value (jerry_set_property (object, prop_name, func_obj));
jerry_release_value (prop_name);
jerry_release_value (func_obj);
func_obj = jerry_function_external (set_led);
prop_name = jerry_string_sz ("setLed");
jerry_value_free (jerry_object_set (object, prop_name, func_obj));
jerry_value_free (prop_name);
jerry_value_free (func_obj);
func_obj = jerry_create_external_function (js_delay);
prop_name = jerry_create_string ((const jerry_char_t *) "delay");
jerry_release_value (jerry_set_property (object, prop_name, func_obj));
jerry_release_value (prop_name);
jerry_release_value (func_obj);
func_obj = jerry_function_external (js_delay);
prop_name = jerry_string_sz ("delay");
jerry_value_free (jerry_object_set (object, prop_name, func_obj));
jerry_value_free (prop_name);
jerry_value_free (func_obj);
/* Wrap the JS object (not empty anymore) into a jerry api value */
jerry_value_t global_object = jerry_get_global_object ();
jerry_value_t global_object = jerry_current_realm ();
/* Add the JS object to the global context */
prop_name = jerry_create_string ((const jerry_char_t *) "test");
jerry_release_value (jerry_set_property (global_object, prop_name, object));
jerry_release_value (prop_name);
jerry_release_value (object);
jerry_release_value (global_object);
prop_name = jerry_string_sz ("test");
jerry_value_free (jerry_object_set (global_object, prop_name, object));
jerry_value_free (prop_name);
jerry_value_free (object);
jerry_value_free (global_object);
} /* init_jerry */
/**
@ -117,7 +117,7 @@ test_jerry ()
jerry_value_t eval_ret = jerry_eval (script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
/* Free JavaScript value, returned by eval */
jerry_release_value (eval_ret);
jerry_value_free (eval_ret);
} /* test_jerry */
/**

40
targets/riot-stm32f4/source/main-riotos.c
View File

@ -16,10 +16,12 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "shell.h"
#include "jerryscript.h"
#include "jerryscript-ext/handler.h"
#include "jerryscript-port.h"
#include "jerryscript.h"
#include "jerryscript-ext/handler.h"
#include "shell.h"
/**
* Standalone Jerry exit codes
@ -34,26 +36,27 @@ 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);
jerry_value_t result_val = jerryx_handler_register_global (name_p, handler_p);
if (jerry_value_is_error (result_val))
if (jerry_value_is_exception (result_val))
{
printf ("Warning: failed to register '%s' method.", name_p);
}
jerry_release_value (result_val);
jerry_value_free (result_val);
} /* register_js_function */
/**
* Jerryscript simple test
*/
int test_jerry (int argc, char **argv)
int
test_jerry (int argc, char **argv)
{
/* Suppress compiler errors */
(void) argc;
(void) argv;
jerry_value_t ret_value = jerry_create_undefined ();
jerry_value_t ret_value = jerry_undefined ();
const jerry_char_t script[] = "print ('Hello, World!');";
printf ("This test run the following script code: [%s]\n\n", script);
@ -67,7 +70,7 @@ int test_jerry (int argc, char **argv)
/* Setup Global scope code */
ret_value = jerry_parse (script, sizeof (script) - 1, NULL);
if (!jerry_value_is_error (ret_value))
if (!jerry_value_is_exception (ret_value))
{
/* Execute the parsed source code in the Global scope */
ret_value = jerry_run (ret_value);
@ -75,14 +78,14 @@ int test_jerry (int argc, char **argv)
int ret_code = JERRY_STANDALONE_EXIT_CODE_OK;
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
printf ("Script Error!");
ret_code = JERRY_STANDALONE_EXIT_CODE_FAIL;
}
jerry_release_value (ret_value);
jerry_value_free (ret_value);
/* Cleanup engine */
jerry_cleanup ();
@ -91,14 +94,17 @@ int test_jerry (int argc, char **argv)
} /* test_jerry */
const shell_command_t shell_commands[] = {
{ "test", "Jerryscript Hello World test", test_jerry },
{ NULL, NULL, NULL }
};
const shell_command_t shell_commands[] = { { "test", "Jerryscript Hello World test", test_jerry },
{ NULL, NULL, NULL } };
int main (void)
int
main (void)
{
union { double d; unsigned u; } now = { .d = jerry_port_get_current_time () };
union
{
double d;
unsigned u;
} now = { .d = jerry_port_get_current_time () };
srand (now.u);
printf ("You are running RIOT on a(n) %s board.\n", RIOT_BOARD);
printf ("This board features a(n) %s MCU.\n", RIOT_MCU);

73
targets/zephyr/src/jerry-module.c
View File

@ -14,12 +14,12 @@
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include "jerryscript.h"
#include "jerryscript-port.h"
#include "jerryscript.h"
/**
* Computes the end of the directory part of a path.
@ -102,8 +102,7 @@ typedef struct jerry_port_module_t
/**
* Native info descriptor for modules.
*/
static const jerry_object_native_info_t jerry_port_module_native_info =
{
static const jerry_object_native_info_t jerry_port_module_native_info = {
.free_cb = NULL,
};
@ -136,8 +135,8 @@ jerry_port_module_free (jerry_port_module_manager_t *manager_p, /**< module mana
if (release_all || module_p->realm == realm)
{
free (module_p->path_p);
jerry_release_value (module_p->realm);
jerry_release_value (module_p->module);
jerry_value_free (module_p->realm);
jerry_value_free (module_p->module);
free (module_p);
@ -174,20 +173,18 @@ jerry_port_module_manager_init (void *user_data_p)
static void
jerry_port_module_manager_deinit (void *user_data_p) /**< context pointer to deinitialize */
{
jerry_value_t undef = jerry_create_undefined ();
jerry_value_t undef = jerry_undefined ();
jerry_port_module_free ((jerry_port_module_manager_t *) user_data_p, undef);
jerry_release_value (undef);
jerry_value_free (undef);
} /* jerry_port_module_manager_deinit */
/**
* Declare the context data manager for modules.
*/
static const jerry_context_data_manager_t jerry_port_module_manager =
{
.init_cb = jerry_port_module_manager_init,
.deinit_cb = jerry_port_module_manager_deinit,
.bytes_needed = sizeof (jerry_port_module_manager_t)
};
static const jerry_context_data_manager_t jerry_port_module_manager = { .init_cb = jerry_port_module_manager_init,
.deinit_cb = jerry_port_module_manager_deinit,
.bytes_needed =
sizeof (jerry_port_module_manager_t) };
/**
* Default module resolver.
@ -201,44 +198,43 @@ jerry_port_module_resolve (const jerry_value_t specifier, /**< module specifier
{
(void) user_p;
jerry_port_module_t *module_p;
jerry_port_module_t *module_p = jerry_object_get_native_ptr (referrer, &jerry_port_module_native_info);
const jerry_char_t *base_path_p = NULL;
size_t base_path_length = 0;
if (jerry_get_object_native_pointer (referrer, (void **) &module_p, &jerry_port_module_native_info))
if (module_p != NULL)
{
base_path_p = module_p->path_p;
base_path_length = module_p->base_path_length;
}
jerry_size_t in_path_length = jerry_get_utf8_string_size (specifier);
jerry_size_t in_path_length = jerry_string_size (specifier, JERRY_ENCODING_UTF8);
jerry_char_t *in_path_p = (jerry_char_t *) malloc (in_path_length + 1);
jerry_string_to_utf8_char_buffer (specifier, in_path_p, in_path_length);
jerry_string_to_buffer (specifier, JERRY_ENCODING_UTF8, in_path_p, in_path_length);
in_path_p[in_path_length] = '\0';
jerry_char_t *path_p = jerry_port_normalize_path (in_path_p, in_path_length, base_path_p, base_path_length);
if (path_p == NULL)
{
return jerry_create_error (JERRY_ERROR_COMMON, (const jerry_char_t *) "Out of memory");
return jerry_throw_sz (JERRY_ERROR_COMMON, "Out of memory");
}
jerry_value_t realm = jerry_get_global_object ();
jerry_value_t realm = jerry_current_realm ();
jerry_port_module_manager_t *manager_p;
manager_p = (jerry_port_module_manager_t *) jerry_get_context_data (&jerry_port_module_manager);
manager_p = (jerry_port_module_manager_t *) jerry_context_data (&jerry_port_module_manager);
module_p = manager_p->module_head_p;
while (module_p != NULL)
{
if (module_p->realm == realm
&& strcmp ((const char *) module_p->path_p, (const char *) path_p) == 0)
if (module_p->realm == realm && strcmp ((const char *) module_p->path_p, (const char *) path_p) == 0)
{
free (path_p);
free (in_path_p);
jerry_release_value (realm);
return jerry_acquire_value (module_p->module);
jerry_value_free (realm);
return jerry_value_copy (module_p->module);
}
module_p = module_p->next_p;
@ -251,28 +247,24 @@ jerry_port_module_resolve (const jerry_value_t specifier, /**< module specifier
{
free (path_p);
free (in_path_p);
jerry_release_value (realm);
/* TODO: This is incorrect, but makes test262 module tests pass
* (they should throw SyntaxError, but not because the module cannot be found). */
return jerry_create_error (JERRY_ERROR_SYNTAX, (const jerry_char_t *) "Module file not found");
jerry_value_free (realm);
return jerry_throw_sz (JERRY_ERROR_SYNTAX, "Module file not found");
}
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_MODULE | JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name = jerry_create_string_sz ((const jerry_char_t *) in_path_p, in_path_length);
parse_options.options = JERRY_PARSE_MODULE | JERRY_PARSE_HAS_SOURCE_NAME;
parse_options.source_name = jerry_string ((const jerry_char_t *) in_path_p, in_path_length, JERRY_ENCODING_UTF8);
jerry_value_t ret_value = jerry_parse (source_p,
source_size,
&parse_options);
jerry_value_t ret_value = jerry_parse (source_p, source_size, &parse_options);
jerry_release_value (parse_options.resource_name);
jerry_value_free (parse_options.source_name);
jerry_port_release_source (source_p);
free (in_path_p);
if (jerry_value_is_error (ret_value))
if (jerry_value_is_exception (ret_value))
{
free (path_p);
jerry_release_value (realm);
jerry_value_free (realm);
return ret_value;
}
@ -282,9 +274,9 @@ jerry_port_module_resolve (const jerry_value_t specifier, /**< module specifier
module_p->path_p = path_p;
module_p->base_path_length = jerry_port_get_directory_end (module_p->path_p);
module_p->realm = realm;
module_p->module = jerry_acquire_value (ret_value);
module_p->module = jerry_value_copy (ret_value);
jerry_set_object_native_pointer (ret_value, module_p, &jerry_port_module_native_info);
jerry_object_set_native_ptr (ret_value, &jerry_port_module_native_info, module_p);
manager_p->module_head_p = module_p;
return ret_value;
@ -297,6 +289,5 @@ void
jerry_port_module_release (const jerry_value_t realm) /**< if this argument is object, release only those modules,
* which realm value is equal to this argument. */
{
jerry_port_module_free ((jerry_port_module_manager_t *) jerry_get_context_data (&jerry_port_module_manager),
realm);
jerry_port_module_free ((jerry_port_module_manager_t *) jerry_context_data (&jerry_port_module_manager), realm);
} /* jerry_port_module_release */

70
targets/zephyr/src/main-zephyr.c
View File

@ -14,16 +14,16 @@
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <string.h>
#include <zephyr.h>
#include <sys/printk.h>
#include "getline-zephyr.h"
#include "jerryscript.h"
#include "jerryscript-port.h"
#include "jerryscript.h"
#include "getline-zephyr.h"
#include "jerryscript-ext/handler.h"
#include <sys/printk.h>
static jerry_value_t print_function;
@ -34,25 +34,24 @@ 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);
jerry_value_t result_val = jerryx_handler_register_global (name_p, handler_p);
if (jerry_value_is_error (result_val))
if (jerry_value_is_exception (result_val))
{
jerry_port_log (JERRY_LOG_LEVEL_WARNING, "Warning: failed to register '%s' method.", name_p);
}
jerry_release_value (result_val);
jerry_value_free (result_val);
} /* register_js_function */
static int shell_cmd_handler (char *source_buffer)
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),
JERRY_PARSE_NO_OPTS);
ret_val = jerry_eval ((jerry_char_t *) source_buffer, strlen (source_buffer), JERRY_PARSE_NO_OPTS);
if (jerry_value_is_error (ret_val))
if (jerry_value_is_exception (ret_val))
{
/* User-friendly error messages require at least "cp" JerryScript
profile. Include a message prefix in case "cp_minimal" profile
@ -60,44 +59,47 @@ static int shell_cmd_handler (char *source_buffer)
printf ("Error executing statement: ");
/* Clear error flag, otherwise print call below won't produce any
output. */
ret_val = jerry_get_value_from_error (ret_val, true);
ret_val = jerry_exception_value (ret_val, true);
}
if (!jerry_value_is_error (print_function))
if (!jerry_value_is_exception (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_value_t ret_val_print = jerry_call (print_function, jerry_undefined (), &ret_val, 1);
jerry_value_free (ret_val_print);
}
jerry_release_value (ret_val);
jerry_value_free (ret_val);
return 0;
} /* shell_cmd_handler */
void main (void)
void
main (void)
{
union { double d; unsigned u; } now = { .d = jerry_port_get_current_time () };
union
{
double d;
unsigned u;
} now = { .d = jerry_port_get_current_time () };
srand (now.u);
uint32_t zephyr_ver = sys_kernel_version_get ();
printf ("JerryScript build: " __DATE__ " " __TIME__ "\n");
printf ("JerryScript API %d.%d.%d\n", JERRY_API_MAJOR_VERSION, JERRY_API_MINOR_VERSION, JERRY_API_PATCH_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));
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);
register_js_function ("print", jerryx_handler_print);
jerry_value_t global_obj_val = jerry_get_global_object ();
jerry_value_t global_obj_val = jerry_current_realm ();
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_is_error (print_function))
jerry_value_t print_func_name_val = jerry_string_sz ("print");
print_function = jerry_object_get (global_obj_val, print_func_name_val);
jerry_value_free (print_func_name_val);
jerry_value_free (global_obj_val);
if (jerry_value_is_exception (print_function))
{
printf ("Error: could not look up print function, expression results won't be printed\n");
}
@ -105,8 +107,8 @@ void main (void)
while (1)
{
char *s;
printf("js> ");
fflush(stdout);
printf ("js> ");
fflush (stdout);
s = zephyr_getline ();
if (*s)
{

Some files were not shown because too many files have changed in this diff Show More