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

Removed ECMA_TRY_CATCH macros from RegExp built-in (#2642)

Browse Source 
JerryScript-DCO-1.0-Signed-off-by: László Langó llango.u-szeged@partner.samsung.com
This commit is contained in:
László Langó 2019-01-04 15:12:03 +01:00 committed by Akos Kiss
parent f2404ac0e1
commit 2f8c0a168f
5 changed files with 222 additions and 228 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

324
jerry-core/ecma/builtin-objects/ecma-builtin-regexp-prototype.c
View File

@ -63,156 +63,157 @@ ecma_builtin_regexp_prototype_compile (ecma_value_t this_arg, /**< this argument
ecma_value_t pattern_arg, /**< pattern or RegExp object */
ecma_value_t flags_arg) /**< flags */
{
ecma_value_t ret_value = ECMA_VALUE_EMPTY;
if (!ecma_is_value_object (this_arg)
|| !ecma_object_class_is (ecma_get_object_from_value (this_arg), LIT_MAGIC_STRING_REGEXP_UL))
{
ret_value = ecma_raise_type_error (ECMA_ERR_MSG ("Incomplete RegExp type"));
return ecma_raise_type_error (ECMA_ERR_MSG ("Incomplete RegExp type"));
}
else
uint16_t flags = 0;
if (ecma_is_value_object (pattern_arg)
&& ecma_object_class_is (ecma_get_object_from_value (pattern_arg), LIT_MAGIC_STRING_REGEXP_UL))
{
uint16_t flags = 0;
if (ecma_is_value_object (pattern_arg)
&& ecma_object_class_is (ecma_get_object_from_value (pattern_arg), LIT_MAGIC_STRING_REGEXP_UL))
if (!ecma_is_value_undefined (flags_arg))
{
if (!ecma_is_value_undefined (flags_arg))
{
ret_value = ecma_raise_type_error (ECMA_ERR_MSG ("Invalid argument of RegExp compile."));
}
else
{
/* Compile from existing RegExp pbject. */
ecma_object_t *target_p = ecma_get_object_from_value (pattern_arg);
/* Get source. */
ecma_string_t *magic_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_SOURCE);
ecma_value_t source_value = ecma_op_object_get_own_data_prop (target_p, magic_string_p);
ecma_string_t *pattern_string_p = ecma_get_string_from_value (source_value);
/* Get flags. */
magic_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_GLOBAL);
ecma_value_t global_value = ecma_op_object_get_own_data_prop (target_p, magic_string_p);
JERRY_ASSERT (ecma_is_value_boolean (global_value));
if (ecma_is_value_true (global_value))
{
flags |= RE_FLAG_GLOBAL;
}
magic_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_IGNORECASE_UL);
ecma_value_t ignore_case_value = ecma_op_object_get_own_data_prop (target_p, magic_string_p);
JERRY_ASSERT (ecma_is_value_boolean (ignore_case_value));
if (ecma_is_value_true (ignore_case_value))
{
flags |= RE_FLAG_IGNORE_CASE;
}
magic_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_MULTILINE);
ecma_value_t multiline_value = ecma_op_object_get_own_data_prop (target_p, magic_string_p);
JERRY_ASSERT (ecma_is_value_boolean (multiline_value));
if (ecma_is_value_true (multiline_value))
{
flags |= RE_FLAG_MULTILINE;
}
ECMA_TRY_CATCH (obj_this, ecma_op_to_object (this_arg), ret_value);
ecma_object_t *this_obj_p = ecma_get_object_from_value (obj_this);
/* Get bytecode property. */
ecma_value_t *bc_prop_p = &(((ecma_extended_object_t *) this_obj_p)->u.class_prop.u.value);
/* TODO: We currently have to re-compile the bytecode, because
* we can't copy it without knowing its length. */
const re_compiled_code_t *new_bc_p = NULL;
ecma_value_t bc_comp = re_compile_bytecode (&new_bc_p, pattern_string_p, flags);
/* Should always succeed, since we're compiling from a source that has been compiled previously. */
JERRY_ASSERT (ecma_is_value_empty (bc_comp));
ecma_deref_ecma_string (pattern_string_p);
re_compiled_code_t *old_bc_p = ECMA_GET_INTERNAL_VALUE_ANY_POINTER (re_compiled_code_t, *bc_prop_p);
if (old_bc_p != NULL)
{
/* Free the old bytecode */
ecma_bytecode_deref ((ecma_compiled_code_t *) old_bc_p);
}
ECMA_SET_INTERNAL_VALUE_POINTER (*bc_prop_p, new_bc_p);
re_initialize_props (this_obj_p, pattern_string_p, flags);
ret_value = ECMA_VALUE_UNDEFINED;
ECMA_FINALIZE (obj_this);
}
return ecma_raise_type_error (ECMA_ERR_MSG ("Invalid argument of RegExp compile."));
}
else
/* Compile from existing RegExp pbject. */
ecma_object_t *target_p = ecma_get_object_from_value (pattern_arg);
/* Get source. */
ecma_string_t *magic_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_SOURCE);
ecma_value_t source_value = ecma_op_object_get_own_data_prop (target_p, magic_string_p);
ecma_string_t *pattern_string_p = ecma_get_string_from_value (source_value);
/* Get flags. */
magic_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_GLOBAL);
ecma_value_t global_value = ecma_op_object_get_own_data_prop (target_p, magic_string_p);
JERRY_ASSERT (ecma_is_value_boolean (global_value));
if (ecma_is_value_true (global_value))
{
ecma_string_t *pattern_string_p = NULL;
flags |= RE_FLAG_GLOBAL;
}
/* Get source string. */
ret_value = ecma_regexp_read_pattern_str_helper (pattern_arg, &pattern_string_p);
magic_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_IGNORECASE_UL);
ecma_value_t ignore_case_value = ecma_op_object_get_own_data_prop (target_p, magic_string_p);
/* Parse flags. */
if (ecma_is_value_empty (ret_value) && !ecma_is_value_undefined (flags_arg))
{
ECMA_TRY_CATCH (flags_str_value,
ecma_op_to_string (flags_arg),
ret_value);
JERRY_ASSERT (ecma_is_value_boolean (ignore_case_value));
ECMA_TRY_CATCH (flags_dummy,
re_parse_regexp_flags (ecma_get_string_from_value (flags_str_value), &flags),
ret_value);
ECMA_FINALIZE (flags_dummy);
ECMA_FINALIZE (flags_str_value);
}
if (ecma_is_value_true (ignore_case_value))
{
flags |= RE_FLAG_IGNORE_CASE;
}
if (ecma_is_value_empty (ret_value))
{
ECMA_TRY_CATCH (obj_this, ecma_op_to_object (this_arg), ret_value);
ecma_object_t *this_obj_p = ecma_get_object_from_value (obj_this);
magic_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_MULTILINE);
ecma_value_t multiline_value = ecma_op_object_get_own_data_prop (target_p, magic_string_p);
ecma_value_t *bc_prop_p = &(((ecma_extended_object_t *) this_obj_p)->u.class_prop.u.value);
JERRY_ASSERT (ecma_is_value_boolean (multiline_value));
/* Try to compile bytecode from new source. */
const re_compiled_code_t *new_bc_p = NULL;
ECMA_TRY_CATCH (bc_dummy,
re_compile_bytecode (&new_bc_p, pattern_string_p, flags),
ret_value);
if (ecma_is_value_true (multiline_value))
{
flags |= RE_FLAG_MULTILINE;
}
re_compiled_code_t *old_bc_p = ECMA_GET_INTERNAL_VALUE_ANY_POINTER (re_compiled_code_t, *bc_prop_p);
ecma_value_t obj_this = ecma_op_to_object (this_arg);
if (ECMA_IS_VALUE_ERROR (obj_this))
{
return obj_this;
}
ecma_object_t *this_obj_p = ecma_get_object_from_value (obj_this);
if (old_bc_p != NULL)
{
/* Free the old bytecode */
ecma_bytecode_deref ((ecma_compiled_code_t *) old_bc_p);
}
/* Get bytecode property. */
ecma_value_t *bc_prop_p = &(((ecma_extended_object_t *) this_obj_p)->u.class_prop.u.value);
ECMA_SET_INTERNAL_VALUE_POINTER (*bc_prop_p, new_bc_p);
re_initialize_props (this_obj_p, pattern_string_p, flags);
ret_value = ECMA_VALUE_UNDEFINED;
/* TODO: We currently have to re-compile the bytecode, because
* we can't copy it without knowing its length. */
const re_compiled_code_t *new_bc_p = NULL;
ecma_value_t bc_comp = re_compile_bytecode (&new_bc_p, pattern_string_p, flags);
/* Should always succeed, since we're compiling from a source that has been compiled previously. */
JERRY_ASSERT (ecma_is_value_empty (bc_comp));
ECMA_FINALIZE (bc_dummy);
ecma_deref_ecma_string (pattern_string_p);
ECMA_FINALIZE (obj_this);
}
re_compiled_code_t *old_bc_p = ECMA_GET_INTERNAL_VALUE_ANY_POINTER (re_compiled_code_t, *bc_prop_p);
if (pattern_string_p != NULL)
{
ecma_deref_ecma_string (pattern_string_p);
}
if (old_bc_p != NULL)
{
/* Free the old bytecode */
ecma_bytecode_deref ((ecma_compiled_code_t *) old_bc_p);
}
ECMA_SET_INTERNAL_VALUE_POINTER (*bc_prop_p, new_bc_p);
re_initialize_props (this_obj_p, pattern_string_p, flags);
ecma_free_value (obj_this);
return ECMA_VALUE_UNDEFINED;
}
ecma_string_t *pattern_string_p = NULL;
/* Get source string. */
ecma_value_t ret_value = ecma_regexp_read_pattern_str_helper (pattern_arg, &pattern_string_p);
if (ECMA_IS_VALUE_ERROR (ret_value))
{
JERRY_ASSERT (pattern_string_p == NULL);
return ret_value;
}
JERRY_ASSERT (ecma_is_value_empty (ret_value));
/* Parse flags. */
if (!ecma_is_value_undefined (flags_arg))
{
ecma_value_t flags_str_value = ecma_op_to_string (flags_arg);
if (ECMA_IS_VALUE_ERROR (flags_str_value))
{
ecma_deref_ecma_string (pattern_string_p);
return flags_str_value;
}
ecma_value_t parsed_flags_val = re_parse_regexp_flags (ecma_get_string_from_value (flags_str_value), &flags);
ecma_free_value (flags_str_value);
if (ECMA_IS_VALUE_ERROR (parsed_flags_val))
{
ecma_deref_ecma_string (pattern_string_p);
return parsed_flags_val;
}
}
return ret_value;
/* Try to compile bytecode from new source. */
const re_compiled_code_t *new_bc_p = NULL;
ecma_value_t bc_val = re_compile_bytecode (&new_bc_p, pattern_string_p, flags);
if (ECMA_IS_VALUE_ERROR (bc_val))
{
ecma_deref_ecma_string (pattern_string_p);
return bc_val;
}
ecma_value_t obj_this = ecma_op_to_object (this_arg);
if (ECMA_IS_VALUE_ERROR (obj_this))
{
ecma_deref_ecma_string (pattern_string_p);
return obj_this;
}
ecma_object_t *this_obj_p = ecma_get_object_from_value (obj_this);
ecma_value_t *bc_prop_p = &(((ecma_extended_object_t *) this_obj_p)->u.class_prop.u.value);
re_compiled_code_t *old_bc_p = ECMA_GET_INTERNAL_VALUE_ANY_POINTER (re_compiled_code_t, *bc_prop_p);
if (old_bc_p != NULL)
{
/* Free the old bytecode */
ecma_bytecode_deref ((ecma_compiled_code_t *) old_bc_p);
}
ECMA_SET_INTERNAL_VALUE_POINTER (*bc_prop_p, new_bc_p);
re_initialize_props (this_obj_p, pattern_string_p, flags);
ecma_free_value (obj_this);
ecma_deref_ecma_string (pattern_string_p);
return ECMA_VALUE_UNDEFINED;
} /* ecma_builtin_regexp_prototype_compile */
#endif /* !CONFIG_DISABLE_ANNEXB_BUILTIN */
@ -232,48 +233,49 @@ static ecma_value_t
ecma_builtin_regexp_prototype_exec (ecma_value_t this_arg, /**< this argument */
ecma_value_t arg) /**< routine's argument */
{
ecma_value_t ret_value = ECMA_VALUE_EMPTY;
if (!ecma_is_value_object (this_arg)
|| !ecma_object_class_is (ecma_get_object_from_value (this_arg), LIT_MAGIC_STRING_REGEXP_UL))
{
ret_value = ecma_raise_type_error (ECMA_ERR_MSG ("Incomplete RegExp type"));
return ecma_raise_type_error (ECMA_ERR_MSG ("Incomplete RegExp type"));
}
ecma_value_t obj_this = ecma_op_to_object (this_arg);
if (ECMA_IS_VALUE_ERROR (obj_this))
{
return obj_this;
}
ecma_value_t input_str_value = ecma_op_to_string (arg);
if (ECMA_IS_VALUE_ERROR (input_str_value))
{
ecma_free_value (obj_this);
return input_str_value;
}
ecma_object_t *obj_p = ecma_get_object_from_value (obj_this);
ecma_value_t *bytecode_prop_p = &(((ecma_extended_object_t *) obj_p)->u.class_prop.u.value);
void *bytecode_p = ECMA_GET_INTERNAL_VALUE_ANY_POINTER (void, *bytecode_prop_p);
ecma_value_t ret_value;
if (bytecode_p == NULL)
{
/* Missing bytecode means empty RegExp: '/(?:)/', so always return empty string. */
ecma_value_t empty_str_val = ecma_make_magic_string_value (LIT_MAGIC_STRING__EMPTY);
ret_value = ecma_op_create_array_object (&empty_str_val, 1, false);
re_set_result_array_properties (ecma_get_object_from_value (ret_value),
ecma_get_string_from_value (input_str_value),
1,
0);
}
else
{
ECMA_TRY_CATCH (obj_this, ecma_op_to_object (this_arg), ret_value);
ECMA_TRY_CATCH (input_str_value,
ecma_op_to_string (arg),
ret_value);
ecma_object_t *obj_p = ecma_get_object_from_value (obj_this);
ecma_value_t *bytecode_prop_p = &(((ecma_extended_object_t *) obj_p)->u.class_prop.u.value);
void *bytecode_p = ECMA_GET_INTERNAL_VALUE_ANY_POINTER (void, *bytecode_prop_p);
if (bytecode_p == NULL)
{
/* Missing bytecode means empty RegExp: '/(?:)/', so always return empty string. */
ecma_value_t arguments_list[1];
arguments_list[0] = ecma_make_magic_string_value (LIT_MAGIC_STRING__EMPTY);
ret_value = ecma_op_create_array_object (arguments_list, 1, false);
re_set_result_array_properties (ecma_get_object_from_value (ret_value),
ecma_get_string_from_value (input_str_value),
1,
0);
}
else
{
ret_value = ecma_regexp_exec_helper (obj_this, input_str_value, false);
}
ECMA_FINALIZE (input_str_value);
ECMA_FINALIZE (obj_this);
ret_value = ecma_regexp_exec_helper (obj_this, input_str_value, false);
}
ecma_free_value (obj_this);
ecma_free_value (input_str_value);
return ret_value;
} /* ecma_builtin_regexp_prototype_exec */

