Simplify source evaluation options. (#2431)

JerryScript-DCO-1.0-Signed-off-by: Robert Fancsik frobert@inf.u-szeged.hu

docs/02.API-REFERENCE.md

@@ -970,12 +970,12 @@ Perform JavaScript `eval`.
 jerry_value_t
 jerry_eval (const jerry_char_t *source_p,
             size_t source_size,
-            bool is_strict);
+            uint32_t parse_opts);
 ```
 
 - `source_p` - source code to evaluate, it must be a valid utf8 string.
 - `source_size` - length of the source code
-- `is_strict` - perform `eval` as it is called from "strict mode" code.
+- `parse_opts` - any combination of [jerry_parse_opts_t](#jerry_parse_opts_t) flags.
 - return value - result of eval, may be error value.
 
 **Example**
@@ -984,7 +984,7 @@ jerry_eval (const jerry_char_t *source_p,
 {
   jerry_value_t ret_val = jerry_eval (str_to_eval,
                                       strlen (str_to_eval),
-                                      false);
+                                      JERRY_PARSE_NO_OPTS);
 }
 ```
 

docs/03.API-EXAMPLE.md

@@ -105,7 +105,7 @@ main (void)
   /* Evaluate script1 */
   eval_ret = jerry_eval (script_1,
                          strlen ((const char *) script_1),
-                         false);
+                         JERRY_PARSE_NO_OPTS);
 
   /* Free JavaScript value, returned by eval */
   jerry_release_value (eval_ret);
@@ -113,7 +113,7 @@ main (void)
   /* Evaluate script2 */
   eval_ret = jerry_eval (script_2,
                          strlen ((const char *) script_2),
-                         false);
+                         JERRY_PARSE_NO_OPTS);
 
   /* Free JavaScript value, returned by eval */
   jerry_release_value (eval_ret);
@@ -169,7 +169,7 @@ main (void)
   /* Now starting script that would output value of just initialized field */
   jerry_value_t eval_ret = jerry_eval (script,
                                        strlen ((const char *) script),
-                                       false);
+                                       JERRY_PARSE_NO_OPTS);
 
   /* Free JavaScript value, returned by eval */
   jerry_release_value (eval_ret);
@@ -322,7 +322,7 @@ main (void)
     /* Evaluate entered command */
     ret_val = jerry_eval ((const jerry_char_t *) cmd,
                           len,
-                          false);
+                          JERRY_PARSE_NO_OPTS);
 
     /* If command evaluated successfully, print value, returned by eval */
     if (jerry_value_is_error (ret_val))
@@ -420,7 +420,7 @@ main (void)
   size_t script_size = strlen ((const char *) script);
 
   /* Evaluate script */
-  jerry_value_t eval_ret = jerry_eval (script, script_size, false);
+  jerry_value_t eval_ret = jerry_eval (script, script_size, JERRY_PARSE_NO_OPTS);
 
   /* Free JavaScript value, returned by eval */
   jerry_release_value (eval_ret);
@@ -509,7 +509,7 @@ main (void)
   /* Evaluate script */
   my_js_obj_val = jerry_eval (my_js_object,
                               strlen ((const char *) my_js_object),
-                              false);
+                              JERRY_PARSE_NO_OPTS);
 
   /* Create a JS function object and wrap into a jerry value */
   jerry_value_t add_func_obj = jerry_create_external_function (add_handler);
@@ -532,7 +532,7 @@ main (void)
   size_t script_size = strlen ((const char *) script);
 
   /* Evaluate script */
-  jerry_value_t eval_ret = jerry_eval (script, script_size, false);
+  jerry_value_t eval_ret = jerry_eval (script, script_size, JERRY_PARSE_NO_OPTS);
 
   /* Free JavaScript value, returned by eval */
   jerry_release_value (eval_ret);
@@ -583,7 +583,7 @@ main (void)
                                   jerryx_handler_print);
 
   /* Evaluate the script */
