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

JerryScript-DCO-1.0-Signed-off-by: Zoltan Herczeg zherczeg.u-szeged@partner.samsung.com

docs/02.API-REFERENCE.md

@@ -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
+Option bits for [jerry_parse_options_t](#jerry_parse_options_t).
-[jerry_parse_function](#jerry_parse_function) functions:
 
- - JERRY_PARSE_NO_OPTS - no options passed
+ - JERRY_PARSE_NO_OPTS - No options passed
- - JERRY_PARSE_STRICT_MODE - enable strict mode
+ - JERRY_PARSE_STRICT_MODE - Enable strict mode
- - JERRY_PARSE_MODULE - parse source as an ECMAScript module
+ - 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) */
+jerry_parse (const jerry_char_t *source_p,
-             size_t resource_name_length, /**< length of resource name */
-             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) */
+jerry_parse_function (const jerry_char_t *arg_list_p,
-                      size_t resource_name_length, /**< length of resource name */
+                      size_t arg_list_size,
-                      const jerry_char_t *arg_list_p, /**< script source */
+                      const jerry_char_t *source_p,
-                      size_t arg_list_size, /**< script source size */
+                      size_t source_size,
-                      const jerry_char_t *source_p, /**< script source */
+                      const jerry_parse_options_t *options_p);
-                      size_t source_size, /**< script source size */
-                      uint32_t parse_opts) /**< strict mode */
 ```
 
-- `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,
+  jerry_value_t parsed_function = jerry_parse_function ((const jerry_char_t *) function_args,
-                                                        0,
-                                                        (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,
+jerry_generate_snapshot (const jerry_char_t *source_p,
-                         size_t resource_name_length,
-                         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,
+  generate_result = jerry_generate_snapshot (script_to_snapshot,
-                                             0,
-                                             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,
+jerry_generate_function_snapshot (const jerry_char_t *source_p,
-                                  size_t resource_name_length,
-                                  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,
+  generate_result = jerry_generate_function_snapshot (src,
-                                                      0,
-                                                      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,
+  generate_result = jerry_generate_snapshot (script_to_snapshot,
-                                             0,
-                                             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,
+  generate_result = jerry_generate_function_snapshot (func_src,
-                                                      0,
-                                                      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,
+  jerry_value_t generate_result = jerry_generate_snapshot (script_for_literal_save,
-                                                           0,
-                                                           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,
+  jerry_parse_options_t parse_options;
-                                       strlen (resource),
+  parse_options.options = JERRY_PARSE_HAS_RESOURCE;
-                                       (const jerry_char_t *) source,
+  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,
+  jerry_parse_options_t parse_options;
-                                       strlen (resource),
+  parse_options.options = JERRY_PARSE_HAS_RESOURCE;
-                                       (const jerry_char_t *) source,
+  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,
+  jerry_parse_options_t parse_options;
-                                       sizeof (resource) - 1,
+  parse_options.options = JERRY_PARSE_HAS_RESOURCE;
-                                       source,
+  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))
   {

docs/03.API-EXAMPLE.md

@@ -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))
   {

docs/07.DEBUGGER.md

@@ -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,
+  jerry_parse_options_t parse_options;
-                                       resource_name_size,
+  parse_options.options = JERRY_PARSE_HAS_RESOURCE;
-                                       source_p,
+  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))
   {

jerry-core/api/jerry-snapshot.c

@@ -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 */
+jerry_generate_snapshot_with_args (const jerry_char_t *source_p, /**< script source */
-                                   size_t resource_name_length, /**< script resource name length */
-                                   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. */
+  uint32_t allowed_options = JERRY_SNAPSHOT_SAVE_STATIC;
-  JERRY_UNUSED (resource_name_p);
+  uint32_t allowed_parse_options = (JERRY_PARSE_STRICT_MODE
-  JERRY_UNUSED (resource_name_length);
+                                    | JERRY_PARSE_HAS_RESOURCE
+                                    | JERRY_PARSE_HAS_START);
 
-  ecma_value_t resource_name = ecma_make_magic_string_value (LIT_MAGIC_STRING_RESOURCE_ANON);
+  if ((generate_snapshot_opts & ~allowed_options) != 0
-
+      || (options_p != NULL && (options_p->options & ~allowed_parse_options) != 0))
-#if JERRY_RESOURCE_NAME
-  if (resource_name_length > 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
+  uint32_t status_flags = ECMA_PARSE_NO_OPTS;
-                                                                                 : 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 */
+jerry_generate_snapshot (const jerry_char_t *source_p, /**< script source */
-                         size_t resource_name_length, /**< script resource name length */
-                         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);
+  return jerry_generate_snapshot_with_args (source_p,
-
-  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,
                                             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 */
+jerry_generate_function_snapshot (const jerry_char_t *source_p, /**< script source */
-                                  size_t resource_name_length, /**< script resource name length */
-                                  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);
+  return jerry_generate_snapshot_with_args (source_p,
-
-  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,
                                             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);

jerry-core/api/jerry.c

@@ -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) */
+jerry_parse (const jerry_char_t *source_p, /**< script source */
-             size_t resource_name_length, /**< length of resource name */
-             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 (options_p != NULL && (options_p->options & ~allowed_parse_options) != 0)
-  if (resource_name_length > 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) */
+jerry_parse_function (const jerry_char_t *arg_list_p, /**< script source */
-                      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) /**< 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 (options_p != NULL && (options_p->options & ~allowed_parse_options) != 0)
-  if (resource_name_length > 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));

jerry-core/ecma/base/ecma-globals.h

@@ -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
 
 /**

jerry-core/ecma/base/ecma-module.c

@@ -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;
+  ecma_string_t *path_p = ecma_get_magic_string (LIT_MAGIC_STRING_RESOURCE_ANON);
-  uint8_t flags = ECMA_STRING_FLAG_EMPTY;
 
-  const lit_utf8_byte_t *path_str_chars_p = ecma_string_get_chars (root_path_p,
+  if (options_p != NULL
-                                                                   &path_str_size,
+      && (options_p->options & JERRY_PARSE_HAS_RESOURCE)
-                                                                   NULL,
+      && options_p->resource_name_length > 0)
-                                                                   NULL,
+  {
-                                                                   &flags);
+    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;
 
-  ecma_string_t *path_p = ecma_module_create_normalized_path (path_str_chars_p,
+    path_p = ecma_module_create_normalized_path (path_str_chars_p,
                                                  path_str_size,
                                                  NULL);
-
     if (path_p == NULL)
     {
-    ecma_ref_ecma_string (root_path_p);
+      path_p = ecma_new_ecma_string_from_utf8_converted_to_cesu8 (path_str_chars_p, path_str_size);
-    path_p = root_path_p;
+    }
   }
 
   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))

jerry-core/ecma/base/ecma-module.h

@@ -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);

jerry-core/ecma/operations/ecma-eval.c

@@ -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))
   {

jerry-core/ecma/operations/ecma-function-object.c

@@ -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);

jerry-core/include/jerryscript-core.h

@@ -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,
+jerry_value_t jerry_parse (const jerry_char_t *source_p, size_t source_size,
-                           const jerry_char_t *source_p, size_t source_size, uint32_t parse_opts);
+                           const jerry_parse_options_t *options_p);
-jerry_value_t jerry_parse_function (const jerry_char_t *resource_name_p, size_t resource_name_length,
+jerry_value_t jerry_parse_function (const jerry_char_t *arg_list_p, size_t arg_list_size,
-                                    const jerry_char_t *arg_list_p, size_t arg_list_size,
+                                    const jerry_char_t *source_p, size_t source_size,
-                                    const jerry_char_t *source_p, size_t source_size, uint32_t parse_opts);
+                                    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);
 

jerry-core/include/jerryscript-snapshot.h

@@ -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,
+jerry_value_t jerry_generate_snapshot (const jerry_char_t *source_p, size_t source_size,
-                                       const jerry_char_t *source_p, size_t source_size,
+                                       const jerry_parse_options_t *options_p, uint32_t generate_snapshot_opts,
-                                       uint32_t generate_snapshot_opts, uint32_t *buffer_p, size_t buffer_size);
+                                       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,
+jerry_value_t jerry_generate_function_snapshot (const jerry_char_t *source_p, size_t source_size,
-                                                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,
+                                                const jerry_parse_options_t *options_p,
-                                                size_t buffer_size);
+                                                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);

jerry-core/lit/lit-magic-strings.inc.h

@@ -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)

jerry-core/parser/js/js-lexer.c

@@ -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. += -> +

jerry-core/parser/js/js-parser-internal.h

@@ -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);
 
 /**

jerry-core/parser/js/js-parser.c

@@ -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;
+  lexer_init_line_info (&context);
-  context.column = 1;
+
 #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)
+    /* It is unlikely that memory can be allocated in an out-of-memory
-    {
+     * situation. However, a simple value can still be thrown. */
-      error_location_p->error = context.error;
+    jcontext_raise_exception (ECMA_VALUE_NULL);
-      error_location_p->line = context.token.line;
-      error_location_p->column = context.token.column;
-    }
     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;
+      lexer_init_line_info (&context);
-      context.column = 1;
 
       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);
 
+  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
+    /* Exception has already thrown. */
-    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 */
-
     return NULL;
   }
 

jerry-core/parser/js/js-parser.h

@@ -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,
+parser_parse_script (const uint8_t *arg_list_p, size_t arg_list_size,
-                     size_t arg_list_size,
+                     const uint8_t *source_p, size_t source_size,
-                     const uint8_t *source_p,
+                     uint32_t parse_opts, const ecma_parse_options_t *options_p);
-                     size_t source_size,
-                     ecma_value_t resource_name,
-                     uint32_t parse_opts);
 
 #if JERRY_ERROR_MESSAGES
 const char *parser_error_to_string (parser_error_t);

jerry-core/parser/js/js-scanner.c

@@ -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;
+            lexer_init_line_info (context_p);
-            context_p->column = 1;
 
 #if JERRY_ESNEXT
             scanner_filter_arguments (context_p, &scanner_context);

jerry-main/main-jerry-snapshot.c

@@ -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,
+    snapshot_result = jerry_generate_function_snapshot ((jerry_char_t *) source_p,
-                                                        (size_t) strlen (file_name_p),
-                                                        (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,
+    snapshot_result = jerry_generate_snapshot ((jerry_char_t *) source_p,
-                                               (size_t) strlen (file_name_p),
-                                               (jerry_char_t *) source_p,
                                                source_length,
+                                               &parse_options,
                                                snapshot_flags,
                                                output_buffer,
                                                sizeof (output_buffer) / sizeof (uint32_t));

jerry-main/main-jerry-test.c

@@ -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))
       {

jerry-main/main-jerry.c

@@ -117,11 +117,14 @@ restart:
           goto exit;
         }
 
-        ret_value = jerry_parse ((jerry_char_t *) file_path_p,
+        jerry_parse_options_t parse_options;
-                                 strlen (file_path_p),
+        parse_options.options = parse_opts | JERRY_PARSE_HAS_RESOURCE;
-                                 source_p,
+        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))
       {

jerry-main/main-utils.c

@@ -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,
+  jerry_parse_options_t parse_options;
-                                       source_p,
+  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))
   {

targets/mbedos5/jerryscript-mbed/jerryscript-mbed-launcher/source/launcher.cpp

@@ -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);

targets/nuttx-stm32f4/jerry_main.c

@@ -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],
+      jerry_parse_options_t parse_options;
-                               strlen (file_names[i]),
+      parse_options.options = JERRY_PARSE_HAS_RESOURCE;
-                               source_p,
+      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))

