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

Add custom configuration to jerry_parse and its variants (#4620)

Browse Source 
JerryScript-DCO-1.0-Signed-off-by: Zoltan Herczeg zherczeg.u-szeged@partner.samsung.com
This commit is contained in:
Zoltan Herczeg 2021-03-10 09:56:48 +01:00 committed by GitHub
parent 7a2665621b
commit 546422161e
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
45 changed files with 658 additions and 596 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -229,18 +229,21 @@ RegExp object optional flags:
*Changed in version 2.4*: Added `JERRY_REGEXP_FLAG_STICKY`, `JERRY_REGEXP_FLAG_UNICODE` , `JERRY_REGEXP_FLAG_DOTALL` values.
## jerry_parse_opts_t
## jerry_parse_option_enable_feature_t
Option bits for [jerry_parse](#jerry_parse) and
[jerry_parse_function](#jerry_parse_function) functions:
Option bits for [jerry_parse_options_t](#jerry_parse_options_t).
- JERRY_PARSE_NO_OPTS - no options passed
- JERRY_PARSE_STRICT_MODE - enable strict mode
- JERRY_PARSE_MODULE - parse source as an ECMAScript module
- JERRY_PARSE_NO_OPTS - No options passed
- JERRY_PARSE_STRICT_MODE - Enable strict mode
- JERRY_PARSE_MODULE - Parse source as an ECMAScript module
- JERRY_PARSE_HAS_RESOURCE - `resource_name_p` and `resource_name_length` fields are valid
- JERRY_PARSE_HAS_START - `start_line` and `start_column` fields are valid
*New in version 2.0*.
*New in version [[NEXT_RELEASE]]*.
*Changed in version 2.4: Added `JERRY_PARSE_MODULE`.*
**See also**
- [jerry_parse_options_t](#jerry_parse_options_t)
## jerry_gc_mode_t
@ -271,7 +274,6 @@ Flags for [jerry_generate_snapshot](#jerry_generate_snapshot) and
[jerry_generate_function_snapshot](#jerry_generate_function_snapshot) functions:
- JERRY_SNAPSHOT_SAVE_STATIC - generate static snapshot (see below)
- JERRY_SNAPSHOT_SAVE_STRICT - strict source code provided
**Generate static snapshots**
Snapshots contain literal pools, and these literal pools contain references
@ -294,6 +296,7 @@ when the snapshot is generated and executed. Furthermore the
`JERRY_SNAPSHOT_EXEC_COPY_DATA` option is not allowed.
*New in version 2.0*.
*Changed in version [[NEXT_RELEASE]]*: The `JERRY_SNAPSHOT_SAVE_STRICT` value is removed, `JERRY_PARSE_STRICT_MODE` should be used instead.
## jerry_exec_snapshot_opts_t
@ -506,6 +509,38 @@ Enum that contains the flags of property descriptors.
- [jerry_property_descriptor_t](#jerry_property_descriptor_t)
## jerry_parse_options_t
**Summary**
Various configuration options for parsing functions such as [jerry_parse](#jerry_parse)
or [jerry_parse_function](#jerry_parse_function)
**Prototype**
```c
typedef struct
{
uint32_t options; /**< combination of jerry_parse_option_enable_feature_t values */
const jerry_char_t *resource_name_p; /**< resource name (usually a file name)
* if JERRY_PARSE_HAS_RESOURCE is set in options */
size_t resource_name_length; /**< length of resource name
* if JERRY_PARSE_HAS_RESOURCE is set in options */
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_parse_options_t;
```
*New in version [[NEXT_RELEASE]]*.
**See also**
- [jerry_parse](#jerry_parse)
- [jerry_parse_function](#jerry_parse_function)
- [jerry_generate_snapshot](#jerry_generate_snapshot)
- [jerry_generate_function_snapshot](#jerry_generate_function_snapshot)
- [jerry_parse_option_enable_feature_t](#jerry_parse_option_enable_feature_t)
## jerry_property_descriptor_t
**Summary**
@ -1408,23 +1443,20 @@ is no longer needed.
```c
jerry_value_t
jerry_parse (const jerry_char_t *resource_name_p, /**< resource name (usually a file name) */
size_t resource_name_length, /**< length of resource name */
const jerry_char_t *source_p,
jerry_parse (const jerry_char_t *source_p,
size_t source_size,
uint32_t parse_opts);
const jerry_parse_options_t *options_p);
```
- `resource_name_p` - resource name, usually a file name (must be a valid UTF8 string).
- `resource_name_length` - size of the resource name, in bytes.
- `source_p` - string, containing source code to parse (must be a valid UTF8 string).
- `source_size` - size of the string, in bytes.
- `parse_opts` - any combination of [jerry_parse_opts_t](#jerry_parse_opts_t) flags.
- `options_p` - additional parsing options, can be NULL if not used
- return value
- function object value, if script was parsed successfully,
- thrown error, otherwise
*Changed in version 2.0*: Added `resource_name_p`, and `resource_name_length` arguments.
*Changed in version [[NEXT_RELEASE]]*: The `resource_name_p`, `resource_name_length`, and `parse_opts` arguments are replaced by `options_p`.
**Example**
@ -1439,8 +1471,17 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
const jerry_char_t script[] = "print ('Hello, World!');";
const jerry_char_t file[] = "hello.js";
jerry_value_t parsed_code = jerry_parse (NULL, 0, script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_STRICT_MODE | JERRY_PARSE_HAS_RESOURCE | JERRY_PARSE_HAS_START;
parse_options.resource_name_p = file;
parse_options.resource_name_length = sizeof(file) - 1;
/* This example script is extracted from the middle of a file. */
parse_options.start_line = 10;
parse_options.start_column = 1;
jerry_value_t parsed_code = jerry_parse (script, sizeof (script) - 1, &parse_options);
jerry_release_value (parsed_code);
jerry_cleanup ();
@ -1452,6 +1493,7 @@ main (void)
- [jerry_run](#jerry_run)
- [jerry_parse_function](#jerry_parse_function)
- [jerry_parse_options_t](#jerry_parse_options_t)
## jerry_parse_function
@ -1471,27 +1513,24 @@ is no longer needed.
```c
jerry_value_t
jerry_parse_function (const jerry_char_t *resource_name_p, /**< resource name (usually a file name) */
size_t resource_name_length, /**< length of resource name */
const jerry_char_t *arg_list_p, /**< script source */
size_t arg_list_size, /**< script source size */
const jerry_char_t *source_p, /**< script source */
size_t source_size, /**< script source size */
uint32_t parse_opts) /**< strict mode */
jerry_parse_function (const jerry_char_t *arg_list_p,
size_t arg_list_size,
const jerry_char_t *source_p,
size_t source_size,
const jerry_parse_options_t *options_p);
```
- `resource_name_p` - resource name, usually a file name (must be a valid UTF8 string).
- `resource_name_length` - size of the resource name, in bytes.
- `arg_list_p` - argument list of the function (must be a valid UTF8 string).
- `arg_list_size` - size of the argument list, in bytes.
- `source_p` - string, containing source code to parse (must be a valid UTF8 string).
- `source_size` - size of the string, in bytes.
- `parse_opts` - any combination of [jerry_parse_opts_t](#jerry_parse_opts_t) flags.
- `options_p` - additional parsing options, can be NULL if not used
- return value
- function object value, if script was parsed successfully,
- thrown error, otherwise
*New in version 2.0*.
*Changed in version [[NEXT_RELEASE]]*: The `resource_name_p`, `resource_name_length`, and `parse_opts` arguments are replaced by `options_p`.
**Example**
@ -1514,13 +1553,11 @@ main (void)
const char function_args[] = "a, b";
const char function_source[] = "return a + b";
jerry_value_t parsed_function = jerry_parse_function (NULL,
0,
(const jerry_char_t *) function_args,
jerry_value_t parsed_function = jerry_parse_function ((const jerry_char_t *) function_args,
strlen (function_args),
(const jerry_char_t *) function_source,
strlen (function_source),
JERRY_PARSE_NO_OPTS);
NULL);
if (!jerry_value_is_error (parsed_function))
{
@ -1565,6 +1602,7 @@ main (void)
**See also**
- [jerry_call_function](#jerry_call_function)
- [jerry_parse_options_t](#jerry_parse_options_t)
## jerry_run
@ -1606,7 +1644,7 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
/* Setup Global scope code */
jerry_value_t parsed_code = jerry_parse (NULL, 0, script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
jerry_value_t parsed_code = jerry_parse (script, sizeof (script) - 1, NULL);
if (!jerry_value_is_error (parsed_code))
{
@ -1650,7 +1688,8 @@ jerry_eval (const jerry_char_t *source_p,
- `source_p` - source code to evaluate, it must be a valid utf8 string.
- `source_size` - length of the source code
- `parse_opts` - any combination of [jerry_parse_opts_t](#jerry_parse_opts_t) flags.
- `parse_opts` - combination of [jerry_parse_option_enable_feature_t](#jerry_parse_option_enable_feature_t) flags.
The following flags are allowed: JERRY_PARSE_STRICT_MODE
- return value - result of eval, may be an error value.
**Example**
@ -1705,7 +1744,7 @@ main (void)
const jerry_char_t script[] = "new Promise(function(f,r) { f('Hello, World!'); }).then(function(x) { print(x); });";
jerry_value_t parsed_code = jerry_parse (NULL, 0, script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
jerry_value_t parsed_code = jerry_parse (script, sizeof (script) - 1, NULL);
jerry_value_t script_value = jerry_run (parsed_code);
jerry_value_t job_value;
@ -8878,19 +8917,17 @@ Generate snapshot from the specified source code.
```c
jerry_value_t
jerry_generate_snapshot (const jerry_char_t *resource_name_p,
size_t resource_name_length,
const jerry_char_t *source_p,
jerry_generate_snapshot (const jerry_char_t *source_p,
size_t source_size,
const jerry_parse_options_t *options_p,
uint32_t generate_snapshot_opts,
uint32_t *buffer_p,
size_t buffer_size);
```
- `resource_name_p` - resource (file) name of the source code. Currently unused, the debugger may use it in the future.
- `resource_name_length` - length of resource name.
- `source_p` - script source, it must be a valid utf8 string.
- `source_size` - script source size, in bytes.
- `options_p` - additional parsing options, can be NULL if not used
- `generate_snapshot_opts` - any combination of [jerry_generate_snapshot_opts_t](#jerry_generate_snapshot_opts_t) flags.
- `buffer_p` - output buffer (aligned to 4 bytes) to save snapshot to.
- `buffer_size` - the output buffer's size in bytes.
@ -8901,6 +8938,7 @@ jerry_generate_snapshot (const jerry_char_t *resource_name_p,
- thrown error, otherwise.
*New in version 2.0*.
*Changed in version [[NEXT_RELEASE]]*: The `resource_name_p`, and `resource_name_length` arguments are replaced by `options_p`.
**Example**
@ -8918,10 +8956,9 @@ main (void)
const jerry_char_t script_to_snapshot[] = "(function () { return 'string from snapshot'; }) ();";
jerry_value_t generate_result;
generate_result = jerry_generate_snapshot (NULL,
0,
script_to_snapshot,
generate_result = jerry_generate_snapshot (script_to_snapshot,
sizeof (script_to_snapshot) - 1,
NULL,
0,
global_mode_snapshot_buffer,
sizeof (global_mode_snapshot_buffer) / sizeof (uint32_t));
@ -8944,6 +8981,7 @@ main (void)
- [jerry_cleanup](#jerry_cleanup)
- [jerry_generate_function_snapshot](#jerry_generate_function_snapshot)
- [jerry_exec_snapshot](#jerry_exec_snapshot)
- [jerry_parse_options_t](#jerry_parse_options_t)
## jerry_generate_function_snapshot
@ -8967,23 +9005,21 @@ passed as separated arguments.
```c
jerry_value_t
jerry_generate_function_snapshot (const jerry_char_t *resource_name_p,
size_t resource_name_length,
const jerry_char_t *source_p,
jerry_generate_function_snapshot (const jerry_char_t *source_p,
size_t source_size,
const jerry_char_t *args_p,
size_t args_size,
const jerry_parse_options_t *options_p,
uint32_t generate_snapshot_opts,
uint32_t *buffer_p,
size_t buffer_size)
```
- `resource_name_p` - resource (file) name of the source code. Currently unused, the debugger may use it in the future.
- `resource_name_length` - length of resource name.
- `source_p` - script source, it must be a valid utf8 string.
- `source_size` - script source size, in bytes.
- `args_p` - function arguments, it must be a valid utf8 string.
- `args_size` - function argument size, in bytes.
- `options_p` - additional parsing options, can be NULL if not used
- `generate_snapshot_opts` - any combination of [jerry_generate_snapshot_opts_t](#jerry_generate_snapshot_opts_t) flags.
- `buffer_p` - buffer (aligned to 4 bytes) to save snapshot to.
- `buffer_size` - the buffer's size in bytes.
@ -8994,6 +9030,7 @@ jerry_generate_function_snapshot (const jerry_char_t *resource_name_p,
- thrown error, otherwise.
*New in version 2.0*.
*Changed in version [[NEXT_RELEASE]]*: The `resource_name_p`, and `resource_name_length` arguments are replaced by `options_p`.
**Example**
@ -9012,12 +9049,11 @@ main (void)
const jerry_char_t src[] = "return a + b;";
jerry_value_t generate_result;
generate_result = jerry_generate_function_snapshot (NULL,
0,
src,
generate_result = jerry_generate_function_snapshot (src,
sizeof (src) - 1,
args,
sizeof (args) - 1,
NULL,
0,
func_snapshot_buffer,
sizeof (func_snapshot_buffer) / sizeof (uint32_t));
@ -9040,6 +9076,7 @@ main (void)
- [jerry_cleanup](#jerry_cleanup)
- [jerry_generate_snapshot](#jerry_generate_snapshot)
- [jerry_load_function_snapshot_at](#jerry_load_function_snapshot_at)
- [jerry_parse_options_t](#jerry_parse_options_t)
## jerry_exec_snapshot
@ -9091,10 +9128,9 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t generate_result;
generate_result = jerry_generate_snapshot (NULL,
0,
script_to_snapshot,
generate_result = jerry_generate_snapshot (script_to_snapshot,
sizeof (script_to_snapshot) - 1,
NULL,
0,
global_mode_snapshot_buffer,
sizeof (global_mode_snapshot_buffer) / sizeof (uint32_t));
@ -9180,13 +9216,12 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t generate_result;
generate_result = jerry_generate_function_snapshot (NULL,
0,
func_src,
generate_result = jerry_generate_function_snapshot (func_src,
sizeof (func_src) - 1,
func_args,
sizeof (func_args) - 1,
false,
NULL,
0,
snapshot_buffer,
sizeof (snapshot_buffer) / sizeof (uint32_t));
@ -9281,10 +9316,9 @@ main (void)
static uint32_t snapshot_buffer[256];
const jerry_char_t script_for_literal_save[] = "var obj = { a:'aa', bb:'Bb' }";
jerry_value_t generate_result = jerry_generate_snapshot (NULL,
0,
script_for_literal_save,
jerry_value_t generate_result = jerry_generate_snapshot (script_for_literal_save,
sizeof (script_for_literal_save) - 1,
NULL,
0,
snapshot_buffer,
256);
@ -9418,11 +9452,14 @@ main (void)
"f ();\n");
const char *resource = "demo_memoryjs";
jerry_value_t program = jerry_parse ((const jerry_char_t *) resource,
strlen (resource),
(const jerry_char_t *) source,
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name_p = (jerry_char_t *) resource;
parse_options.resource_name_length = (size_t) strlen (resource);
jerry_value_t program = jerry_parse ((const jerry_char_t *) source,
strlen (source),
JERRY_PARSE_NO_OPTS);
&parse_options);
if (!jerry_value_is_error (program))
{
jerry_value_t run_result = jerry_run (program);
@ -9521,11 +9558,14 @@ main (void)
"f ();\n");
const char *resource = "demo_backtrace.js";
jerry_value_t program = jerry_parse ((const jerry_char_t *) resource,
strlen (resource),
(const jerry_char_t *) source,
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name_p = (jerry_char_t *) resource;
parse_options.resource_name_length = (size_t) strlen (resource);
jerry_value_t program = jerry_parse ((const jerry_char_t *) source,
strlen (source),
JERRY_PARSE_NO_OPTS);
&parse_options);
if (!jerry_value_is_error (program))
{
jerry_value_t run_result = jerry_run (program);
@ -9843,7 +9883,7 @@ main (void)
// Infinite loop.
const jerry_char_t script[] = "while(true) {}";
jerry_value_t parsed_code = jerry_parse (NULL, 0, script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
jerry_value_t parsed_code = jerry_parse (script, sizeof (script) - 1, NULL);
jerry_release_value (jerry_run (parsed_code));
jerry_release_value (parsed_code);
jerry_cleanup ();
@ -9930,11 +9970,14 @@ main (void)
const jerry_char_t source[] = "function myFunction() { return resourceName() }; myFunction()";
const jerry_char_t resource[] = "demo.js";
jerry_value_t program = jerry_parse (resource,
sizeof (resource) - 1,
source,
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name_p = resource;
parse_options.resource_name_length = sizeof (resource) - 1;
jerry_value_t program = jerry_parse (source,
sizeof (source) - 1,
JERRY_PARSE_NO_OPTS);
&parse_options);
if (!jerry_value_is_error (program))
{

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

@ -153,7 +153,7 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
/* Setup Global scope code */
jerry_value_t parsed_code = jerry_parse (NULL, 0, script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
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))
@ -259,7 +259,7 @@ main (void)
}
/* Setup Global scope code */
jerry_value_t parsed_code = jerry_parse (NULL, 0, script, script_size, JERRY_PARSE_NO_OPTS);
jerry_value_t parsed_code = jerry_parse (script, script_size, NULL);
if (!jerry_value_is_error (parsed_code))
{
@ -378,7 +378,7 @@ main (void)
}
/* Setup Global scope code */
jerry_value_t parsed_code = jerry_parse (NULL, 0, script, script_size, JERRY_PARSE_NO_OPTS);
jerry_value_t parsed_code = jerry_parse (script, script_size, NULL);
if (!jerry_value_is_error (parsed_code))
{
@ -444,7 +444,7 @@ main (void)
jerryx_handler_print);
/* Setup Global scope code */
jerry_value_t parsed_code = jerry_parse (NULL, 0, script, script_size, JERRY_PARSE_NO_OPTS);
jerry_value_t parsed_code = jerry_parse (script, script_size, NULL);
if (!jerry_value_is_error (parsed_code))
{

11
docs/07.DEBUGGER.md
View File

@ -314,11 +314,14 @@ wait_for_source_callback (const jerry_char_t *resource_name_p, /**< resource nam
{
(void) user_p;
jerry_value_t ret_val = jerry_parse (resource_name_p,
resource_name_size,
source_p,
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name_p = resource_name_p;
parse_options.resource_name_length = resource_name_size;
jerry_value_t ret_val = jerry_parse (source_p,
source_size,
JERRY_PARSE_NO_OPTS);
&parse_options);
if (!jerry_value_is_error (ret_val))
{

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

@ -757,28 +757,27 @@ snapshot_load_compiled_code (const uint8_t *base_addr_p, /**< base address of th
* error object otherwise
*/
static jerry_value_t
jerry_generate_snapshot_with_args (const jerry_char_t *resource_name_p, /**< script resource name */
size_t resource_name_length, /**< script resource name length */
const jerry_char_t *source_p, /**< script source */
jerry_generate_snapshot_with_args (const jerry_char_t *source_p, /**< script source */
size_t source_size, /**< script source size */
const jerry_char_t *args_p, /**< arguments string */
size_t args_size, /**< arguments string size */
const jerry_parse_options_t *options_p, /**< parsing options,
* can be NULL if not used */
uint32_t generate_snapshot_opts, /**< jerry_generate_snapshot_opts_t option bits */
uint32_t *buffer_p, /**< buffer to save snapshot to */
size_t buffer_size) /**< the buffer's size */
{
/* Currently unused arguments. */
JERRY_UNUSED (resource_name_p);
JERRY_UNUSED (resource_name_length);
uint32_t allowed_options = JERRY_SNAPSHOT_SAVE_STATIC;
uint32_t allowed_parse_options = (JERRY_PARSE_STRICT_MODE
| JERRY_PARSE_HAS_RESOURCE
| JERRY_PARSE_HAS_START);
ecma_value_t resource_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON);
#if JERRY_RESOURCE_NAME
if (resource_name_length > 0)
if ((generate_snapshot_opts & ~allowed_options) != 0
|| (options_p != NULL && (options_p->options & ~allowed_parse_options) != 0))
{
resource_name = ecma_find_or_create_literal_string (resource_name_p, (lit_utf8_size_t) resource_name_length);
const char * const error_message_p = "Unsupported generate snapshot flags specified";
return jerry_create_error (JERRY_ERROR_RANGE, (const jerry_char_t *) error_message_p);
}
#endif /* JERRY_RESOURCE_NAME */
snapshot_globals_t globals;
const uint32_t aligned_header_size = JERRY_ALIGNUP (sizeof (jerry_snapshot_header_t),
@ -789,15 +788,19 @@ jerry_generate_snapshot_with_args (const jerry_char_t *resource_name_p, /**< scr
globals.regex_found = false;
globals.class_found = false;
uint32_t status_flags = ((generate_snapshot_opts & JERRY_SNAPSHOT_SAVE_STRICT) ? ECMA_PARSE_STRICT_MODE
: ECMA_PARSE_NO_OPTS);
uint32_t status_flags = ECMA_PARSE_NO_OPTS;
if (options_p != NULL)
{
status_flags |= (options_p->options & ECMA_PARSE_STRICT_MODE);
}
ecma_compiled_code_t *bytecode_data_p = parser_parse_script (args_p,
args_size,
source_p,
source_size,
resource_name,
status_flags);
status_flags,
(const ecma_parse_options_t *) options_p);
if (JERRY_UNLIKELY (bytecode_data_p == NULL))
{
@ -883,37 +886,27 @@ jerry_generate_snapshot_with_args (const jerry_char_t *resource_name_p, /**< scr
* error object otherwise
*/
jerry_value_t
jerry_generate_snapshot (const jerry_char_t *resource_name_p, /**< script resource name */
size_t resource_name_length, /**< script resource name length */
const jerry_char_t *source_p, /**< script source */
jerry_generate_snapshot (const jerry_char_t *source_p, /**< script source */
size_t source_size, /**< script source size */
const jerry_parse_options_t *options_p, /**< parsing options,
* can be NULL if not used */
uint32_t generate_snapshot_opts, /**< jerry_generate_snapshot_opts_t option bits */
uint32_t *buffer_p, /**< buffer to save snapshot to */
size_t buffer_size) /**< the buffer's size */
{
#if JERRY_SNAPSHOT_SAVE
uint32_t allowed_opts = (JERRY_SNAPSHOT_SAVE_STATIC | JERRY_SNAPSHOT_SAVE_STRICT);
if ((generate_snapshot_opts & ~(allowed_opts)) != 0)
{
const char * const error_message_p = "Unsupported generate snapshot flags specified";
return jerry_create_error (JERRY_ERROR_RANGE, (const jerry_char_t *) error_message_p);
}
return jerry_generate_snapshot_with_args (resource_name_p,
resource_name_length,
source_p,
return jerry_generate_snapshot_with_args (source_p,
source_size,
NULL,
0,
options_p,
generate_snapshot_opts,
buffer_p,
buffer_size);
#else /* !JERRY_SNAPSHOT_SAVE */
JERRY_UNUSED (resource_name_p);
JERRY_UNUSED (resource_name_length);
JERRY_UNUSED (source_p);
JERRY_UNUSED (source_size);
JERRY_UNUSED (options_p);
JERRY_UNUSED (generate_snapshot_opts);
JERRY_UNUSED (buffer_p);
JERRY_UNUSED (buffer_size);
@ -1806,41 +1799,31 @@ jerry_get_literals_from_snapshot (const uint32_t *snapshot_p, /**< input snapsho
* error object otherwise
*/
jerry_value_t
jerry_generate_function_snapshot (const jerry_char_t *resource_name_p, /**< script resource name */
size_t resource_name_length, /**< script resource name length */
const jerry_char_t *source_p, /**< script source */
jerry_generate_function_snapshot (const jerry_char_t *source_p, /**< script source */
size_t source_size, /**< script source size */
const jerry_char_t *args_p, /**< arguments string */
size_t args_size, /**< arguments string size */
const jerry_parse_options_t *options_p, /**< parsing options,
* can be NULL if not used */
uint32_t generate_snapshot_opts, /**< jerry_generate_snapshot_opts_t option bits */
uint32_t *buffer_p, /**< buffer to save snapshot to */
size_t buffer_size) /**< the buffer's size */
{
#if JERRY_SNAPSHOT_SAVE
uint32_t allowed_opts = (JERRY_SNAPSHOT_SAVE_STATIC | JERRY_SNAPSHOT_SAVE_STRICT);
if ((generate_snapshot_opts & ~(allowed_opts)) != 0)
{
const char * const error_message_p = "Unsupported generate snapshot flags specified";
return jerry_create_error (JERRY_ERROR_RANGE, (const jerry_char_t *) error_message_p);
}
return jerry_generate_snapshot_with_args (resource_name_p,
resource_name_length,
source_p,
return jerry_generate_snapshot_with_args (source_p,
source_size,
args_p,
args_size,
options_p,
generate_snapshot_opts,
buffer_p,
buffer_size);
#else /* !JERRY_SNAPSHOT_SAVE */
JERRY_UNUSED (resource_name_p);
JERRY_UNUSED (resource_name_length);
JERRY_UNUSED (source_p);
JERRY_UNUSED (source_size);
JERRY_UNUSED (args_p);
JERRY_UNUSED (args_size);
JERRY_UNUSED (options_p);
JERRY_UNUSED (generate_snapshot_opts);
JERRY_UNUSED (buffer_p);
JERRY_UNUSED (buffer_size);

136
jerry-core/api/jerry.c
View File

@ -82,6 +82,15 @@ JERRY_STATIC_ASSERT ((int) JERRY_PROP_NO_OPTS == (int) ECMA_PROP_NO_OPTS
&& (int) JERRY_PROP_SHOULD_THROW == (int) ECMA_PROP_SHOULD_THROW,
jerry_prop_desc_flags_must_be_equal_to_ecma_prop_desc_flags);
JERRY_STATIC_ASSERT ((int) ECMA_PARSE_STRICT_MODE == (int) JERRY_PARSE_STRICT_MODE
&& (int) ECMA_PARSE_MODULE == (int) JERRY_PARSE_MODULE
&& (int) ECMA_PARSE_HAS_RESOURCE == (int) JERRY_PARSE_HAS_RESOURCE
&& (int) ECMA_PARSE_HAS_START == (int) JERRY_PARSE_HAS_START,
ecma_parse_config_options_t_must_be_equal_to_jerry_parse_config_options_t);
JERRY_STATIC_ASSERT (sizeof (jerry_parse_options_t) == sizeof (ecma_parse_options_t),
ecma_parse_options_t_and_jerry_parse_options_t_must_be_the_same);
#if JERRY_BUILTIN_REGEXP
JERRY_STATIC_ASSERT ((int) RE_FLAG_GLOBAL == (int) JERRY_REGEXP_FLAG_GLOBAL
&& (int) RE_FLAG_MULTILINE == (int) JERRY_REGEXP_FLAG_MULTILINE
@ -445,7 +454,7 @@ jerry_run_simple (const jerry_char_t *script_source_p, /**< script source */
jerry_init (flags);
jerry_value_t parse_ret_val = jerry_parse (NULL, 0, script_source_p, script_source_size, JERRY_PARSE_NO_OPTS);
jerry_value_t parse_ret_val = jerry_parse (script_source_p, script_source_size, NULL);
if (!ecma_is_value_error_reference (parse_ret_val))
{
@ -473,42 +482,49 @@ jerry_run_simple (const jerry_char_t *script_source_p, /**< script source */
* thrown error - otherwise
*/
jerry_value_t
jerry_parse (const jerry_char_t *resource_name_p, /**< resource name (usually a file name) */
size_t resource_name_length, /**< length of resource name */
const jerry_char_t *source_p, /**< script source */
jerry_parse (const jerry_char_t *source_p, /**< script source */
size_t source_size, /**< script source size */
uint32_t parse_opts) /**< jerry_parse_opts_t option bits */
const jerry_parse_options_t *options_p) /**< parsing options, can be NULL if not used */
{
#if JERRY_DEBUGGER && JERRY_PARSER
if ((JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_CONNECTED)
&& resource_name_length > 0)
{
jerry_debugger_send_string (JERRY_DEBUGGER_SOURCE_CODE_NAME,
JERRY_DEBUGGER_NO_SUBTYPE,
resource_name_p,
resource_name_length);
}
#else /* !(JERRY_DEBUGGER && JERRY_PARSER) */
JERRY_UNUSED (resource_name_p);
JERRY_UNUSED (resource_name_length);
#endif /* JERRY_DEBUGGER && JERRY_PARSER */
#if JERRY_PARSER
jerry_assert_api_available ();
ecma_value_t resource_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON);
uint32_t allowed_parse_options = (JERRY_PARSE_STRICT_MODE
| JERRY_PARSE_MODULE
| JERRY_PARSE_HAS_RESOURCE
| JERRY_PARSE_HAS_START);
#if JERRY_RESOURCE_NAME
if (resource_name_length > 0)
if (options_p != NULL && (options_p->options & ~allowed_parse_options) != 0)
{
resource_name = ecma_find_or_create_literal_string (resource_name_p, (lit_utf8_size_t) resource_name_length);
return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (wrong_args_msg_p)));
}
#endif /* JERRY_PARSER */
#if JERRY_DEBUGGER && JERRY_PARSER
if ((JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_CONNECTED)
&& options_p != NULL
&& (options_p->options & JERRY_PARSE_HAS_RESOURCE)
&& options_p->resource_name_length > 0)
{
jerry_debugger_send_string (JERRY_DEBUGGER_SOURCE_CODE_NAME,
JERRY_DEBUGGER_NO_SUBTYPE,
options_p->resource_name_p,
options_p->resource_name_length);
}
#endif /* JERRY_DEBUGGER && JERRY_PARSER */
#if JERRY_PARSER
uint32_t parse_opts = 0;
if (options_p != NULL)
{
parse_opts |= options_p->options & (JERRY_PARSE_STRICT_MODE | JERRY_PARSE_MODULE);
}
#endif /* JERRY_RESOURCE_NAME */
if ((parse_opts & JERRY_PARSE_MODULE) != 0)
{
#if JERRY_MODULE_SYSTEM
ecma_module_initialize_context (ecma_get_string_from_value (resource_name));
ecma_module_initialize_context ((const ecma_parse_options_t *) options_p);
#else /* !JERRY_MODULE_SYSTEM */
return jerry_throw (ecma_raise_syntax_error (ECMA_ERR_MSG ("Module system has been disabled")));
#endif /* JERRY_MODULE_SYSTEM */
@ -518,8 +534,8 @@ jerry_parse (const jerry_char_t *resource_name_p, /**< resource name (usually a
0,
source_p,
source_size,
resource_name,
parse_opts);
parse_opts,
(const ecma_parse_options_t *) options_p);
if (JERRY_UNLIKELY (bytecode_data_p == NULL))
{
@ -570,7 +586,7 @@ jerry_parse (const jerry_char_t *resource_name_p, /**< resource name (usually a
#else /* !JERRY_PARSER */
JERRY_UNUSED (source_p);
JERRY_UNUSED (source_size);
JERRY_UNUSED (parse_opts);
JERRY_UNUSED (options_p);
return jerry_throw (ecma_raise_syntax_error (ECMA_ERR_MSG (error_parser_not_supported_p)));
#endif /* JERRY_PARSER */
@ -584,38 +600,45 @@ jerry_parse (const jerry_char_t *resource_name_p, /**< resource name (usually a
* thrown error - otherwise
*/
jerry_value_t
jerry_parse_function (const jerry_char_t *resource_name_p, /**< resource name (usually a file name) */
size_t resource_name_length, /**< length of resource name */
const jerry_char_t *arg_list_p, /**< script source */
jerry_parse_function (const jerry_char_t *arg_list_p, /**< script source */
size_t arg_list_size, /**< script source size */
const jerry_char_t *source_p, /**< script source */
size_t source_size, /**< script source size */
uint32_t parse_opts) /**< jerry_parse_opts_t option bits */
const jerry_parse_options_t *options_p) /**< parsing options, can be NULL if not used */
{
#if JERRY_DEBUGGER && JERRY_PARSER
if (JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_CONNECTED)
{
jerry_debugger_send_string (JERRY_DEBUGGER_SOURCE_CODE_NAME,
JERRY_DEBUGGER_NO_SUBTYPE,
resource_name_p,
resource_name_length);
}
#else /* !(JERRY_DEBUGGER && JERRY_PARSER) */
JERRY_UNUSED (resource_name_p);
JERRY_UNUSED (resource_name_length);
#endif /* JERRY_DEBUGGER && JERRY_PARSER */
#if JERRY_PARSER
jerry_assert_api_available ();
ecma_value_t resource_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON);
uint32_t allowed_parse_options = (JERRY_PARSE_STRICT_MODE
| JERRY_PARSE_HAS_RESOURCE
| JERRY_PARSE_HAS_START);
#if JERRY_RESOURCE_NAME
if (resource_name_length > 0)
if (options_p != NULL && (options_p->options & ~allowed_parse_options) != 0)
{
resource_name = ecma_find_or_create_literal_string (resource_name_p, (lit_utf8_size_t) resource_name_length);
return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (wrong_args_msg_p)));
}
#endif /* JERRY_PARSER */
#if JERRY_DEBUGGER && JERRY_PARSER
if ((JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_CONNECTED)
&& options_p != NULL
&& (options_p->options & JERRY_PARSE_HAS_RESOURCE)
&& options_p->resource_name_length > 0)
{
jerry_debugger_send_string (JERRY_DEBUGGER_SOURCE_CODE_NAME,
JERRY_DEBUGGER_NO_SUBTYPE,
options_p->resource_name_p,
options_p->resource_name_length);
}
#endif /* JERRY_DEBUGGER && JERRY_PARSER */
#if JERRY_PARSER
uint32_t parse_opts = 0;
if (options_p != NULL)
{
parse_opts |= options_p->options & JERRY_PARSE_STRICT_MODE;
}
#endif /* JERRY_RESOURCE_NAME */
if (arg_list_p == NULL)
{
@ -627,8 +650,8 @@ jerry_parse_function (const jerry_char_t *resource_name_p, /**< resource name (u
arg_list_size,
source_p,
source_size,
resource_name,
parse_opts);
parse_opts,
(const ecma_parse_options_t *) options_p);
if (JERRY_UNLIKELY (bytecode_p == NULL))
{
@ -651,7 +674,7 @@ jerry_parse_function (const jerry_char_t *resource_name_p, /**< resource name (u
JERRY_UNUSED (arg_list_size);
JERRY_UNUSED (source_p);
JERRY_UNUSED (source_size);
JERRY_UNUSED (parse_opts);
JERRY_UNUSED (options_p);
return jerry_throw (ecma_raise_syntax_error (ECMA_ERR_MSG (error_parser_not_supported_p)));
#endif /* JERRY_PARSER */
@ -731,6 +754,13 @@ jerry_eval (const jerry_char_t *source_p, /**< source code */
{
jerry_assert_api_available ();
uint32_t allowed_parse_options = JERRY_PARSE_STRICT_MODE;
if ((parse_opts & ~allowed_parse_options) != 0)
{
return jerry_throw (ecma_raise_type_error (ECMA_ERR_MSG (wrong_args_msg_p)));
}
return jerry_return (ecma_op_eval_chars_buffer ((const lit_utf8_byte_t *) source_p,
source_size,
parse_opts));

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

@ -331,6 +331,32 @@ typedef struct ecma_native_pointer_t
struct ecma_native_pointer_t *next_p; /**< points to the next ecma_native_pointer_t element */
} ecma_native_pointer_t;
/**
* Option bits for ecma_parse_options_t.
*/
typedef enum
{
/* bit 0: ECMA_PARSE_STRICT_MODE */
/* bit 1: ECMA_PARSE_MODULE */
ECMA_PARSE_HAS_RESOURCE = (1 << 2), /**< resource_name_p and resource_name_length fields are valid */
ECMA_PARSE_HAS_START = (1 << 3), /**< start_line and start_column fields are valid */
} ecma_parse_option_feature_t;
/**
* Variable configuration options for parsing functions such as ecma_parse or ecma_parse_function.
*/
typedef struct
{
uint32_t options; /**< combination of ecma_parse_option_feature_t values
* which enables parsing features */
const lit_utf8_byte_t *resource_name_p; /**< resource name (usually a file name)
* if ECMA_PARSE_HAS_RESOURCE is set in options */
size_t resource_name_length; /**< length of resource name
* if ECMA_PARSE_HAS_RESOURCE is set in options */
uint32_t start_line; /**< start line of the source code if ECMA_PARSE_HAS_START is set in options */
uint32_t start_column; /**< start column of the source code if ECMA_PARSE_HAS_START is set in options */
} ecma_parse_options_t;
#if JERRY_ESNEXT
/**

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

@ -198,28 +198,27 @@ ecma_module_find_native_module (ecma_string_t *const path_p)
* Initialize context variables for the root module.
*/
void
ecma_module_initialize_context (ecma_string_t *root_path_p) /**< root module */
ecma_module_initialize_context (const ecma_parse_options_t *options_p) /**< configuration options */
{
JERRY_ASSERT (JERRY_CONTEXT (module_current_p) == NULL);
JERRY_ASSERT (JERRY_CONTEXT (module_list_p) == NULL);
lit_utf8_size_t path_str_size;
uint8_t flags = ECMA_STRING_FLAG_EMPTY;
ecma_string_t *path_p = ecma_get_magic_string (LIT_MAGIC_STRING_RESOURCE_ANON);
const lit_utf8_byte_t *path_str_chars_p = ecma_string_get_chars (root_path_p,
&path_str_size,
NULL,
NULL,
&flags);
ecma_string_t *path_p = ecma_module_create_normalized_path (path_str_chars_p,
path_str_size,
NULL);
if (path_p == NULL)
if (options_p != NULL
&& (options_p->options & JERRY_PARSE_HAS_RESOURCE)
&& options_p->resource_name_length > 0)
{
ecma_ref_ecma_string (root_path_p);
path_p = root_path_p;
const lit_utf8_byte_t *path_str_chars_p = options_p->resource_name_p;
lit_utf8_size_t path_str_size = (lit_utf8_size_t) options_p->resource_name_length;
path_p = ecma_module_create_normalized_path (path_str_chars_p,
path_str_size,
NULL);
if (path_p == NULL)
{
path_p = ecma_new_ecma_string_from_utf8_converted_to_cesu8 (path_str_chars_p, path_str_size);
}
}
ecma_module_t *module_p = (ecma_module_t *) jmem_heap_alloc_block (sizeof (ecma_module_t));
@ -1000,10 +999,10 @@ ecma_module_parse (ecma_module_t *module_p) /**< module */
size_t source_size = 0;
uint8_t *source_p = jerry_port_read_source ((const char *) module_path_p, &source_size);
jmem_heap_free_block (module_path_p, module_path_size + 1);
if (source_p == NULL)
{
jmem_heap_free_block (module_path_p, module_path_size + 1);
return ecma_raise_syntax_error (ECMA_ERR_MSG ("File not found"));
}
@ -1020,14 +1019,21 @@ ecma_module_parse (ecma_module_t *module_p) /**< module */
}
#endif /* JERRY_DEBUGGER && JERRY_PARSER */
/* TODO: Improve this code in the future. */
ecma_parse_options_t parse_options;
parse_options.options = ECMA_PARSE_STRICT_MODE | ECMA_PARSE_MODULE | ECMA_PARSE_HAS_RESOURCE;
parse_options.resource_name_p = module_path_p;
parse_options.resource_name_length = module_path_size;
ecma_compiled_code_t *bytecode_p = parser_parse_script (NULL,
0,
(jerry_char_t *) source_p,
source_size,
ecma_make_string_value (module_p->path_p),
ECMA_PARSE_STRICT_MODE | ECMA_PARSE_MODULE);
ECMA_PARSE_STRICT_MODE | ECMA_PARSE_MODULE,
&parse_options);
JERRY_CONTEXT (module_current_p) = prev_module_p;
jmem_heap_free_block (module_path_p, module_path_size + 1);
jerry_port_release_source (source_p);
if (JERRY_UNLIKELY (bytecode_p == NULL))

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

@ -126,7 +126,7 @@ ecma_module_t *ecma_module_find_native_module (ecma_string_t *const path_p);
ecma_value_t ecma_module_parse_referenced_modules (void);
ecma_value_t ecma_module_initialize (ecma_module_t *module_p);
void ecma_module_initialize_context (ecma_string_t *root_path_p);
void ecma_module_initialize_context (const ecma_parse_options_t *options_p);
void ecma_module_cleanup_context (void);
void ecma_module_release_module_nodes (ecma_module_node_t *module_node_p);

5
jerry-core/ecma/operations/ecma-eval.c
View File

@ -95,13 +95,12 @@ ecma_op_eval_chars_buffer (const lit_utf8_byte_t *code_p, /**< code characters b
ECMA_CLEAR_LOCAL_PARSE_OPTS ();
#endif /* JERRY_ESNEXT */
ecma_value_t resource_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_EVAL);
ecma_compiled_code_t *bytecode_p = parser_parse_script (NULL,
0,
code_p,
code_buffer_size,
resource_name,
parse_opts);
parse_opts,
NULL);
if (JERRY_UNLIKELY (bytecode_p == NULL))
{

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

@ -457,13 +457,12 @@ ecma_op_create_dynamic_function (const ecma_value_t *arguments_list_p, /**< argu
ECMA_STRING_TO_UTF8_STRING (arguments_str_p, arguments_buffer_p, arguments_buffer_size);
ECMA_STRING_TO_UTF8_STRING (function_body_str_p, function_body_buffer_p, function_body_buffer_size);
ecma_value_t resource_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON);
ecma_compiled_code_t *bytecode_p = parser_parse_script (arguments_buffer_p,
arguments_buffer_size,
function_body_buffer_p,
function_body_buffer_size,
resource_name,
parse_opts);
parse_opts,
NULL);
ECMA_FINALIZE_UTF8_STRING (function_body_buffer_p, function_body_buffer_size);
ECMA_FINALIZE_UTF8_STRING (arguments_buffer_p, arguments_buffer_size);

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

@ -113,16 +113,6 @@ typedef enum
JERRY_FEATURE__COUNT /**< number of features. NOTE: must be at the end of the list */
} jerry_feature_t;
/**
* Option flags for jerry_parse and jerry_parse_function functions.
*/
typedef enum
{
JERRY_PARSE_NO_OPTS = 0, /**< no options passed */
JERRY_PARSE_STRICT_MODE = (1 << 0), /**< enable strict mode */
JERRY_PARSE_MODULE = (1 << 1) /**< parse source as an ECMAScript module */
} jerry_parse_opts_t;
/**
* GC operational modes.
*/
@ -168,7 +158,33 @@ typedef uint32_t jerry_length_t;
typedef uint32_t jerry_value_t;
/**
* Flags of ECMA property descriptor.
* Option bits for jerry_parse_options_t.
*/
typedef enum
{
JERRY_PARSE_NO_OPTS = 0, /**< no options passed */
JERRY_PARSE_STRICT_MODE = (1 << 0), /**< enable strict mode */
JERRY_PARSE_MODULE = (1 << 1), /**< parse source as an ECMAScript module */
JERRY_PARSE_HAS_RESOURCE = (1 << 2), /**< resource_name_p and resource_name_length fields are valid */
JERRY_PARSE_HAS_START = (1 << 3), /**< start_line and start_column fields are valid */
} jerry_parse_option_enable_feature_t;
/**
* Various configuration options for parsing functions such as jerry_parse or jerry_parse_function.
*/
typedef struct
{
uint32_t options; /**< combination of jerry_parse_option_enable_feature_t values */
const jerry_char_t *resource_name_p; /**< resource name (usually a file name)
* if JERRY_PARSE_HAS_RESOURCE is set in options */
size_t resource_name_length; /**< length of resource name
* if JERRY_PARSE_HAS_RESOURCE is set in options */
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_parse_options_t;
/**
* Description of ECMA property descriptor.
*/
typedef enum
{
@ -411,11 +427,11 @@ bool jerry_get_memory_stats (jerry_heap_stats_t *out_stats_p);
* Parser and executor functions.
*/
bool jerry_run_simple (const jerry_char_t *script_source_p, size_t script_source_size, jerry_init_flag_t flags);
jerry_value_t jerry_parse (const jerry_char_t *resource_name_p, size_t resource_name_length,
const jerry_char_t *source_p, size_t source_size, uint32_t parse_opts);
jerry_value_t jerry_parse_function (const jerry_char_t *resource_name_p, size_t resource_name_length,
const jerry_char_t *arg_list_p, size_t arg_list_size,
const jerry_char_t *source_p, size_t source_size, uint32_t parse_opts);
jerry_value_t jerry_parse (const jerry_char_t *source_p, size_t source_size,
const jerry_parse_options_t *options_p);
jerry_value_t jerry_parse_function (const jerry_char_t *arg_list_p, size_t arg_list_size,
const jerry_char_t *source_p, size_t source_size,
const jerry_parse_options_t *options_p);
jerry_value_t jerry_run (const jerry_value_t func_val);
jerry_value_t jerry_eval (const jerry_char_t *source_p, size_t source_size, uint32_t parse_opts);

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

@ -38,7 +38,6 @@ extern "C"
typedef enum
{
JERRY_SNAPSHOT_SAVE_STATIC = (1u << 0), /**< static snapshot */
JERRY_SNAPSHOT_SAVE_STRICT = (1u << 1), /**< strict mode code */
} jerry_generate_snapshot_opts_t;
/**
@ -53,14 +52,14 @@ typedef enum
/**
* Snapshot functions.
*/
jerry_value_t jerry_generate_snapshot (const jerry_char_t *resource_name_p, size_t resource_name_length,
const jerry_char_t *source_p, size_t source_size,
uint32_t generate_snapshot_opts, uint32_t *buffer_p, size_t buffer_size);
jerry_value_t jerry_generate_function_snapshot (const jerry_char_t *resource_name_p, size_t resource_name_length,
const jerry_char_t *source_p, size_t source_size,
jerry_value_t jerry_generate_snapshot (const jerry_char_t *source_p, size_t source_size,
const jerry_parse_options_t *options_p, uint32_t generate_snapshot_opts,
uint32_t *buffer_p, size_t buffer_size);
jerry_value_t jerry_generate_function_snapshot (const jerry_char_t *source_p, size_t source_size,
const jerry_char_t *args_p, size_t args_size,
uint32_t generate_snapshot_opts, uint32_t *buffer_p,
size_t buffer_size);
const jerry_parse_options_t *options_p,
uint32_t generate_snapshot_opts,
uint32_t *buffer_p, size_t buffer_size);
jerry_value_t jerry_exec_snapshot (const uint32_t *snapshot_p, size_t snapshot_size,
size_t func_index, uint32_t exec_snapshot_opts);

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

@ -313,7 +313,7 @@ LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_THROW, "throw")
LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_TRUNC, "trunc")
#endif
LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_VALUE, "value")
#if JERRY_PARSER
#if JERRY_PARSER && JERRY_RESOURCE_NAME
LIT_MAGIC_STRING_DEF (LIT_MAGIC_STRING_RESOURCE_EVAL, "<eval>")
#endif
#if JERRY_BUILTIN_BIGINT
@ -1070,7 +1070,7 @@ LIT_MAGIC_STRING_FIRST_STRING_WITH_SIZE (4, LIT_MAGIC_STRING_EMPTY_NON_CAPTURE_G
LIT_MAGIC_STRING_FIRST_STRING_WITH_SIZE (4, LIT_MAGIC_STRING_DATE_UL)
#endif
LIT_MAGIC_STRING_FIRST_STRING_WITH_SIZE (5, LIT_MAGIC_STRING_ARRAY_UL)
#if JERRY_PARSER
#if JERRY_PARSER && JERRY_RESOURCE_NAME
LIT_MAGIC_STRING_FIRST_STRING_WITH_SIZE (6, LIT_MAGIC_STRING_RESOURCE_EVAL)
#elif JERRY_BUILTIN_BIGINT
LIT_MAGIC_STRING_FIRST_STRING_WITH_SIZE (6, LIT_MAGIC_STRING_BIGINT_UL)

18
jerry-core/parser/js/js-lexer.c
View File

@ -3694,6 +3694,24 @@ lexer_compare_literal_to_string (parser_context_t *context_p, /**< context */
&& memcmp (context_p->token.lit_location.char_p, string_p, string_length) == 0);
} /* lexer_compare_literal_to_string */
/**
* Initialize line info to its default value
*/
void
lexer_init_line_info (parser_context_t *context_p) /**< context */
{
context_p->line = 1;
context_p->column = 1;
const ecma_parse_options_t *options_p = context_p->options_p;
if (options_p != NULL && (options_p->options & ECMA_PARSE_HAS_START))
{
context_p->line = (options_p->start_line > 0) ? options_p->start_line : 1;
context_p->column = (options_p->start_column > 0) ? options_p->start_column : 1;
}
} /* lexer_init_line_info */
/**
* Convert binary lvalue token to binary token
* e.g. += -> +

2
jerry-core/parser/js/js-parser-internal.h
View File

@ -546,6 +546,7 @@ typedef struct
uint32_t global_status_flags; /**< global status flags */
uint16_t stack_depth; /**< current stack depth */
uint16_t stack_limit; /**< maximum stack depth */
const ecma_parse_options_t *options_p; /**< parse options */
parser_saved_context_t *last_context_p; /**< last saved context */
parser_stack_iterator_t last_statement; /**< last statement position */
@ -781,6 +782,7 @@ bool lexer_token_is_let (parser_context_t *context_p);
bool lexer_token_is_async (parser_context_t *context_p);
#endif /* JERRY_ESNEXT */
bool lexer_compare_literal_to_string (parser_context_t *context_p, const char *string_p, size_t string_length);
void lexer_init_line_info (parser_context_t *context_p);
uint8_t lexer_convert_binary_lvalue_token_to_binary (uint8_t token);
/**

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

@ -1794,20 +1794,13 @@ parser_parse_source (const uint8_t *arg_list_p, /**< function argument list */
size_t arg_list_size, /**< size of function argument list */
const uint8_t *source_p, /**< valid UTF-8 source code */
size_t source_size, /**< size of the source code */
ecma_value_t resource_name, /**< resource name */
uint32_t parse_opts, /**< ecma_parse_opts_t option bits */
parser_error_location_t *error_location_p) /**< error location */
const ecma_parse_options_t *options_p) /**< additional configuration options */
{
parser_context_t context;
ecma_compiled_code_t *compiled_code_p;
context.error = PARSER_ERR_NO_ERROR;
if (error_location_p != NULL)
{
error_location_p->error = PARSER_ERR_NO_ERROR;
}
context.status_flags = parse_opts & PARSER_STRICT_MODE_MASK;
context.global_status_flags = parse_opts;
@ -1842,16 +1835,29 @@ parser_parse_source (const uint8_t *arg_list_p, /**< function argument list */
context.stack_depth = 0;
context.stack_limit = 0;
context.options_p = options_p;
context.last_context_p = NULL;
context.last_statement.current_p = NULL;
context.token.flags = 0;
context.line = 1;
context.column = 1;
lexer_init_line_info (&context);
#if JERRY_RESOURCE_NAME
ecma_value_t resource_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON);
if (context.global_status_flags & ECMA_PARSE_EVAL)
{
resource_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_EVAL);
}
if (context.options_p != NULL
&& (context.options_p->options & JERRY_PARSE_HAS_RESOURCE)
&& context.options_p->resource_name_length > 0)
{
resource_name = ecma_find_or_create_literal_string (context.options_p->resource_name_p,
(lit_utf8_size_t) context.options_p->resource_name_length);
}
context.resource_name = resource_name;
#else /* !JERRY_RESOURCE_NAME */
JERRY_UNUSED (resource_name);
#endif /* !JERRY_RESOURCE_NAME */
scanner_info_t scanner_info_end;
@ -1912,12 +1918,9 @@ parser_parse_source (const uint8_t *arg_list_p, /**< function argument list */
{
JERRY_ASSERT (context.error == PARSER_ERR_OUT_OF_MEMORY);
if (error_location_p != NULL)
{
error_location_p->error = context.error;
error_location_p->line = context.token.line;
error_location_p->column = context.token.column;
}
/* It is unlikely that memory can be allocated in an out-of-memory
* situation. However, a simple value can still be thrown. */
jcontext_raise_exception (ECMA_VALUE_NULL);
return NULL;
}
@ -1933,9 +1936,8 @@ parser_parse_source (const uint8_t *arg_list_p, /**< function argument list */
}
context.u.allocated_buffer_p = NULL;
context.line = 1;
context.column = 1;
context.token.flags = 0;
lexer_init_line_info (&context);
parser_stack_init (&context);
@ -1970,8 +1972,7 @@ parser_parse_source (const uint8_t *arg_list_p, /**< function argument list */
context.source_p = source_p;
context.source_end_p = source_p + source_size;
context.line = 1;
context.column = 1;
lexer_init_line_info (&context);
lexer_next_token (&context);
}
@ -2056,13 +2057,6 @@ parser_parse_source (const uint8_t *arg_list_p, /**< function argument list */
}
#endif
if (error_location_p != NULL)
{
error_location_p->error = context.error;
error_location_p->line = context.token.line;
error_location_p->column = context.token.column;
}
compiled_code_p = NULL;
parser_free_literals (&context.literal_pool);
parser_cbc_stream_free (&context.byte_code);
@ -2085,7 +2079,69 @@ parser_parse_source (const uint8_t *arg_list_p, /**< function argument list */
parser_stack_free (&context);
return compiled_code_p;
if (compiled_code_p != NULL)
{
return compiled_code_p;
}
#if JERRY_DEBUGGER
if (JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_CONNECTED)
{
jerry_debugger_send_type (JERRY_DEBUGGER_PARSE_ERROR);
}
#endif /* JERRY_DEBUGGER */
if (context.error == PARSER_ERR_OUT_OF_MEMORY)
{
/* It is unlikely that memory can be allocated in an out-of-memory
* situation. However, a simple value can still be thrown. */
jcontext_raise_exception (ECMA_VALUE_NULL);
return NULL;
}
#if JERRY_ERROR_MESSAGES
ecma_string_t *err_str_p;
if (context.error == PARSER_ERR_INVALID_REGEXP)
{
ecma_value_t error = jcontext_take_exception ();
ecma_property_t *prop_p = ecma_find_named_property (ecma_get_object_from_value (error),
ecma_get_magic_string (LIT_MAGIC_STRING_MESSAGE));
ecma_free_value (error);
JERRY_ASSERT (prop_p);
err_str_p = ecma_get_string_from_value (ECMA_PROPERTY_VALUE_PTR (prop_p)->value);
ecma_ref_ecma_string (err_str_p);
}
else
{
const lit_utf8_byte_t *err_bytes_p = (const lit_utf8_byte_t *) parser_error_to_string (context.error);
lit_utf8_size_t err_bytes_size = lit_zt_utf8_string_size (err_bytes_p);
err_str_p = ecma_new_ecma_string_from_utf8 (err_bytes_p, err_bytes_size);
}
ecma_value_t err_str_val = ecma_make_string_value (err_str_p);
ecma_value_t line_str_val = ecma_make_uint32_value (context.token.line);
ecma_value_t col_str_val = ecma_make_uint32_value (context.token.column);
ecma_raise_standard_error_with_format (ECMA_ERROR_SYNTAX,
"% [%:%:%]",
err_str_val,
context.resource_name,
line_str_val,
col_str_val);
ecma_free_value (col_str_val);
ecma_free_value (line_str_val);
ecma_deref_ecma_string (err_str_p);
#else /* !JERRY_ERROR_MESSAGES */
if (context.error == PARSER_ERR_INVALID_REGEXP)
{
jcontext_release_exception ();
}
ecma_raise_syntax_error ("");
#endif /* JERRY_ERROR_MESSAGES */
return NULL;
} /* parser_parse_source */
/**
@ -2788,11 +2844,10 @@ parser_parse_script (const uint8_t *arg_list_p, /**< function argument list */
size_t arg_list_size, /**< size of function argument list */
const uint8_t *source_p, /**< source code */
size_t source_size, /**< size of the source code */
ecma_value_t resource_name, /**< resource name */
uint32_t parse_opts) /**< ecma_parse_opts_t option bits */
uint32_t parse_opts, /**< ecma_parse_opts_t option bits */
const ecma_parse_options_t *options_p) /**< additional configuration options */
{
#if JERRY_PARSER
parser_error_location_t parser_error;
#if JERRY_DEBUGGER
if (JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_CONNECTED)
@ -2808,69 +2863,12 @@ parser_parse_script (const uint8_t *arg_list_p, /**< function argument list */
arg_list_size,
source_p,
source_size,
resource_name,
parse_opts,
&parser_error);
options_p);
if (JERRY_UNLIKELY (bytecode_p == NULL))
{
#if JERRY_DEBUGGER
if (JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_CONNECTED)
{
jerry_debugger_send_type (JERRY_DEBUGGER_PARSE_ERROR);
}
#endif /* JERRY_DEBUGGER */
if (parser_error.error == PARSER_ERR_OUT_OF_MEMORY)
{
/* It is unlikely that memory can be allocated in an out-of-memory
* situation. However, a simple value can still be thrown. */
jcontext_raise_exception (ECMA_VALUE_NULL);
return NULL;
}
#if JERRY_ERROR_MESSAGES
ecma_string_t *err_str_p;
if (parser_error.error == PARSER_ERR_INVALID_REGEXP)
{
ecma_value_t error = jcontext_take_exception ();
ecma_property_t *prop_p = ecma_find_named_property (ecma_get_object_from_value (error),
ecma_get_magic_string (LIT_MAGIC_STRING_MESSAGE));
ecma_free_value (error);
JERRY_ASSERT (prop_p);
err_str_p = ecma_get_string_from_value (ECMA_PROPERTY_VALUE_PTR (prop_p)->value);
ecma_ref_ecma_string (err_str_p);
}
else
{
const lit_utf8_byte_t *err_bytes_p = (const lit_utf8_byte_t *) parser_error_to_string (parser_error.error);
lit_utf8_size_t err_bytes_size = lit_zt_utf8_string_size (err_bytes_p);
err_str_p = ecma_new_ecma_string_from_utf8 (err_bytes_p, err_bytes_size);
}
ecma_value_t err_str_val = ecma_make_string_value (err_str_p);
ecma_value_t line_str_val = ecma_make_uint32_value (parser_error.line);
ecma_value_t col_str_val = ecma_make_uint32_value (parser_error.column);
ecma_raise_standard_error_with_format (ECMA_ERROR_SYNTAX,
"% [%:%:%]",
err_str_val,
resource_name,
line_str_val,
col_str_val);
ecma_free_value (col_str_val);
ecma_free_value (line_str_val);
ecma_deref_ecma_string (err_str_p);
#else /* !JERRY_ERROR_MESSAGES */
if (parser_error.error == PARSER_ERR_INVALID_REGEXP)
{
jcontext_release_exception ();
}
ecma_raise_syntax_error ("");
#endif /* JERRY_ERROR_MESSAGES */
/* Exception has already thrown. */
return NULL;
}

19
jerry-core/parser/js/js-parser.h
View File

@ -191,24 +191,11 @@ typedef enum
*/
typedef uint32_t parser_line_counter_t;
/**
* Error code location.
*/
typedef struct
{
parser_error_t error; /**< error code */
parser_line_counter_t line; /**< line where the error occured */
parser_line_counter_t column; /**< column where the error occured */
} parser_error_location_t;
/* Note: source must be a valid UTF-8 string */
ecma_compiled_code_t *
parser_parse_script (const uint8_t *arg_list_p,
size_t arg_list_size,
const uint8_t *source_p,
size_t source_size,
ecma_value_t resource_name,
uint32_t parse_opts);
parser_parse_script (const uint8_t *arg_list_p, size_t arg_list_size,
const uint8_t *source_p, size_t source_size,
uint32_t parse_opts, const ecma_parse_options_t *options_p);
#if JERRY_ERROR_MESSAGES
const char *parser_error_to_string (parser_error_t);

6
jerry-core/parser/js/js-scanner.c
View File

@ -2472,9 +2472,6 @@ scanner_scan_all (parser_context_t *context_p, /**< context */
PARSER_TRY (context_p->try_buffer)
{
context_p->line = 1;
context_p->column = 1;
if (arg_list_p == NULL)
{
context_p->source_p = source_p;
@ -3085,8 +3082,7 @@ scanner_scan_all (parser_context_t *context_p, /**< context */
context_p->next_scanner_info_p = scanner_info_p;
context_p->source_p = source_p;
context_p->source_end_p = source_end_p;
context_p->line = 1;
context_p->column = 1;
lexer_init_line_info (context_p);
#if JERRY_ESNEXT
scanner_filter_arguments (context_p, &scanner_context);

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

@ -376,24 +376,27 @@ process_generate (cli_state_t *cli_state_p, /**< cli state */
jerry_value_t snapshot_result;
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name_p = (jerry_char_t *) file_name_p;
parse_options.resource_name_length = (size_t) strlen (file_name_p);
if (function_args_p != NULL)
{
snapshot_result = jerry_generate_function_snapshot ((jerry_char_t *) file_name_p,
(size_t) strlen (file_name_p),
(jerry_char_t *) source_p,
snapshot_result = jerry_generate_function_snapshot ((jerry_char_t *) source_p,
source_length,
(const jerry_char_t *) function_args_p,
strlen (function_args_p),
&parse_options,
snapshot_flags,
output_buffer,
sizeof (output_buffer) / sizeof (uint32_t));
}
else
{
snapshot_result = jerry_generate_snapshot ((jerry_char_t *) file_name_p,
(size_t) strlen (file_name_p),
(jerry_char_t *) source_p,
snapshot_result = jerry_generate_snapshot ((jerry_char_t *) source_p,
source_length,
&parse_options,
snapshot_flags,
output_buffer,
sizeof (output_buffer) / sizeof (uint32_t));

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

@ -92,7 +92,7 @@ run (void)
}
else
{
ret_value = jerry_parse (NULL, 0, source_p, source_size, JERRY_PARSE_NO_OPTS);
ret_value = jerry_parse (source_p, source_size, NULL);
if (!jerry_value_is_error (ret_value))
{

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

@ -117,11 +117,14 @@ restart:
goto exit;
}
ret_value = jerry_parse ((jerry_char_t *) file_path_p,
strlen (file_path_p),
source_p,
jerry_parse_options_t parse_options;
parse_options.options = parse_opts | JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name_p = (jerry_char_t *) file_path_p;
parse_options.resource_name_length = (size_t) strlen (file_path_p);
ret_value = jerry_parse (source_p,
source_size,
parse_opts);
&parse_options);
jerry_port_release_source (source_p);
@ -204,7 +207,7 @@ restart:
source_size = new_size;
}
ret_value = jerry_parse (NULL, 0, (jerry_char_t *) source_p, source_size, JERRY_PARSE_NO_OPTS);
ret_value = jerry_parse ((jerry_char_t *) source_p, source_size, NULL);
free (source_p);
if (jerry_value_is_error (ret_value))
@ -254,7 +257,7 @@ restart:
continue;
}
ret_value = jerry_parse (NULL, 0, (jerry_char_t *) str_p, len, JERRY_PARSE_NO_OPTS);
ret_value = jerry_parse ((jerry_char_t *) str_p, len, NULL);
if (jerry_value_is_error (ret_value))
{

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

@ -128,7 +128,7 @@ test262_eval_script (const jerry_call_info_t *call_info_p, /**< call information
return jerry_create_error (JERRY_ERROR_RANGE, (jerry_char_t *) "Internal error");
}
jerry_value_t ret_value = jerry_parse (NULL, 0, str_buf_p, str_size, JERRY_PARSE_NO_OPTS);
jerry_value_t ret_value = jerry_parse (str_buf_p, str_size, NULL);
if (!jerry_value_is_error (ret_value))
{
@ -430,11 +430,15 @@ main_wait_for_source_callback (const jerry_char_t *resource_name_p, /**< resourc
void *user_p) /**< user pointer */
{
(void) user_p; /* unused */
jerry_value_t ret_val = jerry_parse (resource_name_p,
resource_name_size,
source_p,
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name_p = resource_name_p;
parse_options.resource_name_length = resource_name_size;
jerry_value_t ret_val = jerry_parse (source_p,
source_size,
JERRY_PARSE_NO_OPTS);
&parse_options);
if (!jerry_value_is_error (ret_val))
{

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

@ -42,7 +42,7 @@ static int load_javascript() {
const jerry_char_t* code = reinterpret_cast<const jerry_char_t*>(js_codes[src].source);
const size_t length = js_codes[src].length;
jerry_value_t parsed_code = jerry_parse(NULL, 0, code, length, JERRY_PARSE_NO_OPTS);
jerry_value_t parsed_code = jerry_parse(code, length, NULL);
if (jerry_value_is_error(parsed_code)) {
LOG_PRINT_ALWAYS("jerry_parse failed [%s]\r\n", js_codes[src].name);

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

@ -397,7 +397,7 @@ int jerry_main (int argc, char *argv[])
printf ("No input files, running a hello world demo:\n");
const jerry_char_t script[] = "var str = 'Hello World'; print(str + ' from JerryScript')";
ret_value = jerry_parse (NULL, 0, script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
ret_value = jerry_parse (script, sizeof (script) - 1, NULL);
if (!jerry_value_is_error (ret_value))
{
@ -417,11 +417,14 @@ int jerry_main (int argc, char *argv[])
return JERRY_STANDALONE_EXIT_CODE_FAIL;
}
ret_value = jerry_parse ((jerry_char_t *) file_names[i],
strlen (file_names[i]),
source_p,
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name_p = (const jerry_char_t *) file_names[i];
parse_options.resource_name_length = strlen (file_names[i]);
ret_value = jerry_parse (source_p,
source_size,
JERRY_PARSE_NO_OPTS);
&parse_options);
free ((void*) source_p);
if (!jerry_value_is_error (ret_value))

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

@ -65,7 +65,7 @@ int test_jerry (int argc, char **argv)
register_js_function ("print", jerryx_handler_print);
/* Setup Global scope code */
ret_value = jerry_parse (NULL, 0, script, sizeof (script) - 1, JERRY_PARSE_NO_OPTS);
ret_value = jerry_parse (script, sizeof (script) - 1, NULL);
if (!jerry_value_is_error (ret_value))
{

12
tests/unit-core/test-abort.c
View File

@ -62,11 +62,9 @@ main (void)
"}"
);
jerry_value_t parsed_code_val = jerry_parse (NULL,
0,
inf_loop_code_src1,
jerry_value_t parsed_code_val = jerry_parse (inf_loop_code_src1,
sizeof (inf_loop_code_src1) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
res = jerry_run (parsed_code_val);
@ -97,11 +95,9 @@ main (void)
" f();\n"
);
parsed_code_val = jerry_parse (NULL,
0,
inf_loop_code_src2,
parsed_code_val = jerry_parse (inf_loop_code_src2,
sizeof (inf_loop_code_src2) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
res = jerry_run (parsed_code_val);

6
tests/unit-core/test-api-errortype.c
View File

@ -64,11 +64,9 @@ main (void)
char test_source[] = "\xF0\x9D\x84\x9E";
jerry_value_t result = jerry_parse (NULL,
0,
(const jerry_char_t *) test_source,
jerry_value_t result = jerry_parse ((const jerry_char_t *) test_source,
sizeof (test_source) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (jerry_value_is_error (result));
TEST_ASSERT (jerry_get_error_type (result) == JERRY_ERROR_SYNTAX);

9
tests/unit-core/test-api-objecttype.c
View File

@ -28,7 +28,7 @@ typedef struct
#define ENTRY(TYPE, VALUE) { TYPE, VALUE, true }
#define ENTRY_IF(TYPE, VALUE, FEATURE) { TYPE, VALUE, jerry_is_feature_enabled (FEATURE) }
#define EVALUATE(BUFF) (jerry_eval ((BUFF), sizeof ((BUFF)) - 1, JERRY_PARSE_NO_OPTS))
#define PARSE(OPTS) (jerry_parse (NULL, 0, (const jerry_char_t *) "", 0, (OPTS)))
#define PARSE(OPTS) (jerry_parse ((const jerry_char_t *) "", 0, (OPTS)))
static jerry_value_t
test_ext_function (const jerry_call_info_t *call_info_p, /**< call information */
const jerry_value_t args_p[], /**< array of arguments */
@ -75,6 +75,9 @@ main (void)
const jerry_char_t string_object[] = "new String('foo')";
const jerry_char_t weak_ref_object[] = "new WeakRef({})";
jerry_parse_options_t module_parse_options;
module_parse_options.options = JERRY_PARSE_MODULE;
test_entry_t entries[] =
{
ENTRY (JERRY_OBJECT_TYPE_NONE, jerry_create_number (-33.0)),
@ -92,8 +95,8 @@ main (void)
ENTRY_IF (JERRY_OBJECT_TYPE_CONTAINER, EVALUATE (container_object), JERRY_FEATURE_MAP),
ENTRY_IF (JERRY_OBJECT_TYPE_ITERATOR, EVALUATE (iterator_object), JERRY_FEATURE_SYMBOL),
ENTRY (JERRY_OBJECT_TYPE_SCRIPT, PARSE (JERRY_PARSE_NO_OPTS)),
ENTRY_IF (JERRY_OBJECT_TYPE_MODULE, PARSE (JERRY_PARSE_MODULE), JERRY_FEATURE_MODULE),
ENTRY (JERRY_OBJECT_TYPE_SCRIPT, PARSE (NULL)),
ENTRY_IF (JERRY_OBJECT_TYPE_MODULE, PARSE (&module_parse_options), JERRY_FEATURE_MODULE),
ENTRY_IF (JERRY_OBJECT_TYPE_FUNCTION, EVALUATE (arrow_function), JERRY_FEATURE_SYMBOL),
ENTRY_IF (JERRY_OBJECT_TYPE_FUNCTION, EVALUATE (async_arrow_function), JERRY_FEATURE_SYMBOL),
ENTRY_IF (JERRY_OBJECT_TYPE_FUNCTION, EVALUATE (generator_function), JERRY_FEATURE_SYMBOL),

6
tests/unit-core/test-api-promise.c
View File

@ -157,11 +157,9 @@ test_promise_from_js (void)
{
const jerry_char_t test_source[] = "(new Promise(function(rs, rj) { rs(30); })).then(function(v) { return v + 1; })";
jerry_value_t parsed_code_val = jerry_parse (NULL,
0,
test_source,
jerry_value_t parsed_code_val = jerry_parse (test_source,
sizeof (test_source) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
jerry_value_t res = jerry_run (parsed_code_val);

180
tests/unit-core/test-api.c
View File

@ -344,6 +344,42 @@ test_run_simple (const char *script_p) /**< source code to run */
return jerry_run_simple ((const jerry_char_t *) script_p, script_size, JERRY_INIT_EMPTY);
} /* test_run_simple */
static void
test_syntax_error (const char *script_p, /**< source code to run */
const jerry_parse_options_t *options_p, /**< additional parsing options */
const char *error_message_p, /**< error message */
bool run_script) /**< run script before checking the error message */
{
jerry_value_t result_val = jerry_parse ((const jerry_char_t *) script_p,
strlen (script_p),
options_p);
if (run_script)
{
TEST_ASSERT (!jerry_value_is_error (result_val));
jerry_value_t script_val = result_val;
result_val = jerry_run (script_val);
jerry_release_value (script_val);
}
TEST_ASSERT (jerry_value_is_error (result_val));
result_val = jerry_get_value_from_error (result_val, true);
jerry_value_t err_str_val = jerry_value_to_string (result_val);
jerry_size_t err_str_size = jerry_get_string_size (err_str_val);
jerry_char_t err_str_buf[256];
TEST_ASSERT (err_str_size <= sizeof (err_str_buf));
TEST_ASSERT (err_str_size == strlen (error_message_p));
TEST_ASSERT (jerry_string_to_char_buffer (err_str_val, err_str_buf, err_str_size) == err_str_size);
jerry_release_value (err_str_val);
jerry_release_value (result_val);
TEST_ASSERT (memcmp ((char *) err_str_buf, error_message_p, err_str_size) == 0);
} /* test_syntax_error */
int
main (void)
{
@ -367,11 +403,9 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
parsed_code_val = jerry_parse (NULL,
0,
test_source,
parsed_code_val = jerry_parse (test_source,
sizeof (test_source) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
res = jerry_run (parsed_code_val);
@ -803,17 +837,14 @@ main (void)
jerry_release_value (val_t);
/* Test: create function */
const jerry_char_t func_resource[] = "unknown";
const jerry_char_t func_arg_list[] = "a , b,c";
const jerry_char_t func_src[] = " return 5 + a+\nb+c";
jerry_value_t func_val = jerry_parse_function (func_resource,
sizeof (func_resource) - 1,
func_arg_list,
jerry_value_t func_val = jerry_parse_function (func_arg_list,
sizeof (func_arg_list) - 1,
func_src,
sizeof (func_src) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (func_val));
@ -859,19 +890,15 @@ main (void)
{
jerry_init (JERRY_INIT_EMPTY);
const jerry_char_t scoped_src_p[] = "let a; this.b = 5";
jerry_value_t parse_result = jerry_parse (NULL,
0,
scoped_src_p,
jerry_value_t parse_result = jerry_parse (scoped_src_p,
sizeof (scoped_src_p) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parse_result));
jerry_release_value (parse_result);
parse_result = jerry_parse (NULL,
0,
scoped_src_p,
parse_result = jerry_parse (scoped_src_p,
sizeof (scoped_src_p) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parse_result));
jerry_value_t run_result = jerry_run (parse_result);
@ -885,21 +912,17 @@ main (void)
jerry_release_value (parse_result);
/* The variable should have no effect on parsing. */
parse_result = jerry_parse (NULL,
0,
scoped_src_p,
parse_result = jerry_parse (scoped_src_p,
sizeof (scoped_src_p) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parse_result));
jerry_release_value (parse_result);
/* The already existing global binding should not affect a new lexical binding */
const jerry_char_t scoped_src2_p[] = "let b = 6; this.b + b";
parse_result = jerry_parse (NULL,
0,
scoped_src2_p,
parse_result = jerry_parse (scoped_src2_p,
sizeof (scoped_src2_p) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parse_result));
run_result = jerry_run (parse_result);
TEST_ASSERT (jerry_value_is_number (run_result));
@ -909,11 +932,9 @@ main (void)
/* Check restricted global property */
const jerry_char_t scoped_src3_p[] = "let undefined;";
parse_result = jerry_parse (NULL,
0,
scoped_src3_p,
parse_result = jerry_parse (scoped_src3_p,
sizeof (scoped_src3_p) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parse_result));
run_result = jerry_run (parse_result);
TEST_ASSERT (jerry_value_is_error (run_result));
@ -937,11 +958,9 @@ main (void)
jerry_release_value (global_obj);
const jerry_char_t scoped_src4_p[] = "let foo;";
parse_result = jerry_parse (NULL,
0,
scoped_src4_p,
parse_result = jerry_parse (scoped_src4_p,
sizeof (scoped_src4_p) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parse_result));
run_result = jerry_run (parse_result);
TEST_ASSERT (jerry_value_is_error (run_result));
@ -963,11 +982,9 @@ main (void)
jerry_value_t old_realm = jerry_set_realm (new_realm_value);
const jerry_char_t scoped_src5_p[] = "let a;";
parse_result = jerry_parse (NULL,
0,
scoped_src5_p,
parse_result = jerry_parse (scoped_src5_p,
sizeof (scoped_src5_p) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parse_result));
run_result = jerry_run (parse_result);
TEST_ASSERT (jerry_value_is_error (run_result));
@ -994,11 +1011,9 @@ main (void)
old_realm = jerry_set_realm (new_realm_value);
const jerry_char_t scoped_src6_p[] = "let b;";
parse_result = jerry_parse (NULL,
0,
scoped_src6_p,
parse_result = jerry_parse (scoped_src6_p,
sizeof (scoped_src6_p) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parse_result));
run_result = jerry_run (parse_result);
TEST_ASSERT (jerry_value_is_error (run_result));
@ -1021,66 +1036,35 @@ main (void)
{
jerry_init (JERRY_INIT_SHOW_OPCODES);
const jerry_char_t parser_err_src[] = "b = 'hello';\nvar a = (;";
parsed_code_val = jerry_parse (NULL,
0,
parser_err_src,
sizeof (parser_err_src) - 1,
JERRY_PARSE_NO_OPTS);
TEST_ASSERT (jerry_value_is_error (parsed_code_val));
parsed_code_val = jerry_get_value_from_error (parsed_code_val, true);
jerry_value_t err_str_val = jerry_value_to_string (parsed_code_val);
jerry_size_t err_str_size = jerry_get_string_size (err_str_val);
jerry_char_t err_str_buf[256];
sz = jerry_string_to_char_buffer (err_str_val, err_str_buf, err_str_size);
err_str_buf[sz] = 0;
jerry_release_value (err_str_val);
jerry_release_value (parsed_code_val);
TEST_ASSERT (!strcmp ((char *) err_str_buf,
"SyntaxError: Primary expression expected [<anonymous>:2:10]"));
test_syntax_error ("b = 'hello';\nvar a = (;",
NULL,
"SyntaxError: Primary expression expected [<anonymous>:2:10]",
false);
const jerry_char_t file_str[] = "filename.js";
parsed_code_val = jerry_parse (file_str,
sizeof (file_str) - 1,
parser_err_src,
sizeof (parser_err_src) - 1,
JERRY_PARSE_NO_OPTS);
TEST_ASSERT (jerry_value_is_error (parsed_code_val));
parsed_code_val = jerry_get_value_from_error (parsed_code_val, true);
err_str_val = jerry_value_to_string (parsed_code_val);
err_str_size = jerry_get_string_size (err_str_val);
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name_p = file_str;
parse_options.resource_name_length = sizeof (file_str) - 1;
sz = jerry_string_to_char_buffer (err_str_val, err_str_buf, err_str_size);
err_str_buf[sz] = 0;
test_syntax_error ("b = 'hello';\nvar a = (;",
&parse_options,
"SyntaxError: Primary expression expected [filename.js:2:10]",
false);
jerry_release_value (err_str_val);
jerry_release_value (parsed_code_val);
TEST_ASSERT (!strcmp ((char *) err_str_buf,
"SyntaxError: Primary expression expected [filename.js:2:10]"));
test_syntax_error ("eval(\"var b;\\nfor (,); \");",
&parse_options,
"SyntaxError: Primary expression expected [<eval>:2:6]",
true);
const jerry_char_t eval_err_src[] = "eval(\"var b;\\nfor (,); \");";
parsed_code_val = jerry_parse (file_str,
sizeof (file_str),
eval_err_src,
sizeof (eval_err_src) - 1,
JERRY_PARSE_NO_OPTS);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
parse_options.options |= JERRY_PARSE_HAS_START;
parse_options.start_line = 10;
parse_options.start_column = 20;
res = jerry_run (parsed_code_val);
TEST_ASSERT (jerry_value_is_error (res));
res = jerry_get_value_from_error (res, true);
err_str_val = jerry_value_to_string (res);
err_str_size = jerry_get_string_size (err_str_val);
sz = jerry_string_to_char_buffer (err_str_val, err_str_buf, err_str_size);
err_str_buf[sz] = 0;
jerry_release_value (err_str_val);
jerry_release_value (parsed_code_val);
jerry_release_value (res);
TEST_ASSERT (!strcmp ((char *) err_str_buf,
"SyntaxError: Primary expression expected [<eval>:2:6]"));
test_syntax_error ("for (var a in []",
&parse_options,
"SyntaxError: Expected ')' token [filename.js:10:36]",
false);
jerry_cleanup ();
}
@ -1094,11 +1078,9 @@ main (void)
magic_string_lengths);
const jerry_char_t ms_code_src[] = "var global = {}; var console = [1]; var process = 1;";
parsed_code_val = jerry_parse (NULL,
0,
ms_code_src,
parsed_code_val = jerry_parse (ms_code_src,
sizeof (ms_code_src) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
res = jerry_run (parsed_code_val);

11
tests/unit-core/test-backtrace.c
View File

@ -136,11 +136,14 @@ static jerry_value_t
run (const char *resource_name_p, /**< resource name */
const char *source_p) /**< source code */
{
jerry_value_t code = jerry_parse ((const jerry_char_t *) resource_name_p,
strlen (resource_name_p),
(const jerry_char_t *) source_p,
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
parse_options.resource_name_p = (const jerry_char_t *) resource_name_p;
parse_options.resource_name_length = strlen (resource_name_p);
jerry_value_t code = jerry_parse ((const jerry_char_t *) source_p,
strlen (source_p),
JERRY_PARSE_NO_OPTS);
&parse_options);
TEST_ASSERT (!jerry_value_is_error (code));
jerry_value_t result = jerry_run (code);

12
tests/unit-core/test-exec-stop.c
View File

@ -50,11 +50,9 @@ main (void)
jerry_set_vm_exec_stop_callback (vm_exec_stop_callback, &countdown, 16);
const jerry_char_t inf_loop_code_src1[] = "while(true) {}";
jerry_value_t parsed_code_val = jerry_parse (NULL,
0,
inf_loop_code_src1,
jerry_value_t parsed_code_val = jerry_parse (inf_loop_code_src1,
sizeof (inf_loop_code_src1) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
jerry_value_t res = jerry_run (parsed_code_val);
@ -76,11 +74,9 @@ main (void)
"try { f(); } catch(e) {}"
);
parsed_code_val = jerry_parse (NULL,
0,
inf_loop_code_src2,
parsed_code_val = jerry_parse (inf_loop_code_src2,
sizeof (inf_loop_code_src2) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
res = jerry_run (parsed_code_val);

6
tests/unit-core/test-mem-stats.c
View File

@ -29,11 +29,9 @@ int main (void)
);
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t parsed_code_val = jerry_parse (NULL,
0,
test_source,
jerry_value_t parsed_code_val = jerry_parse (test_source,
sizeof (test_source) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
jerry_value_t res = jerry_run (parsed_code_val);

18
tests/unit-core/test-newtarget.c
View File

@ -150,11 +150,9 @@ main (void)
{
static const jerry_char_t test_source[] = TEST_STRING_LITERAL ("new Demo (1)");
jerry_value_t parsed_code_val = jerry_parse (NULL,
0,
test_source,
jerry_value_t parsed_code_val = jerry_parse (test_source,
sizeof (test_source) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
jerry_value_t res = jerry_run (parsed_code_val);
@ -167,11 +165,9 @@ main (void)
{
static const jerry_char_t test_source[] = TEST_STRING_LITERAL ("Demo (2)");
jerry_value_t parsed_code_val = jerry_parse (NULL,
0,
test_source,
jerry_value_t parsed_code_val = jerry_parse (test_source,
sizeof (test_source) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
jerry_value_t res = jerry_run (parsed_code_val);
@ -189,11 +185,9 @@ main (void)
"new base(3);"
);
jerry_value_t parsed_code_val = jerry_parse (NULL,
0,
test_source,
jerry_value_t parsed_code_val = jerry_parse (test_source,
sizeof (test_source) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
jerry_value_t res = jerry_run (parsed_code_val);

9
tests/unit-core/test-objects-foreach.c
View File

@ -183,12 +183,13 @@ main (void)
{
jerry_init (JERRY_INIT_EMPTY);
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_STRICT_MODE;
/* Render strict-equal as a function. */
jerry_value_t parse_result = jerry_parse (NULL,
0,
strict_equal_source,
jerry_value_t parse_result = jerry_parse (strict_equal_source,
sizeof (strict_equal_source) - 1,
JERRY_PARSE_STRICT_MODE);
&parse_options);
TEST_ASSERT (!jerry_value_is_error (parse_result));
jerry_value_t strict_equal = jerry_run (parse_result);
TEST_ASSERT (!jerry_value_is_error (strict_equal));

6
tests/unit-core/test-promise.c
View File

@ -122,11 +122,9 @@ main (void)
register_js_function ("create_promise2", create_promise2_handler);
register_js_function ("assert", assert_handler);
jerry_value_t parsed_code_val = jerry_parse (NULL,
0,
test_source,
jerry_value_t parsed_code_val = jerry_parse (test_source,
sizeof (test_source) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
jerry_value_t res = jerry_run (parsed_code_val);

20
tests/unit-core/test-proxy.c
View File

@ -243,11 +243,9 @@ main (void)
}
const jerry_char_t get_value_src[] = TEST_STRING_LITERAL ("pdemo.value");
jerry_value_t parsed_get_code_val = jerry_parse (NULL,
0,
get_value_src,
sizeof (get_value_src) - 1,
JERRY_PARSE_NO_OPTS);
jerry_value_t parsed_get_code_val = jerry_parse (get_value_src,
sizeof (get_value_src) - 1,
NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_get_code_val));
{
@ -272,11 +270,9 @@ main (void)
}
const jerry_char_t set_value_src[] = TEST_STRING_LITERAL ("pdemo.value = 55");
jerry_value_t parsed_set_code_val = jerry_parse (NULL,
0,
set_value_src,
jerry_value_t parsed_set_code_val = jerry_parse (set_value_src,
sizeof (set_value_src) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_set_code_val));
{
@ -316,11 +312,9 @@ main (void)
const jerry_char_t has_value_src[] = TEST_STRING_LITERAL ("new Proxy({}, {\n"
" has: function(target, key) { throw 33 }\n"
"})");
jerry_value_t parsed_has_code_val = jerry_parse (NULL,
0,
has_value_src,
jerry_value_t parsed_has_code_val = jerry_parse (has_value_src,
sizeof (has_value_src) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_has_code_val));
jerry_value_t res = jerry_run (parsed_has_code_val);

6
tests/unit-core/test-realm.c
View File

@ -235,11 +235,9 @@ main (void)
TEST_ASSERT (!jerry_value_is_error (result_value));
const char *script_p = "global2 = global1 - 1; Object.getPrototypeOf([])";
jerry_value_t script_value = jerry_parse (NULL,
0,
(const jerry_char_t *) script_p,
jerry_value_t script_value = jerry_parse ((const jerry_char_t *) script_p,
strlen (script_p),
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (script_value));
jerry_set_realm (result_value);

7
tests/unit-core/test-regexp-dotall-unicode.c
View File

@ -36,16 +36,13 @@ main (void)
jerry_value_t regex_obj = jerry_create_regexp (pattern2, flags);
TEST_ASSERT (jerry_value_is_object (regex_obj));
const jerry_char_t func_resource[] = "unknown";
const jerry_char_t func_arg_list[] = "regex";
const jerry_char_t func_src2[] = "return [regex.exec('a\\nb'), regex.dotAll, regex.sticky, regex.unicode ];";
jerry_value_t func_val = jerry_parse_function (func_resource,
sizeof (func_resource) - 1,
func_arg_list,
jerry_value_t func_val = jerry_parse_function (func_arg_list,
sizeof (func_arg_list) - 1,
func_src2,
sizeof (func_src2) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
jerry_value_t res = jerry_call_function (func_val, undefined_this_arg, &regex_obj, 1);
jerry_value_t regex_res = jerry_get_property_by_index (res, 0);

7
tests/unit-core/test-regexp.c
View File

@ -30,16 +30,13 @@ main (void)
jerry_value_t regex_obj = jerry_create_regexp (pattern, flags);
TEST_ASSERT (jerry_value_is_object (regex_obj));
const jerry_char_t func_resource[] = "unknown";
const jerry_char_t func_arg_list[] = "regex";
const jerry_char_t func_src[] = "return [regex.exec('something.domain.com'), regex.multiline, regex.global];";
jerry_value_t func_val = jerry_parse_function (func_resource,
sizeof (func_resource) - 1,
func_arg_list,
jerry_value_t func_val = jerry_parse_function (func_arg_list,
sizeof (func_arg_list) - 1,
func_src,
sizeof (func_src) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
jerry_value_t res = jerry_call_function (func_val, global_obj_val, &regex_obj, 1);
jerry_value_t regex_res = jerry_get_property_by_index (res, 0);

12
tests/unit-core/test-regression-3588.c
View File

@ -66,11 +66,9 @@ main (void)
"new Sub1 ()"
);
jerry_value_t parsed_code_val = jerry_parse (NULL,
0,
test_source,
jerry_value_t parsed_code_val = jerry_parse (test_source,
sizeof (test_source) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
jerry_value_t result = jerry_run (parsed_code_val);
@ -86,11 +84,9 @@ main (void)
"new Sub2 (1)"
);
jerry_value_t parsed_code_val = jerry_parse (NULL,
0,
test_source,
jerry_value_t parsed_code_val = jerry_parse (test_source,
sizeof (test_source) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
jerry_value_t result = jerry_run (parsed_code_val);

21
tests/unit-core/test-resource-name.c
View File

@ -58,6 +58,9 @@ main (void)
jerry_release_value (global);
jerry_parse_options_t parse_options;
parse_options.options = JERRY_PARSE_HAS_RESOURCE;
const char *source_1 = ("function f1 () {\n"
" if (resourceName() !== 'demo1.js') return false; \n"
" if (resourceName(f1) !== 'demo1.js') return false; \n"
@ -67,11 +70,12 @@ main (void)
"f1();");
const char *resource_1 = "demo1.js";
jerry_value_t program = jerry_parse ((const jerry_char_t *) resource_1,
strlen (resource_1),
(const jerry_char_t *) source_1,
parse_options.resource_name_p = (const jerry_char_t *) resource_1;
parse_options.resource_name_length = strlen (resource_1);
jerry_value_t program = jerry_parse ((const jerry_char_t *) source_1,
strlen (source_1),
JERRY_PARSE_NO_OPTS);
&parse_options);
TEST_ASSERT (!jerry_value_is_error (program));
jerry_value_t run_result = jerry_run (program);
@ -98,11 +102,12 @@ main (void)
"f2(); \n");
const char *resource_2 = "demo2.js";
program = jerry_parse ((const jerry_char_t *) resource_2,
strlen (resource_2),
(const jerry_char_t *) source_2,
parse_options.resource_name_p = (const jerry_char_t *) resource_2;
parse_options.resource_name_length = strlen (resource_2);
program = jerry_parse ((const jerry_char_t *) source_2,
strlen (source_2),
JERRY_PARSE_NO_OPTS);
&parse_options);
TEST_ASSERT (!jerry_value_is_error (program));
run_result = jerry_run (program);

30
tests/unit-core/test-snapshot.c
View File

@ -68,12 +68,11 @@ static void test_function_snapshot (void)
jerry_init (flags);
jerry_value_t generate_result;
generate_result = jerry_generate_function_snapshot (NULL,
0,
code_to_snapshot,
generate_result = jerry_generate_function_snapshot (code_to_snapshot,
sizeof (code_to_snapshot) - 1,
func_args,
sizeof (func_args) - 1,
NULL,
0,
function_snapshot_buffer,
SNAPSHOT_BUFFER_SIZE);
@ -147,10 +146,9 @@ static void test_function_arguments_snapshot (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t generate_result;
generate_result = jerry_generate_snapshot (NULL,
0,
code_to_snapshot,
generate_result = jerry_generate_snapshot (code_to_snapshot,
sizeof (code_to_snapshot) - 1,
NULL,
0,
arguments_snapshot_buffer,
SNAPSHOT_BUFFER_SIZE);
@ -216,10 +214,9 @@ main (void)
magic_string_lengths);
jerry_value_t generate_result;
generate_result = jerry_generate_snapshot (NULL,
0,
code_to_snapshot,
generate_result = jerry_generate_snapshot (code_to_snapshot,
sizeof (code_to_snapshot) - 1,
NULL,
JERRY_SNAPSHOT_SAVE_STATIC,
snapshot_buffer,
SNAPSHOT_BUFFER_SIZE);
@ -252,10 +249,9 @@ main (void)
jerry_init (JERRY_INIT_EMPTY);
jerry_value_t generate_result;
generate_result = jerry_generate_snapshot (NULL,
0,
code_to_snapshot1,
generate_result = jerry_generate_snapshot (code_to_snapshot1,
sizeof (code_to_snapshot1) - 1,
NULL,
0,
snapshot_buffer_0,
SNAPSHOT_BUFFER_SIZE);
@ -270,10 +266,9 @@ main (void)
const jerry_char_t code_to_snapshot2[] = "var b = 'hello'; 456";
jerry_init (JERRY_INIT_EMPTY);
generate_result = jerry_generate_snapshot (NULL,
0,
code_to_snapshot2,
generate_result = jerry_generate_snapshot (code_to_snapshot2,
sizeof (code_to_snapshot2) - 1,
NULL,
0,
snapshot_buffer_1,
SNAPSHOT_BUFFER_SIZE);
@ -337,10 +332,9 @@ main (void)
static const jerry_char_t code_for_c_format[] = "var object = { aa:'fo\" o\\n \\\\', Bb:'max', aaa:'xzy0' };";
jerry_value_t generate_result;
generate_result = jerry_generate_snapshot (NULL,
0,
code_for_c_format,
generate_result = jerry_generate_snapshot (code_for_c_format,
sizeof (code_for_c_format) - 1,
NULL,
0,
literal_snapshot_buffer,
SNAPSHOT_BUFFER_SIZE);

6
tests/unit-core/test-unicode.c
View File

@ -19,11 +19,9 @@
static bool
test_syntax_error (char *script_p) /**< script */
{
jerry_value_t parse_result = jerry_parse (NULL,
0,
(const jerry_char_t *) script_p,
jerry_value_t parse_result = jerry_parse ((const jerry_char_t *) script_p,
strlen (script_p),
JERRY_PARSE_NO_OPTS);
NULL);
bool result = false;

6
tests/unit-ext/test-ext-arg.c
View File

@ -902,11 +902,9 @@ main (void)
register_js_function ("test_validator_array2", test_validator_array2_handler);
register_js_function ("test_validator_restore", test_validator_restore_handler);
jerry_value_t parsed_code_val = jerry_parse (NULL,
0,
test_source,
jerry_value_t parsed_code_val = jerry_parse (test_source,
sizeof (test_source) - 1,
JERRY_PARSE_NO_OPTS);
NULL);
TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
jerry_value_t res = jerry_run (parsed_code_val);