-  jerry_value_t eval_ret = jerry_eval (script, script_size, false);
+  jerry_value_t eval_ret = jerry_eval (script, script_size, JERRY_PARSE_NO_OPTS);
 
   /* Free the JavaScript value returned by eval */
   jerry_release_value (eval_ret);

docs/12.EXT-REFERENCE-MODULE.md

@@ -182,7 +182,7 @@ load_and_evaluate_js_file (const jerry_value_t name, jerry_value_t *result)
     {
       /* We read the file into memory and call jerry_eval (), assigning the result to the out-parameter. */
       fread (js_file_contents, file_size, 1, js_file);
-      (*result) = jerry_eval (js_file_contents, file_size, false);
+      (*result) = jerry_eval (js_file_contents, file_size, JERRY_PARSE_NO_OPTS);
 
       /* We release the memory holding the contents of the file. */
       free (js_file_contents);

jerry-core/api/jerry.c

@@ -391,7 +391,7 @@ jerry_parse (const jerry_char_t *resource_name_p, /**< resource name (usually a
                                       0,
                                       source_p,
                                       source_size,
-                                      (parse_opts & JERRY_PARSE_STRICT_MODE) != 0,
+                                      parse_opts,
                                       &bytecode_data_p);
 
   if (ECMA_IS_VALUE_ERROR (parse_status))
@@ -466,7 +466,7 @@ jerry_parse_function (const jerry_char_t *resource_name_p, /**< resource name (u
                                       arg_list_size,
                                       source_p,
                                       source_size,
-                                      (parse_opts & JERRY_PARSE_STRICT_MODE) != 0,
+                                      parse_opts,
                                       &bytecode_data_p);
 
   if (ECMA_IS_VALUE_ERROR (parse_status))
@@ -544,14 +544,13 @@ jerry_run (const jerry_value_t func_val) /**< function to run */
 jerry_value_t
 jerry_eval (const jerry_char_t *source_p, /**< source code */
             size_t source_size, /**< length of source code */
-            bool is_strict) /**< source must conform with strict mode */
+            uint32_t parse_opts) /**< jerry_parse_opts_t option bits */
 {
   jerry_assert_api_available ();
 
   return jerry_return (ecma_op_eval_chars_buffer ((const lit_utf8_byte_t *) source_p,
                                                   source_size,
-                                                  false,
+                                                  parse_opts));
-                                                  is_strict));
 } /* jerry_eval */
 
 /**

jerry-core/debugger/debugger.c

@@ -192,7 +192,7 @@ jerry_debugger_send_eval (const lit_utf8_byte_t *eval_string_p, /**< evaluated s
   JERRY_ASSERT (!(JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_VM_IGNORE));
 
   JERRY_DEBUGGER_SET_FLAGS (JERRY_DEBUGGER_VM_IGNORE);
-  ecma_value_t result = ecma_op_eval_chars_buffer (eval_string_p + 1, eval_string_size - 1, true, false);
+  ecma_value_t result = ecma_op_eval_chars_buffer (eval_string_p + 1, eval_string_size - 1, ECMA_PARSE_DIRECT_EVAL);
   JERRY_DEBUGGER_CLEAR_FLAGS (JERRY_DEBUGGER_VM_IGNORE);
 
   if (!ECMA_IS_VALUE_ERROR (result))

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

@@ -80,6 +80,17 @@ typedef enum
   ECMA_TYPE___MAX = ECMA_TYPE_ERROR /** highest value for ecma types */
 } ecma_type_t;
 
+
+/**
+ * Option flags for script parsing.
+ */
+typedef enum
+{
+  ECMA_PARSE_NO_OPTS = 0, /**< no options passed */
+  ECMA_PARSE_STRICT_MODE = (1 << 0), /**< enable strict mode */
+  ECMA_PARSE_DIRECT_EVAL = (1 << 1) /**< is eval called directly (ECMA-262 v5, 15.1.2.1.1) */
+} ecma_parse_opts_t;
+
 /**
  * Description of an ecma value
  *

jerry-core/ecma/builtin-objects/ecma-builtin-function.c

@@ -169,7 +169,7 @@ ecma_builtin_function_dispatch_construct (const ecma_value_t *arguments_list_p,
                                                 arguments_buffer_size,
                                                 function_body_buffer_p,
                                                 function_body_buffer_size,
-                                                false,
+                                                ECMA_PARSE_NO_OPTS,
                                                 &bytecode_data_p);
 
   if (!ECMA_IS_VALUE_ERROR (ret_value))

jerry-core/ecma/builtin-objects/ecma-builtin-global.c

@@ -63,17 +63,13 @@ ecma_builtin_global_object_eval (ecma_value_t this_arg, /**< this argument */
   JERRY_UNUSED (this_arg);
   ecma_value_t ret_value = ECMA_VALUE_EMPTY;
 