targets/riot-stm32f4/source/main-riotos.c

@@ -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))
   {

tests/unit-core/test-abort.c

@@ -62,11 +62,9 @@ main (void)
     "}"
   );
 
-  jerry_value_t parsed_code_val = jerry_parse (NULL,
+  jerry_value_t parsed_code_val = jerry_parse (inf_loop_code_src1,
-                                               0,
-                                               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,
+  parsed_code_val = jerry_parse (inf_loop_code_src2,
-                                 0,
-                                 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);

tests/unit-core/test-api-errortype.c

@@ -64,11 +64,9 @@ main (void)
 
   char test_source[] = "\xF0\x9D\x84\x9E";
 
-  jerry_value_t result = jerry_parse (NULL,
+  jerry_value_t result = jerry_parse ((const jerry_char_t *) test_source,
-                                      0,
-                                      (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);
 

tests/unit-core/test-api-objecttype.c

@@ -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 (JERRY_OBJECT_TYPE_SCRIPT, PARSE (NULL)),
-    ENTRY_IF (JERRY_OBJECT_TYPE_MODULE, PARSE (JERRY_PARSE_MODULE), JERRY_FEATURE_MODULE),
+    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),

tests/unit-core/test-api-promise.c

@@ -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,
+  jerry_value_t parsed_code_val = jerry_parse (test_source,
-                                               0,
-                                               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);

tests/unit-core/test-api.c

@@ -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,
+  parsed_code_val = jerry_parse (test_source,
-                                 0,
-                                 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,
+  jerry_value_t func_val = jerry_parse_function (func_arg_list,
-                                                 sizeof (func_resource) - 1,
-                                                 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,
+    jerry_value_t parse_result = jerry_parse (scoped_src_p,
-                                              0,
-                                              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,
+    parse_result = jerry_parse (scoped_src_p,
-                                0,
-                                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,
+    parse_result = jerry_parse (scoped_src_p,
-                                0,
-                                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,
+    parse_result = jerry_parse (scoped_src2_p,
-                                0,
-                                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,
+    parse_result = jerry_parse (scoped_src3_p,
-                                0,
-                                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,
+    parse_result = jerry_parse (scoped_src4_p,
-                                0,
-                                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,
+      parse_result = jerry_parse (scoped_src5_p,
-                                  0,
-                                  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,
+      parse_result = jerry_parse (scoped_src6_p,
-                                  0,
-                                  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 = (;";
+    test_syntax_error ("b = 'hello';\nvar a = (;",
-    parsed_code_val = jerry_parse (NULL,
+                       NULL,
-                                   0,
+                       "SyntaxError: Primary expression expected [<anonymous>:2:10]",
-                                   parser_err_src,
+                       false);
-                                   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]"));
 
     const jerry_char_t file_str[] = "filename.js";
-    parsed_code_val = jerry_parse (file_str,
+    jerry_parse_options_t parse_options;
-                                   sizeof (file_str) - 1,
+    parse_options.options = JERRY_PARSE_HAS_RESOURCE;
-                                   parser_err_src,
+    parse_options.resource_name_p = file_str;
-                                   sizeof (parser_err_src) - 1,
+    parse_options.resource_name_length = sizeof (file_str) - 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);
 
-    sz = jerry_string_to_char_buffer (err_str_val, err_str_buf, err_str_size);
+    test_syntax_error ("b = 'hello';\nvar a = (;",
-    err_str_buf[sz] = 0;
+                       &parse_options,
+                       "SyntaxError: Primary expression expected [filename.js:2:10]",
+                       false);
 
-    jerry_release_value (err_str_val);
+    test_syntax_error ("eval(\"var b;\\nfor (,); \");",
-    jerry_release_value (parsed_code_val);
+                       &parse_options,
-    TEST_ASSERT (!strcmp ((char *) err_str_buf,
+                       "SyntaxError: Primary expression expected [<eval>:2:6]",
-                          "SyntaxError: Primary expression expected [filename.js:2:10]"));
+                       true);
 
-    const jerry_char_t eval_err_src[] = "eval(\"var b;\\nfor (,); \");";
+    parse_options.options |= JERRY_PARSE_HAS_START;
-    parsed_code_val = jerry_parse (file_str,
+    parse_options.start_line = 10;
-                                   sizeof (file_str),
+    parse_options.start_column = 20;
-                                   eval_err_src,
-                                   sizeof (eval_err_src) - 1,
-                                   JERRY_PARSE_NO_OPTS);
-    TEST_ASSERT (!jerry_value_is_error (parsed_code_val));
 
-    res = jerry_run (parsed_code_val);
+    test_syntax_error ("for (var a in []",
-    TEST_ASSERT (jerry_value_is_error (res));
+                       &parse_options,
-    res = jerry_get_value_from_error (res, true);
+                       "SyntaxError: Expected ')' token [filename.js:10:36]",
-    err_str_val = jerry_value_to_string (res);
+                       false);
-    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]"));
 
     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,
+  parsed_code_val = jerry_parse (ms_code_src,
-                                 0,
-                                 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);

tests/unit-core/test-backtrace.c

@@ -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,
+  jerry_parse_options_t parse_options;
-                                    strlen (resource_name_p),
+  parse_options.options = JERRY_PARSE_HAS_RESOURCE;
-                                    (const jerry_char_t *) source_p,
+  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);

tests/unit-core/test-exec-stop.c

@@ -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,
+  jerry_value_t parsed_code_val = jerry_parse (inf_loop_code_src1,
-                                               0,
-                                               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,
+  parsed_code_val = jerry_parse (inf_loop_code_src2,
-                                 0,
-                                 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);

tests/unit-core/test-mem-stats.c

@@ -29,11 +29,9 @@ int main (void)
   );
 
   jerry_init (JERRY_INIT_EMPTY);
-  jerry_value_t parsed_code_val = jerry_parse (NULL,
+  jerry_value_t parsed_code_val = jerry_parse (test_source,
-                                               0,
-                                               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);

tests/unit-core/test-newtarget.c

@@ -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,
+    jerry_value_t parsed_code_val = jerry_parse (test_source,
-                                                 0,
-                                                 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,
+    jerry_value_t parsed_code_val = jerry_parse (test_source,
-                                                 0,
-                                                 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,
+    jerry_value_t parsed_code_val = jerry_parse (test_source,
-                                                 0,
-                                                 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);

tests/unit-core/test-objects-foreach.c

@@ -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,
+  jerry_value_t parse_result = jerry_parse (strict_equal_source,
-                                            0,
-                                            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));

tests/unit-core/test-promise.c

@@ -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,
+  jerry_value_t parsed_code_val = jerry_parse (test_source,
-                                               0,
-                                               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);

tests/unit-core/test-proxy.c

@@ -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,
+  jerry_value_t parsed_get_code_val = jerry_parse (get_value_src,
-                                               0,
-                                               get_value_src,
                                                    sizeof (get_value_src) - 1,
-                                               JERRY_PARSE_NO_OPTS);
+                                                   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,
+  jerry_value_t parsed_set_code_val = jerry_parse (set_value_src,
-                                                   0,
-                                                   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,
+    jerry_value_t parsed_has_code_val = jerry_parse (has_value_src,
-                                                     0,
-                                                     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);

tests/unit-core/test-realm.c

@@ -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,
+  jerry_value_t script_value = jerry_parse ((const jerry_char_t *) script_p,
-                                            0,
-                                            (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);

tests/unit-core/test-regexp-dotall-unicode.c

@@ -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,
+  jerry_value_t func_val = jerry_parse_function (func_arg_list,
-                                                 sizeof (func_resource) - 1,
-                                                 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);

tests/unit-core/test-regexp.c

@@ -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,
+  jerry_value_t func_val = jerry_parse_function (func_arg_list,
-                                                 sizeof (func_resource) - 1,
-                                                 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);

tests/unit-core/test-regression-3588.c

@@ -66,11 +66,9 @@ main (void)
         "new Sub1 ()"
     );
 
-    jerry_value_t parsed_code_val = jerry_parse (NULL,
+    jerry_value_t parsed_code_val = jerry_parse (test_source,
-                                                 0,
-                                                 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,
+    jerry_value_t parsed_code_val = jerry_parse (test_source,
-                                                 0,
-                                                 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);

tests/unit-core/test-resource-name.c

@@ -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,
+  parse_options.resource_name_p = (const jerry_char_t *) resource_1;
-                                       strlen (resource_1),
+  parse_options.resource_name_length = strlen (resource_1);
-                                       (const jerry_char_t *) source_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,
+  parse_options.resource_name_p = (const jerry_char_t *) resource_2;
-                         strlen (resource_2),
+  parse_options.resource_name_length = strlen (resource_2);
-                         (const jerry_char_t *) source_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);

tests/unit-core/test-snapshot.c

@@ -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,
+  generate_result = jerry_generate_function_snapshot (code_to_snapshot,
-                                                      0,
-                                                      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,
+    generate_result = jerry_generate_snapshot (code_to_snapshot,
-                                               0,
-                                               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,
+    generate_result = jerry_generate_snapshot (code_to_snapshot,
-                                               0,
-                                               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,
+    generate_result = jerry_generate_snapshot (code_to_snapshot1,
-                                               0,
-                                               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,
+    generate_result = jerry_generate_snapshot (code_to_snapshot2,
-                                               0,
-                                               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,
+    generate_result = jerry_generate_snapshot (code_for_c_format,
-                                               0,
-                                               code_for_c_format,
                                                sizeof (code_for_c_format) - 1,
+                                               NULL,
                                                0,
                                                literal_snapshot_buffer,
                                                SNAPSHOT_BUFFER_SIZE);

tests/unit-core/test-unicode.c

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

tests/unit-ext/test-ext-arg.c

@@ -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,
+  jerry_value_t parsed_code_val = jerry_parse (test_source,
-                                               0,
-                                               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);