63
jerry-core/ecma/builtin-objects/ecma-builtin-regexp.c
View File

@ -64,7 +64,6 @@ ecma_value_t
ecma_builtin_regexp_dispatch_construct (const ecma_value_t *arguments_list_p, /**< arguments list */
ecma_length_t arguments_list_len) /**< number of arguments */
{
ecma_value_t ret_value = ECMA_VALUE_EMPTY;
ecma_value_t pattern_value = ECMA_VALUE_UNDEFINED;
ecma_value_t flags_value = ECMA_VALUE_UNDEFINED;
@ -84,54 +83,46 @@ ecma_builtin_regexp_dispatch_construct (const ecma_value_t *arguments_list_p, /*
{
if (ecma_is_value_undefined (flags_value))
{
ret_value = ecma_copy_value (pattern_value);
}
else
{
ret_value = ecma_raise_type_error (ECMA_ERR_MSG ("Invalid argument of RegExp call."));
return ecma_copy_value (pattern_value);
}
return ecma_raise_type_error (ECMA_ERR_MSG ("Invalid argument of RegExp call."));
}
else
ecma_string_t *pattern_string_p = NULL;
ecma_value_t ret_value = ecma_regexp_read_pattern_str_helper (pattern_value, &pattern_string_p);
if (ECMA_IS_VALUE_ERROR (ret_value))
{
ecma_string_t *pattern_string_p = NULL;
ecma_string_t *flags_string_p = NULL;
return ret_value;
}
JERRY_ASSERT (ecma_is_value_empty (ret_value));
ret_value = ecma_regexp_read_pattern_str_helper (pattern_value, &pattern_string_p);
uint16_t flags = 0;
if (!ecma_is_value_undefined (flags_value))
{
ecma_value_t flags_str_value = ecma_op_to_string (flags_value);
if (ecma_is_value_empty (ret_value) && !ecma_is_value_undefined (flags_value))
{
ECMA_TRY_CATCH (flags_str_value,
ecma_op_to_string (flags_value),
ret_value);
flags_string_p = ecma_get_string_from_value (flags_str_value);
ecma_ref_ecma_string (flags_string_p);
ECMA_FINALIZE (flags_str_value);
}
uint16_t flags = 0;
if (ecma_is_value_empty (ret_value) && (flags_string_p != NULL))
{
ret_value = re_parse_regexp_flags (flags_string_p, &flags);
}
if (ecma_is_value_empty (ret_value))
{
ret_value = ecma_op_create_regexp_object (pattern_string_p, flags);
}
if (pattern_string_p != NULL)
if (ECMA_IS_VALUE_ERROR (flags_str_value))
{
ecma_deref_ecma_string (pattern_string_p);
return flags_str_value;
}
if (flags_string_p != NULL)
ecma_string_t *flags_string_p = ecma_get_string_from_value (flags_str_value);
JERRY_ASSERT (flags_string_p != NULL);
ret_value = re_parse_regexp_flags (flags_string_p, &flags);
ecma_free_value (flags_str_value); // implicit frees flags_string_p
if (ECMA_IS_VALUE_ERROR (ret_value))
{
ecma_deref_ecma_string (flags_string_p);
ecma_deref_ecma_string (pattern_string_p);
return ret_value;
}
JERRY_ASSERT (ecma_is_value_empty (ret_value));
}
ret_value = ecma_op_create_regexp_object (pattern_string_p, flags);
ecma_deref_ecma_string (pattern_string_p);
return ret_value;
} /* ecma_builtin_regexp_dispatch_construct */

22
jerry-core/ecma/operations/ecma-comparison.c
View File

@ -286,12 +286,18 @@ ecma_op_abstract_relational_compare (ecma_value_t x, /**< first operand */
ecma_value_t ret_value = ECMA_VALUE_EMPTY;
/* 1., 2. */
ECMA_TRY_CATCH (prim_first_converted_value,
ecma_op_to_primitive (x, ECMA_PREFERRED_TYPE_NUMBER),
ret_value);
ECMA_TRY_CATCH (prim_second_converted_value,
ecma_op_to_primitive (y, ECMA_PREFERRED_TYPE_NUMBER),
ret_value);
ecma_value_t prim_first_converted_value = ecma_op_to_primitive (x, ECMA_PREFERRED_TYPE_NUMBER);
if (ECMA_IS_VALUE_ERROR (prim_first_converted_value))
{
return prim_first_converted_value;
}
ecma_value_t prim_second_converted_value = ecma_op_to_primitive (y, ECMA_PREFERRED_TYPE_NUMBER);
if (ECMA_IS_VALUE_ERROR (prim_second_converted_value))
{
ecma_free_value (prim_first_converted_value);
return prim_second_converted_value;
}
const ecma_value_t px = left_first ? prim_first_converted_value : prim_second_converted_value;
const ecma_value_t py = left_first ? prim_second_converted_value : prim_first_converted_value;
@ -393,8 +399,8 @@ ecma_op_abstract_relational_compare (ecma_value_t x, /**< first operand */
ret_value = ecma_make_boolean_value (is_px_less);
}
ECMA_FINALIZE (prim_second_converted_value);
ECMA_FINALIZE (prim_first_converted_value);
ecma_free_value (prim_second_converted_value);
ecma_free_value (prim_first_converted_value);
return ret_value;
} /* ecma_op_abstract_relational_compare */

39
jerry-core/ecma/operations/ecma-regexp-object.c
View File

@ -250,7 +250,6 @@ ecma_op_create_regexp_object (ecma_string_t *pattern_p, /**< input pattern */
uint16_t flags) /**< flags */
{
JERRY_ASSERT (pattern_p != NULL);
ecma_value_t ret_value = ECMA_VALUE_EMPTY;
ecma_object_t *re_prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_REGEXP_PROTOTYPE);
@ -264,22 +263,20 @@ ecma_op_create_regexp_object (ecma_string_t *pattern_p, /**< input pattern */
/* Compile bytecode. */
const re_compiled_code_t *bc_p = NULL;
ECMA_TRY_CATCH (empty, re_compile_bytecode (&bc_p, pattern_p, flags), ret_value);
ecma_value_t ret_value = re_compile_bytecode (&bc_p, pattern_p, flags);
if (ECMA_IS_VALUE_ERROR (ret_value))
{
ecma_deref_object (object_p);
return ret_value;
}
JERRY_ASSERT (ecma_is_value_empty (ret_value));
/* Set [[Class]] and bytecode internal properties. */
ext_object_p->u.class_prop.class_id = LIT_MAGIC_STRING_REGEXP_UL;
ECMA_SET_INTERNAL_VALUE_POINTER (ext_object_p->u.class_prop.u.value, bc_p);
ret_value = ecma_make_object_value (object_p);
ECMA_FINALIZE (empty);
if (ECMA_IS_VALUE_ERROR (ret_value))
{
ecma_deref_object (object_p);
}
return ret_value;
return ecma_make_object_value (object_p);
} /* ecma_op_create_regexp_object */
/**
@ -1280,7 +1277,7 @@ ecma_regexp_exec_helper (ecma_value_t regexp_value, /**< RegExp object */
const lit_utf8_byte_t *sub_str_p = NULL;
uint8_t *bc_start_p = (uint8_t *) (bc_p + 1);
while (ecma_is_value_empty (ret_value))
while (!ECMA_IS_VALUE_ERROR (ret_value))
{
if (index < 0 || index > (int32_t) input_str_len)
{
@ -1297,13 +1294,13 @@ ecma_regexp_exec_helper (ecma_value_t regexp_value, /**< RegExp object */
}
else
{
ECMA_TRY_CATCH (match_value, re_match_regexp (&re_ctx,
bc_start_p,
input_curr_p,
&sub_str_p),
ret_value);
ret_value = re_match_regexp (&re_ctx, bc_start_p, input_curr_p, &sub_str_p);
if (ECMA_IS_VALUE_ERROR (ret_value))
{
break;
}
if (ecma_is_value_true (match_value))
if (ecma_is_value_true (ret_value))
{
is_match = true;
break;
@ -1314,8 +1311,6 @@ ecma_regexp_exec_helper (ecma_value_t regexp_value, /**< RegExp object */
lit_utf8_incr (&input_curr_p);
}
index++;
ECMA_FINALIZE (match_value);
}
}
@ -1341,7 +1336,7 @@ ecma_regexp_exec_helper (ecma_value_t regexp_value, /**< RegExp object */
}
/* 3. Fill the result array or return with 'undefiend' */
if (ecma_is_value_empty (ret_value))
if (!ECMA_IS_VALUE_ERROR (ret_value))
{
if (is_match)
{

2
jerry-core/parser/regexp/re-compiler.c
View File

@ -262,7 +262,7 @@ re_parse_alternative (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context
ret_value = next_token_result;
break;
}
JERRY_ASSERT (next_token_result == ECMA_VALUE_EMPTY);
JERRY_ASSERT (ecma_is_value_empty (next_token_result));
uint32_t new_atom_start_offset = re_get_bytecode_length (re_ctx_p->bytecode_ctx_p);