-  bool is_direct_eval = vm_is_direct_eval_form_call ();
+  uint32_t parse_opts = vm_is_direct_eval_form_call () ? ECMA_PARSE_DIRECT_EVAL : ECMA_PARSE_NO_OPTS;
 
   /* See also: ECMA-262 v5, 10.1.1 */
-  bool is_called_from_strict_mode_code;
+  if (parse_opts && vm_is_strict_mode ())
-  if (is_direct_eval)
   {
-    is_called_from_strict_mode_code = vm_is_strict_mode ();
+    JERRY_ASSERT (parse_opts & ECMA_PARSE_DIRECT_EVAL);
-  }
+    parse_opts |= ECMA_PARSE_STRICT_MODE;
-  else
-  {
-    is_called_from_strict_mode_code = false;
   }
 
   if (!ecma_is_value_string (x))
@@ -85,8 +81,7 @@ ecma_builtin_global_object_eval (ecma_value_t this_arg, /**< this argument */
   {
     /* steps 2 to 8 */
     ret_value = ecma_op_eval (ecma_get_string_from_value (x),
-                              is_direct_eval,
+                              parse_opts);
-                              is_called_from_strict_mode_code);
   }
 
   return ret_value;

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

@@ -45,8 +45,7 @@
  */
 ecma_value_t
 ecma_op_eval (ecma_string_t *code_p, /**< code string */
-              bool is_direct, /**< is eval called directly (ECMA-262 v5, 15.1.2.1.1) */
+              uint32_t parse_opts) /**< ecma_parse_opts_t option bits */
-              bool is_called_from_strict_mode_code) /**< is eval is called from strict mode code */
 {
   ecma_value_t ret_value;
 
@@ -61,8 +60,7 @@ ecma_op_eval (ecma_string_t *code_p, /**< code string */
 
     ret_value = ecma_op_eval_chars_buffer (code_utf8_buffer_p,
                                            chars_num,
-                                           is_direct,
+                                           parse_opts);
-                                           is_called_from_strict_mode_code);
 
     ECMA_FINALIZE_UTF8_STRING (code_utf8_buffer_p, code_utf8_buffer_size);
   }
@@ -82,15 +80,19 @@ ecma_op_eval (ecma_string_t *code_p, /**< code string */
 ecma_value_t
 ecma_op_eval_chars_buffer (const lit_utf8_byte_t *code_p, /**< code characters buffer */
                            size_t code_buffer_size, /**< size of the buffer */
-                           bool is_direct, /**< is eval called directly (ECMA-262 v5, 15.1.2.1.1) */
+                           uint32_t parse_opts) /**< ecma_parse_opts_t option bits */
-                           bool is_called_from_strict_mode_code) /**< is eval is called from strict mode code */
 {
 #ifndef JERRY_DISABLE_JS_PARSER
   JERRY_ASSERT (code_p != NULL);
 
   ecma_compiled_code_t *bytecode_data_p;
 
-  bool is_strict_call = (is_direct && is_called_from_strict_mode_code);
+  uint32_t is_strict_call = ECMA_PARSE_STRICT_MODE | ECMA_PARSE_DIRECT_EVAL;
+
+  if ((parse_opts & is_strict_call) != is_strict_call)
+  {
+    parse_opts &= (uint32_t) ~ECMA_PARSE_STRICT_MODE;
+  }
 
 #ifdef JERRY_ENABLE_LINE_INFO
   JERRY_CONTEXT (resource_name) = ecma_make_magic_string_value (LIT_MAGIC_STRING__EMPTY);
@@ -100,7 +102,7 @@ ecma_op_eval_chars_buffer (const lit_utf8_byte_t *code_p, /**< code characters b
                                                    0,
                                                    code_p,
                                                    code_buffer_size,
-                                                   is_strict_call,
+                                                   parse_opts,
                                                    &bytecode_data_p);
 
   if (ECMA_IS_VALUE_ERROR (parse_status))
@@ -108,12 +110,11 @@ ecma_op_eval_chars_buffer (const lit_utf8_byte_t *code_p, /**< code characters b
     return parse_status;
   }
 
-  return vm_run_eval (bytecode_data_p, is_direct);
+  return vm_run_eval (bytecode_data_p, parse_opts);
 #else /* JERRY_DISABLE_JS_PARSER */
   JERRY_UNUSED (code_p);
   JERRY_UNUSED (code_buffer_size);
-  JERRY_UNUSED (is_direct);
+  JERRY_UNUSED (parse_opts);
-  JERRY_UNUSED (is_called_from_strict_mode_code);
 
   return ecma_raise_syntax_error (ECMA_ERR_MSG ("The parser has been disabled."));
 #endif /* !JERRY_DISABLE_JS_PARSER */

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

@@ -26,11 +26,10 @@
  */
 
 ecma_value_t
-ecma_op_eval (ecma_string_t *code_p, bool is_direct, bool is_called_from_strict_mode_code);
+ecma_op_eval (ecma_string_t *code_p, uint32_t parse_opts);
 
 ecma_value_t
-ecma_op_eval_chars_buffer (const lit_utf8_byte_t *code_p, size_t code_buffer_size, bool is_direct,
+ecma_op_eval_chars_buffer (const lit_utf8_byte_t *code_p, size_t code_buffer_size, uint32_t parse_opts);
-                           bool is_called_from_strict_mode_code);
 
 /**
  * @}

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

@@ -566,7 +566,7 @@ ecma_op_function_call (ecma_object_t *func_obj_p, /**< Function object */
       ecma_value_t ret_value = vm_run (bytecode_data_p,
                                        this_binding,
                                        local_env_p,
-                                       false,
+                                       ECMA_PARSE_NO_OPTS,
                                        arguments_list_p,
                                        arguments_list_len);
 
@@ -629,7 +629,7 @@ ecma_op_function_call (ecma_object_t *func_obj_p, /**< Function object */
       ecma_value_t ret_value = vm_run (bytecode_data_p,
                                        arrow_func_p->this_binding,
                                        local_env_p,
-                                       false,
+                                       ECMA_PARSE_NO_OPTS,
                                        arguments_list_p,
                                        arguments_list_len);
 

jerry-core/include/jerryscript-core.h

@@ -329,7 +329,7 @@ jerry_value_t jerry_parse_function (const jerry_char_t *resource_name_p, size_t
                                     const jerry_char_t *arg_list_p, size_t arg_list_size,
                                     const jerry_char_t *source_p, size_t source_size, uint32_t parse_opts);
 jerry_value_t jerry_run (const jerry_value_t func_val);
-jerry_value_t jerry_eval (const jerry_char_t *source_p, size_t source_size, bool is_strict);
+jerry_value_t jerry_eval (const jerry_char_t *source_p, size_t source_size, uint32_t parse_opts);
 
 jerry_value_t jerry_run_all_enqueued_jobs (void);
 

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

@@ -2224,7 +2224,7 @@ 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 */
-                     int strict_mode, /**< strict mode */
+                     uint32_t parse_opts, /**< ecma_parse_opts_t option bits */
                      parser_error_location_t *error_location_p) /**< error location */
 {
   parser_context_t context;
@@ -2264,7 +2264,7 @@ parser_parse_source (const uint8_t *arg_list_p, /**< function argument list */
   context.last_context_p = NULL;
   context.last_statement.current_p = NULL;
 
-  if (strict_mode)
+  if (parse_opts & ECMA_PARSE_STRICT_MODE)
   {
     context.status_flags |= PARSER_IS_STRICT;
   }
@@ -2867,7 +2867,7 @@ 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 */
-                     bool is_strict, /**< strict mode */
+                     uint32_t parse_opts, /**< ecma_parse_opts_t option bits */
                      ecma_compiled_code_t **bytecode_data_p) /**< [out] JS bytecode */
 {
 #ifndef JERRY_DISABLE_JS_PARSER
@@ -2887,7 +2887,7 @@ parser_parse_script (const uint8_t *arg_list_p, /**< function argument list */
                                           arg_list_size,
                                           source_p,
                                           source_size,
-                                          is_strict,
+                                          parse_opts,
                                           &parser_error);
 
   if (!*bytecode_data_p)
@@ -2959,7 +2959,7 @@ parser_parse_script (const uint8_t *arg_list_p, /**< function argument list */
   JERRY_UNUSED (arg_list_size);
   JERRY_UNUSED (source_p);
   JERRY_UNUSED (source_size);
-  JERRY_UNUSED (is_strict);
+  JERRY_UNUSED (parse_opts);
   JERRY_UNUSED (bytecode_data_p);
 
   return ecma_raise_syntax_error (ECMA_ERR_MSG ("The parser has been disabled."));

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

@@ -138,7 +138,7 @@ typedef struct
 /* Note: source must be a valid UTF-8 string */
 ecma_value_t parser_parse_script (const uint8_t *arg_list_p, size_t arg_list_size,
                                   const uint8_t *source_p, size_t source_size,
-                                  bool is_strict, ecma_compiled_code_t **bytecode_data_p);
+                                  uint32_t parse_opts, ecma_compiled_code_t **bytecode_data_p);
 
 #ifdef JERRY_ENABLE_ERROR_MESSAGES
 const char *parser_error_to_string (parser_error_t);

jerry-core/vm/vm.c

@@ -240,13 +240,13 @@ vm_run_global (const ecma_compiled_code_t *bytecode_p) /**< pointer to bytecode
  */
 ecma_value_t
 vm_run_eval (ecma_compiled_code_t *bytecode_data_p, /**< byte-code data */
-             bool is_direct) /**< is eval called in direct mode? */
+             uint32_t parse_opts) /**< ecma_parse_opts_t option bits */
 {
   ecma_value_t this_binding;
   ecma_object_t *lex_env_p;
 
   /* ECMA-262 v5, 10.4.2 */
-  if (is_direct)
+  if (parse_opts & ECMA_PARSE_DIRECT_EVAL)
   {
     this_binding = ecma_copy_value (JERRY_CONTEXT (vm_top_context_p)->this_binding);
     lex_env_p = JERRY_CONTEXT (vm_top_context_p)->lex_env_p;
@@ -270,7 +270,7 @@ vm_run_eval (ecma_compiled_code_t *bytecode_data_p, /**< byte-code data */
   ecma_value_t completion_value = vm_run (bytecode_data_p,
                                           this_binding,
                                           lex_env_p,
-                                          true,
+                                          parse_opts,
                                           NULL,
                                           0);
 
@@ -3040,7 +3040,7 @@ ecma_value_t
 vm_run (const ecma_compiled_code_t *bytecode_header_p, /**< byte-code data header */
         ecma_value_t this_binding_value, /**< value of 'ThisBinding' */
         ecma_object_t *lex_env_p, /**< lexical environment to use */
-        bool is_eval_code, /**< is the code is eval code (ECMA-262 v5, 10.1) */
+        uint32_t parse_opts, /**< ecma_parse_opts_t option bits */
         const ecma_value_t *arg_list_p, /**< arguments list */
         ecma_length_t arg_list_len) /**< length of arguments list */
 {
@@ -3080,7 +3080,7 @@ vm_run (const ecma_compiled_code_t *bytecode_header_p, /**< byte-code data heade
   frame_ctx.current_line = 0;
 #endif /* JERRY_ENABLE_LINE_INFO */
   frame_ctx.context_depth = 0;
-  frame_ctx.is_eval_code = is_eval_code;
+  frame_ctx.is_eval_code = parse_opts & ECMA_PARSE_DIRECT_EVAL;
   frame_ctx.call_operation = VM_NO_EXEC_OP;
 
   /* Use JERRY_MAX() to avoid array declaration with size 0. */

jerry-core/vm/vm.h

@@ -282,10 +282,10 @@ typedef enum
 } vm_call_operation;
 
 ecma_value_t vm_run_global (const ecma_compiled_code_t *bytecode_p);
-ecma_value_t vm_run_eval (ecma_compiled_code_t *bytecode_data_p, bool is_direct);
+ecma_value_t vm_run_eval (ecma_compiled_code_t *bytecode_data_p, uint32_t parse_opts);
 
 ecma_value_t vm_run (const ecma_compiled_code_t *bytecode_header_p, ecma_value_t this_binding_value,
-                     ecma_object_t *lex_env_p, bool is_eval_code, const ecma_value_t *arg_list_p,
+                     ecma_object_t *lex_env_p, uint32_t parse_opts, const ecma_value_t *arg_list_p,
                      ecma_length_t arg_list_len);
 
 bool vm_is_strict_mode (void);

jerry-main/main-unix.c

@@ -809,7 +809,7 @@ main (int argc,
       if (len > 0)
       {
         /* Evaluate the line */
-        jerry_value_t ret_val_eval = jerry_eval (buffer, len, false);
+        jerry_value_t ret_val_eval = jerry_eval (buffer, len, JERRY_PARSE_NO_OPTS);
 
         if (!jerry_value_is_error (ret_val_eval))
         {

targets/curie_bsp/jerry_app/quark/main.c

@@ -111,7 +111,7 @@ void eval_jerry_script (int argc, char *argv[], struct tcmd_handler_ctx *ctx)
     }
     *p = '\0';
 
-    jerry_value_t eval_ret = jerry_eval (buffer, str_total_length - 1, false);
+    jerry_value_t eval_ret = jerry_eval (buffer, str_total_length - 1, JERRY_PARSE_NO_OPTS);
 
     if (jerry_value_is_error (eval_ret))
     {

targets/esp8266/user/jerry_run.c

@@ -36,7 +36,7 @@ int js_eval (const char *source_p, const size_t source_size)
 {
   jerry_value_t res = jerry_eval ((jerry_char_t *) source_p,
                                   source_size,
-                                  false);
+                                  JERRY_PARSE_NO_OPTS);
   if (jerry_value_is_error (res)) {
     jerry_release_value (res);
     return -1;

targets/particle/source/main.cpp

@@ -116,7 +116,7 @@ test_jerry ()
 
   size_t script_size = strlen ((const char *) script);
 
-  jerry_value_t eval_ret = jerry_eval (script, script_size, false);
+  jerry_value_t eval_ret = jerry_eval (script, script_size, JERRY_PARSE_NO_OPTS);
 
   /* Free JavaScript value, returned by eval */
   jerry_release_value (eval_ret);

targets/zephyr/src/main-zephyr.c

@@ -50,7 +50,7 @@ static int shell_cmd_handler (char *source_buffer)
 
   ret_val = jerry_eval ((jerry_char_t *) source_buffer,
     strlen (source_buffer),
-    false);
+    JERRY_PARSE_NO_OPTS);
 
   if (jerry_value_is_error (ret_val))
   {

tests/unit-core/test-api-value-type.c

@@ -67,7 +67,9 @@ main (void)
 
     ENTRY (JERRY_TYPE_NULL, jerry_create_null ()),
 
-    ENTRY (JERRY_TYPE_FUNCTION, jerry_eval (test_eval_function, strlen ((char *) test_eval_function), false)),
+    ENTRY (JERRY_TYPE_FUNCTION, jerry_eval (test_eval_function,
+                                            strlen ((char *) test_eval_function),
+                                            JERRY_PARSE_NO_OPTS)),
     ENTRY (JERRY_TYPE_FUNCTION, jerry_create_external_function (test_ext_function)),
 
     ENTRY (JERRY_TYPE_STRING, jerry_create_string (test_eval_function)),

tests/unit-core/test-api.c

@@ -329,7 +329,7 @@ strict_equals (jerry_value_t a,
   jerry_value_t res;
 
   is_equal_src = "var isEqual = function(a, b) { return (a === b); }; isEqual";
-  is_equal_fn_val = jerry_eval ((jerry_char_t *) is_equal_src, strlen (is_equal_src), false);
+  is_equal_fn_val = jerry_eval ((jerry_char_t *) is_equal_src, strlen (is_equal_src), JERRY_PARSE_NO_OPTS);
   TEST_ASSERT (!jerry_value_is_error (is_equal_fn_val));
   args[0] = a;
   args[1] = b;
@@ -967,7 +967,7 @@ main (void)
   jerry_release_value (res);
 
   /* Test: jerry_value_to_primitive */
-  obj_val = jerry_eval ((jerry_char_t *) "new String ('hello')", 20, false);
+  obj_val = jerry_eval ((jerry_char_t *) "new String ('hello')", 20, JERRY_PARSE_NO_OPTS);
   TEST_ASSERT (!jerry_value_is_error (obj_val));
   TEST_ASSERT (jerry_value_is_object (obj_val));
   TEST_ASSERT (!jerry_value_is_string (obj_val));
@@ -1001,7 +1001,7 @@ main (void)
 
   /* Test: eval */
   const char *eval_code_src_p = "(function () { return 123; })";
-  val_t = jerry_eval ((jerry_char_t *) eval_code_src_p, strlen (eval_code_src_p), true);
+  val_t = jerry_eval ((jerry_char_t *) eval_code_src_p, strlen (eval_code_src_p), JERRY_PARSE_STRICT_MODE);
   TEST_ASSERT (!jerry_value_is_error (val_t));
   TEST_ASSERT (jerry_value_is_object (val_t));
   TEST_ASSERT (jerry_value_is_function (val_t));
@@ -1022,7 +1022,7 @@ main (void)
 
   /* Test: spaces */
   eval_code_src_p = "\x0a \x0b \x0c \xc2\xa0 \xe2\x80\xa8 \xe2\x80\xa9 \xef\xbb\xbf 4321";
-  val_t = jerry_eval ((jerry_char_t *) eval_code_src_p, strlen (eval_code_src_p), true);
+  val_t = jerry_eval ((jerry_char_t *) eval_code_src_p, strlen (eval_code_src_p), JERRY_PARSE_STRICT_MODE);
   TEST_ASSERT (!jerry_value_is_error (val_t));
   TEST_ASSERT (jerry_value_is_number (val_t)
                && jerry_get_number_value (val_t) == 4321.0);
@@ -1163,7 +1163,7 @@ main (void)
   const char *test_magic_str_access_src_p = "'console'.charAt(6) == 'e'";
   res = jerry_eval ((const jerry_char_t *) test_magic_str_access_src_p,
                     strlen (test_magic_str_access_src_p),
-                    false);
+                    JERRY_PARSE_NO_OPTS);
   TEST_ASSERT (jerry_value_is_boolean (res));
   TEST_ASSERT (jerry_get_boolean_value (res) == true);
 

tests/unit-core/test-arraybuffer.c

@@ -79,7 +79,7 @@ test_read_with_offset (uint8_t offset) /**< offset for buffer read. */
                                         "array.buffer");
   jerry_value_t arraybuffer = jerry_eval ((jerry_char_t *) eval_arraybuffer_src_p,
                                           strlen (eval_arraybuffer_src_p),
-                                          true);
+                                          JERRY_PARSE_STRICT_MODE);
 
   TEST_ASSERT (!jerry_value_is_error (arraybuffer));
   TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
@@ -115,7 +115,7 @@ static void test_write_with_offset (uint8_t offset) /**< offset for buffer write
   const char *eval_arraybuffer_src_p = "var array = new Uint8Array (15); array.buffer";
   jerry_value_t arraybuffer = jerry_eval ((jerry_char_t *) eval_arraybuffer_src_p,
                                           strlen (eval_arraybuffer_src_p),
-                                          true);
+                                          JERRY_PARSE_STRICT_MODE);
 
   TEST_ASSERT (!jerry_value_is_error (arraybuffer));
   TEST_ASSERT (jerry_value_is_arraybuffer (arraybuffer));
@@ -145,7 +145,7 @@ static void test_write_with_offset (uint8_t offset) /**< offset for buffer write
       "assert (array[15] === undefined, 'ArrayBuffer out of bounds index should return undefined value');");
   jerry_value_t res = jerry_eval ((jerry_char_t *) eval_test_arraybuffer_p,
                                   strlen (eval_test_arraybuffer_p),
-                                  true);
+                                  JERRY_PARSE_STRICT_MODE);
   jerry_release_value (res);
   jerry_release_value (arraybuffer);
 } /* test_write_with_offset */
@@ -179,7 +179,7 @@ main (void)
     const char *eval_arraybuffer_src_p = "new ArrayBuffer (10)";
     jerry_value_t eval_arraybuffer = jerry_eval ((jerry_char_t *) eval_arraybuffer_src_p,
                                                  strlen (eval_arraybuffer_src_p),
-                                                 true);
+                                                 JERRY_PARSE_STRICT_MODE);
     TEST_ASSERT (!jerry_value_is_error (eval_arraybuffer));
     TEST_ASSERT (jerry_value_is_arraybuffer (eval_arraybuffer));
     TEST_ASSERT (jerry_get_arraybuffer_byte_length (eval_arraybuffer) == 10);
@@ -300,7 +300,7 @@ main (void)
       "array.buffer");
     jerry_value_t buffer = jerry_eval ((jerry_char_t *) eval_arraybuffer_src_p,
                                         strlen (eval_arraybuffer_src_p),
-                                        true);
+                                        JERRY_PARSE_STRICT_MODE);
 
     TEST_ASSERT (!jerry_value_is_error (buffer));
     TEST_ASSERT (jerry_value_is_arraybuffer (buffer));
@@ -335,7 +335,7 @@ main (void)
       "sum");
     jerry_value_t res = jerry_eval ((jerry_char_t *) eval_test_arraybuffer_p,
                                     strlen (eval_test_arraybuffer_p),
-                                    true);
+                                    JERRY_PARSE_STRICT_MODE);
     TEST_ASSERT (jerry_value_is_number (res));
     TEST_ASSERT (jerry_get_number_value (res) == sum);
     jerry_release_value (res);

tests/unit-core/test-typedarray.c

@@ -253,7 +253,7 @@ test_typedarray_complex_creation (test_entry_t test_entries[], /**< test cases *
       "array[0] = 0x11223344;");
     jerry_value_t result = jerry_eval ((jerry_char_t *) eval_src_p,
                                        strlen (eval_src_p),
-                                       true);
+                                       JERRY_PARSE_STRICT_MODE);
     TEST_ASSERT (!jerry_value_is_error (result));
     jerry_release_value (result);
 
@@ -479,7 +479,7 @@ main (void)
       "};");
     jerry_value_t result = jerry_eval ((jerry_char_t *) eval_src_p,
                                        strlen (eval_src_p),
-                                       true);
+                                       JERRY_PARSE_STRICT_MODE);
 
     TEST_ASSERT (!jerry_value_is_error (result));
     jerry_release_value (result);

tests/unit-ext/module/jerry-module-test.c

@@ -181,7 +181,9 @@ assert_number (jerry_value_t js_value, double expected_result)
 static void
 eval_one (const char *the_string, double expected_result)
 {
-  jerry_value_t js_eval_result = jerry_eval ((const jerry_char_t *) the_string, strlen (the_string), true);
+  jerry_value_t js_eval_result = jerry_eval ((const jerry_char_t *) the_string,
+                                             strlen (the_string),
+                                             JERRY_PARSE_STRICT_MODE);
   assert_number (js_eval_result, expected_result);
   jerry_release_value (js_eval_result);
 } /* eval_one */