/**
* Fill arguments' list
*
* @return empty completion value if argument list was filled successfully,
* otherwise - not normal completion value indicating completion type
* of last expression evaluated
*/
ecma_completion_value_t
fill_varg_list (vm_frame_ctx_t *frame_ctx_p, /**< interpreter context */
ecma_length_t args_number, /**< number of arguments */
ecma_value_t arg_values[], /**< out: arguments' values */
ecma_length_t *out_arg_number_p) /**< out: number of arguments
successfully read */
{
ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
ecma_length_t arg_index;
for (arg_index = 0;
arg_index < args_number && ecma_is_completion_value_empty (ret_value);
)
{
ecma_completion_value_t evaluate_arg_completion = vm_loop (frame_ctx_p, NULL);
if (ecma_is_completion_value_empty (evaluate_arg_completion))
{
vm_instr_t next_instr = vm_get_instr (frame_ctx_p->instrs_p, frame_ctx_p->pos);
JERRY_ASSERT (next_instr.op_idx == VM_OP_META);
JERRY_ASSERT (next_instr.data.meta.type == OPCODE_META_TYPE_VARG);
const idx_t varg_var_idx = next_instr.data.meta.data_1;
ecma_completion_value_t get_arg_completion = get_variable_value (frame_ctx_p, varg_var_idx, false);
if (ecma_is_completion_value_normal (get_arg_completion))
{
arg_values[arg_index++] = ecma_get_completion_value_value (get_arg_completion);
}
else
{
JERRY_ASSERT (ecma_is_completion_value_throw (get_arg_completion));
ret_value = get_arg_completion;
}
}
else
{
JERRY_ASSERT (ecma_is_completion_value_throw (evaluate_arg_completion));
ret_value = evaluate_arg_completion;
}
frame_ctx_p->pos++;
}
*out_arg_number_p = arg_index;
return ret_value;
} /* fill_varg_list */
/**
* Run the code, starting from specified instruction position
*/
ecma_completion_value_t
vm_run_from_pos (const vm_instr_t *instrs_p, /**< byte-code array */
vm_instr_counter_t start_pos, /**< position of starting instruction */
ecma_value_t this_binding_value, /**< value of 'ThisBinding' */
ecma_object_t *lex_env_p, /**< lexical environment to use */
bool is_strict, /**< is the code is strict mode code (ECMA-262 v5, 10.1.1) */
bool is_eval_code) /**< is the code is eval code (ECMA-262 v5, 10.1) */
{
ecma_completion_value_t completion;
const vm_instr_t *curr = &instrs_p[start_pos];
JERRY_ASSERT (curr->op_idx == VM_OP_REG_VAR_DECL);
const idx_t min_reg_num = curr->data.reg_var_decl.min;
const idx_t max_reg_num = curr->data.reg_var_decl.max;
JERRY_ASSERT (max_reg_num >= min_reg_num);
const int32_t regs_num = max_reg_num - min_reg_num + 1;
MEM_DEFINE_LOCAL_ARRAY (regs, regs_num, ecma_value_t);
vm_frame_ctx_t frame_ctx;
frame_ctx.instrs_p = instrs_p;
frame_ctx.pos = (vm_instr_counter_t) (start_pos + 1);
frame_ctx.this_binding = this_binding_value;
frame_ctx.lex_env_p = lex_env_p;
frame_ctx.is_strict = is_strict;
frame_ctx.is_eval_code = is_eval_code;
frame_ctx.is_call_in_direct_eval_form = false;
frame_ctx.min_reg_num = min_reg_num;
frame_ctx.max_reg_num = max_reg_num;
frame_ctx.tmp_num_p = ecma_alloc_number ();
vm_stack_add_frame (&frame_ctx.stack_frame, regs, regs_num);
vm_frame_ctx_t *prev_context_p = vm_top_context_p;
vm_top_context_p = &frame_ctx;
#ifdef MEM_STATS
interp_mem_stats_context_enter (&frame_ctx, start_pos);
#endif /* MEM_STATS */
completion = vm_loop (&frame_ctx, NULL);
JERRY_ASSERT (ecma_is_completion_value_throw (completion)
|| ecma_is_completion_value_return (completion));
vm_top_context_p = prev_context_p;
vm_stack_free_frame (&frame_ctx.stack_frame);
ecma_dealloc_number (frame_ctx.tmp_num_p);
#ifdef MEM_STATS
interp_mem_stats_context_exit (&frame_ctx, start_pos);
#endif /* MEM_STATS */
MEM_FINALIZE_LOCAL_ARRAY (regs);
return completion;
} /* vm_run_from_pos */
/**
* Run the code, starting from specified opcode
*/
ecma_completion_value_t
vm_run_from_pos (opcode_counter_t start_pos, /**< identifier of starting opcode */
ecma_value_t this_binding_value, /**< value of 'ThisBinding' */
ecma_object_t *lex_env_p, /**< lexical environment to use */
bool is_strict, /**< is the code is strict mode code (ECMA-262 v5, 10.1.1) */
bool is_eval_code) /**< is the code is eval code (ECMA-262 v5, 10.1) */
{
ecma_completion_value_t completion;
const opcode_t *curr = &__program[start_pos];
JERRY_ASSERT (curr->op_idx == __op__idx_reg_var_decl);
const idx_t min_reg_num = curr->data.reg_var_decl.min;
const idx_t max_reg_num = curr->data.reg_var_decl.max;
JERRY_ASSERT (max_reg_num >= min_reg_num);
const int32_t regs_num = max_reg_num - min_reg_num + 1;
MEM_DEFINE_LOCAL_ARRAY (regs, regs_num, ecma_value_t);
int_data_t int_data;
int_data.pos = (opcode_counter_t) (start_pos + 1);
int_data.this_binding = this_binding_value;
int_data.lex_env_p = lex_env_p;
int_data.is_strict = is_strict;
int_data.is_eval_code = is_eval_code;
int_data.min_reg_num = min_reg_num;
int_data.max_reg_num = max_reg_num;
int_data.tmp_num_p = ecma_alloc_number ();
ecma_stack_add_frame (&int_data.stack_frame, regs, regs_num);
int_data_t *prev_context_p = vm_top_context_p;
vm_top_context_p = &int_data;
#ifdef MEM_STATS
interp_mem_stats_context_enter (&int_data, start_pos);
#endif /* MEM_STATS */
completion = vm_loop (&int_data, NULL);
JERRY_ASSERT (ecma_is_completion_value_normal (completion)
|| ecma_is_completion_value_throw (completion)
|| ecma_is_completion_value_return (completion)
|| ecma_is_completion_value_exit (completion));
vm_top_context_p = prev_context_p;
ecma_stack_free_frame (&int_data.stack_frame);
ecma_dealloc_number (int_data.tmp_num_p);
#ifdef MEM_STATS
interp_mem_stats_context_exit (&int_data, start_pos);
#endif /* MEM_STATS */
MEM_FINALIZE_LOCAL_ARRAY (regs);
return completion;
} /* vm_run_from_pos */
/**
* Run global code
*/
jerry_completion_code_t
vm_run_global (void)
{
JERRY_ASSERT (__program != NULL);
JERRY_ASSERT (vm_top_context_p == NULL);
#ifdef MEM_STATS
interp_mem_stats_print_legend ();
#endif /* MEM_STATS */
bool is_strict = false;
opcode_counter_t start_pos = 0;
opcode_scope_code_flags_t scope_flags = vm_get_scope_flags (start_pos++);
if (scope_flags & OPCODE_SCOPE_CODE_FLAGS_STRICT)
{
is_strict = true;
}
ecma_object_t *glob_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_GLOBAL);
ecma_object_t *lex_env_p = ecma_get_global_environment ();
ecma_completion_value_t completion = vm_run_from_pos (start_pos,
ecma_make_object_value (glob_obj_p),
lex_env_p,
is_strict,
false);
jerry_completion_code_t ret_code;
if (ecma_is_completion_value_exit (completion))
{
if (ecma_is_value_true (ecma_get_completion_value_value (completion)))
{
ret_code = JERRY_COMPLETION_CODE_OK;
}
else
{
ret_code = JERRY_COMPLETION_CODE_FAILED_ASSERTION_IN_SCRIPT;
}
}
else
{
JERRY_ASSERT (ecma_is_completion_value_throw (completion));
ret_code = JERRY_COMPLETION_CODE_UNHANDLED_EXCEPTION;
}
ecma_free_completion_value (completion);
ecma_deref_object (glob_obj_p);
ecma_deref_object (lex_env_p);
JERRY_ASSERT (vm_top_context_p == NULL);
return ret_code;
} /* vm_run_global */
/**
* CreateMutableBinding operation.
*
* See also: ECMA-262 v5, 10.2.1
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
ecma_op_create_mutable_binding (ecma_object_t *lex_env_p, /**< lexical environment */
ecma_string_t *name_p, /**< argument N */
bool is_deletable) /**< argument D */
{
JERRY_ASSERT (lex_env_p != NULL
&& ecma_is_lexical_environment (lex_env_p));
JERRY_ASSERT (name_p != NULL);
if (ecma_get_lex_env_type (lex_env_p) == ECMA_LEXICAL_ENVIRONMENT_DECLARATIVE)
{
ecma_create_named_data_property (lex_env_p,
name_p,
true, false, is_deletable);
}
else
{
JERRY_ASSERT (ecma_get_lex_env_type (lex_env_p) == ECMA_LEXICAL_ENVIRONMENT_OBJECTBOUND);
ecma_object_t *binding_obj_p = ecma_get_lex_env_binding_object (lex_env_p);
ecma_property_descriptor_t prop_desc = ecma_make_empty_property_descriptor ();
{
prop_desc.is_value_defined = true;
prop_desc.value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
prop_desc.is_writable_defined = true;
prop_desc.is_writable = true;
prop_desc.is_enumerable_defined = true;
prop_desc.is_enumerable = true;
prop_desc.is_configurable_defined = true;
prop_desc.is_configurable = is_deletable;
}
ecma_completion_value_t completion = ecma_op_object_define_own_property (binding_obj_p,
name_p,
&prop_desc,
true);
if (ecma_is_completion_value_throw (completion))
{
return completion;
}
else
{
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion)
|| ecma_is_completion_value_normal_false (completion));
}
}
return ecma_make_empty_completion_value ();
} /* ecma_op_create_mutable_binding */
/**
* Run specified eval-mode bytecode
*
* @return completion value
*/
ecma_completion_value_t
vm_run_eval (const bytecode_data_header_t *bytecode_data_p, /**< byte-code data header */
bool is_direct) /**< is eval called in direct mode? */
{
vm_instr_counter_t first_instr_index = 0u;
opcode_scope_code_flags_t scope_flags = vm_get_scope_flags (bytecode_data_p, first_instr_index++);
bool is_strict = ((scope_flags & OPCODE_SCOPE_CODE_FLAGS_STRICT) != 0);
ecma_value_t this_binding;
ecma_object_t *lex_env_p;
/* ECMA-262 v5, 10.4.2 */
if (is_direct)
{
this_binding = vm_get_this_binding ();
lex_env_p = vm_get_lex_env ();
}
else
{
this_binding = ecma_make_object_value (ecma_builtin_get (ECMA_BUILTIN_ID_GLOBAL));
lex_env_p = ecma_get_global_environment ();
}
if (is_strict)
{
ecma_object_t *strict_lex_env_p = ecma_create_decl_lex_env (lex_env_p);
ecma_deref_object (lex_env_p);
lex_env_p = strict_lex_env_p;
}
ecma_completion_value_t completion = vm_run_from_pos (bytecode_data_p,
first_instr_index,
this_binding,
lex_env_p,
is_strict,
true,
NULL);
if (ecma_is_completion_value_return (completion))
{
completion = ecma_make_normal_completion_value (ecma_get_completion_value_value (completion));
}
else
{
JERRY_ASSERT (ecma_is_completion_value_throw (completion));
}
ecma_deref_object (lex_env_p);
ecma_free_value (this_binding, true);
return completion;
} /* vm_run_eval */
/**
* The String object's 'fromCharCode' routine
*
* See also:
* ECMA-262 v5, 15.5.3.2
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value.
*/
static ecma_completion_value_t
ecma_builtin_string_object_from_char_code (ecma_value_t this_arg __attr_unused___, /**< 'this' argument */
const ecma_value_t args[], /**< arguments list */
ecma_length_t args_number) /**< number of arguments */
{
ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
if (args_number == 0)
{
ecma_string_t *ret_str_p = ecma_new_ecma_string_from_utf8 (NULL, 0);
return ecma_make_normal_completion_value (ecma_make_string_value (ret_str_p));
}
lit_utf8_size_t utf8_buf_size = args_number * LIT_UTF8_MAX_BYTES_IN_CODE_UNIT;
ecma_string_t *ret_str_p;
MEM_DEFINE_LOCAL_ARRAY (utf8_buf_p, utf8_buf_size, lit_utf8_byte_t);
lit_utf8_size_t utf8_buf_used = 0;
FIXME ("Support surrogate pairs");
for (ecma_length_t arg_index = 0;
arg_index < args_number;
arg_index++)
{
ECMA_OP_TO_NUMBER_TRY_CATCH (arg_num, args[arg_index], ret_value);
uint32_t uint32_char_code = ecma_number_to_uint32 (arg_num);
ecma_char_t code_unit = (uint16_t) uint32_char_code;
JERRY_ASSERT (utf8_buf_used <= utf8_buf_size - LIT_UTF8_MAX_BYTES_IN_CODE_UNIT);
utf8_buf_used += lit_code_unit_to_utf8 (code_unit, utf8_buf_p + utf8_buf_used);
JERRY_ASSERT (utf8_buf_used <= utf8_buf_size);
ECMA_OP_TO_NUMBER_FINALIZE (arg_num);
if (ecma_is_completion_value_throw (ret_value))
{
mem_heap_free_block (utf8_buf_p);
return ret_value;
}
JERRY_ASSERT (ecma_is_completion_value_empty (ret_value));
}
ret_str_p = ecma_new_ecma_string_from_utf8 (utf8_buf_p, utf8_buf_used);
MEM_FINALIZE_LOCAL_ARRAY (utf8_buf_p);
return ecma_make_normal_completion_value (ecma_make_string_value (ret_str_p));
} /* ecma_builtin_string_object_from_char_code */
/**
* RegExp object creation operation.
*
* See also: ECMA-262 v5, 15.10.4.1
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
ecma_op_create_regexp_object (ecma_string_t *pattern_p, /**< input pattern */
ecma_string_t *flags_str_p) /**< flags */
{
JERRY_ASSERT (pattern_p != NULL);
ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
uint8_t flags = 0;
if (flags_str_p != NULL)
{
ECMA_TRY_CATCH (empty, re_parse_regexp_flags (flags_str_p, &flags), ret_value);
ECMA_FINALIZE (empty);
if (!ecma_is_completion_value_empty (ret_value))
{
return ret_value;
}
}
ecma_object_t *re_prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_REGEXP_PROTOTYPE);
ecma_object_t *obj_p = ecma_create_object (re_prototype_obj_p, true, ECMA_OBJECT_TYPE_GENERAL);
ecma_deref_object (re_prototype_obj_p);
/* Set the internal [[Class]] property */
ecma_property_t *class_prop_p = ecma_create_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_CLASS);
class_prop_p->u.internal_property.value = LIT_MAGIC_STRING_REGEXP_UL;
re_initialize_props (obj_p, pattern_p, flags);
/* Set bytecode internal property. */
ecma_property_t *bytecode_prop_p;
bytecode_prop_p = ecma_create_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_REGEXP_BYTECODE);
/* Compile bytecode. */
re_bytecode_t *bc_p = NULL;
ECMA_TRY_CATCH (empty, re_compile_bytecode (&bc_p, pattern_p, flags), ret_value);
ECMA_SET_POINTER (bytecode_prop_p->u.internal_property.value, bc_p);
ret_value = ecma_make_normal_completion_value (ecma_make_object_value (obj_p));
ECMA_FINALIZE (empty);
if (ecma_is_completion_value_throw (ret_value))
{
ecma_deref_object (obj_p);
}
return ret_value;
} /* ecma_op_create_regexp_object */
/**
* [[DefineOwnProperty]] ecma array object's operation
*
* See also:
* ECMA-262 v5, 8.6.2; ECMA-262 v5, Table 8
* ECMA-262 v5, 15.4.5.1
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
ecma_op_array_object_define_own_property (ecma_object_t *obj_p, /**< the array object */
ecma_string_t *property_name_p, /**< property name */
const ecma_property_descriptor_t *property_desc_p, /**< property descriptor */
bool is_throw) /**< flag that controls failure handling */
{
JERRY_ASSERT (ecma_get_object_type (obj_p) == ECMA_OBJECT_TYPE_ARRAY);
// 1.
ecma_string_t *magic_string_length_p = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
ecma_property_t *len_prop_p = ecma_op_object_get_own_property (obj_p, magic_string_length_p);
JERRY_ASSERT (len_prop_p != NULL && len_prop_p->type == ECMA_PROPERTY_NAMEDDATA);
// 2.
ecma_value_t old_len_value = ecma_get_named_data_property_value (len_prop_p);
ecma_number_t *num_p = ecma_get_number_from_value (old_len_value);
uint32_t old_len_uint32 = ecma_number_to_uint32 (*num_p);
// 3.
bool is_property_name_equal_length = ecma_compare_ecma_strings (property_name_p,
magic_string_length_p);
ecma_deref_ecma_string (magic_string_length_p);
if (is_property_name_equal_length)
{
// a.
if (!property_desc_p->is_value_defined)
{
// i.
return ecma_op_general_object_define_own_property (obj_p, property_name_p, property_desc_p, is_throw);
}
ecma_number_t new_len_num;
// c.
ecma_completion_value_t completion = ecma_op_to_number (property_desc_p->value);
if (ecma_is_completion_value_throw (completion))
{
return completion;
}
JERRY_ASSERT (ecma_is_completion_value_normal (completion)
&& ecma_is_value_number (ecma_get_completion_value_value (completion)));
new_len_num = *ecma_get_number_from_completion_value (completion);
ecma_free_completion_value (completion);
uint32_t new_len_uint32 = ecma_number_to_uint32 (new_len_num);
// d.
if (ecma_uint32_to_number (new_len_uint32) != new_len_num)
{
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_RANGE));
}
else
{
// b., e.
ecma_number_t *new_len_num_p = ecma_alloc_number ();
*new_len_num_p = new_len_num;
ecma_property_descriptor_t new_len_property_desc = *property_desc_p;
new_len_property_desc.value = ecma_make_number_value (new_len_num_p);
ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
// f.
if (new_len_uint32 >= old_len_uint32)
{
// i.
magic_string_length_p = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
ret_value = ecma_op_general_object_define_own_property (obj_p,
magic_string_length_p,
&new_len_property_desc,
is_throw);
ecma_deref_ecma_string (magic_string_length_p);
}
else
{
// g.
if (!ecma_is_property_writable (len_prop_p))
{
ret_value = ecma_reject (is_throw);
}
else
{
// h.
bool new_writable;
if (!new_len_property_desc.is_writable_defined
|| new_len_property_desc.is_writable)
{
new_writable = true;
}
else
{
// ii.
new_writable = false;
// iii.
new_len_property_desc.is_writable_defined = true;
new_len_property_desc.is_writable = true;
}
// j.
magic_string_length_p = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
ecma_completion_value_t succeeded = ecma_op_general_object_define_own_property (obj_p,
magic_string_length_p,
&new_len_property_desc,
is_throw);
ecma_deref_ecma_string (magic_string_length_p);
/* Handling normal false and throw values */
if (!ecma_is_completion_value_normal_true (succeeded))
{
JERRY_ASSERT (ecma_is_completion_value_normal_false (succeeded)
|| ecma_is_completion_value_throw (succeeded));
// k.
ret_value = succeeded;
}
else
{
// l
JERRY_ASSERT (new_len_uint32 < old_len_uint32);
/*
* Item i. is replaced with faster iteration: only indices that actually exist in the array, are iterated
*/
bool is_reduce_succeeded = true;
ecma_collection_header_t *array_index_props_p = ecma_op_object_get_property_names (obj_p,
true,
false,
false);
ecma_length_t array_index_props_num = array_index_props_p->unit_number;
MEM_DEFINE_LOCAL_ARRAY (array_index_values_p, array_index_props_num, uint32_t);
ecma_collection_iterator_t iter;
ecma_collection_iterator_init (&iter, array_index_props_p);
uint32_t array_index_values_pos = 0;
while (ecma_collection_iterator_next (&iter))
{
ecma_string_t *property_name_p = ecma_get_string_from_value (*iter.current_value_p);
uint32_t index;
bool is_index = ecma_string_get_array_index (property_name_p, &index);
JERRY_ASSERT (is_index);
JERRY_ASSERT (index < old_len_uint32);
array_index_values_p[array_index_values_pos++] = index;
}
JERRY_ASSERT (array_index_values_pos == array_index_props_num);
while (array_index_values_pos != 0
&& array_index_values_p[--array_index_values_pos] >= new_len_uint32)
{
uint32_t index = array_index_values_p[array_index_values_pos];
// ii.
ecma_string_t *index_string_p = ecma_new_ecma_string_from_uint32 (index);
ecma_completion_value_t delete_succeeded = ecma_op_object_delete (obj_p,
index_string_p,
false);
ecma_deref_ecma_string (index_string_p);
if (ecma_is_completion_value_normal_false (delete_succeeded))
{
// iii.
new_len_uint32 = (index + 1u);
ecma_number_t *new_len_num_p = ecma_get_number_from_value (new_len_property_desc.value);
// 1.
*new_len_num_p = ecma_uint32_to_number (index + 1u);
// 2.
if (!new_writable)
{
new_len_property_desc.is_writable_defined = true;
new_len_property_desc.is_writable = false;
}
// 3.
ecma_string_t *magic_string_length_p = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
ecma_completion_value_t completion = ecma_op_general_object_define_own_property (obj_p,
magic_string_length_p,
&new_len_property_desc,
false);
ecma_deref_ecma_string (magic_string_length_p);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion)
|| ecma_is_completion_value_normal_false (completion));
is_reduce_succeeded = false;
break;
}
}
MEM_FINALIZE_LOCAL_ARRAY (array_index_values_p);
ecma_free_values_collection (array_index_props_p, true);
if (!is_reduce_succeeded)
{
ret_value = ecma_reject (is_throw);
}
else
{
// m.
if (!new_writable)
{
ecma_property_descriptor_t prop_desc_not_writable = ecma_make_empty_property_descriptor ();
prop_desc_not_writable.is_writable_defined = true;
prop_desc_not_writable.is_writable = false;
ecma_completion_value_t completion_set_not_writable;
magic_string_length_p = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
completion_set_not_writable = ecma_op_general_object_define_own_property (obj_p,
magic_string_length_p,
&prop_desc_not_writable,
false);
ecma_deref_ecma_string (magic_string_length_p);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion_set_not_writable));
}
ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
}
}
}
ecma_dealloc_number (new_len_num_p);
return ret_value;
}
JERRY_UNREACHABLE ();
}
else
{
// 4.a.
uint32_t index;
if (!ecma_string_get_array_index (property_name_p, &index))
{
// 5.
return ecma_op_general_object_define_own_property (obj_p,
property_name_p,
property_desc_p,
is_throw);
}
// 4.
// b.
if (index >= old_len_uint32
&& !ecma_is_property_writable (len_prop_p))
{
return ecma_reject (is_throw);
}
// c.
ecma_completion_value_t succeeded = ecma_op_general_object_define_own_property (obj_p,
property_name_p,
property_desc_p,
false);
// d.
JERRY_ASSERT (ecma_is_completion_value_normal_true (succeeded)
|| ecma_is_completion_value_normal_false (succeeded));
if (ecma_is_completion_value_normal_false (succeeded))
{
return ecma_reject (is_throw);
}
// e.
if (index >= old_len_uint32)
{
// i., ii.
ecma_number_t *num_p = ecma_alloc_number ();
*num_p = ecma_number_add (ecma_uint32_to_number (index), ECMA_NUMBER_ONE);
ecma_named_data_property_assign_value (obj_p, len_prop_p, ecma_make_number_value (num_p));
ecma_dealloc_number (num_p);
}
// f.
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
JERRY_UNREACHABLE ();
} /* ecma_op_array_object_define_own_property */
/**
* 'Try' opcode handler.
*
* See also: ECMA-262 v5, 12.14
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
opfunc_try_block (opcode_t opdata, /**< operation data */
vm_frame_ctx_t *frame_ctx_p) /**< interpreter context */
{
const idx_t block_end_oc_idx_1 = opdata.data.try_block.oc_idx_1;
const idx_t block_end_oc_idx_2 = opdata.data.try_block.oc_idx_2;
const opcode_counter_t try_end_oc = (opcode_counter_t) (
calc_opcode_counter_from_idx_idx (block_end_oc_idx_1, block_end_oc_idx_2) + frame_ctx_p->pos);
frame_ctx_p->pos++;
vm_run_scope_t run_scope_try = { frame_ctx_p->pos, try_end_oc };
ecma_completion_value_t try_completion = vm_loop (frame_ctx_p, &run_scope_try);
JERRY_ASSERT ((!ecma_is_completion_value_empty (try_completion) && frame_ctx_p->pos <= try_end_oc)
|| (ecma_is_completion_value_empty (try_completion) && frame_ctx_p->pos == try_end_oc));
frame_ctx_p->pos = try_end_oc;
opcode_t next_opcode = vm_get_opcode (frame_ctx_p->opcodes_p, frame_ctx_p->pos);
JERRY_ASSERT (next_opcode.op_idx == __op__idx_meta);
if (next_opcode.data.meta.type == OPCODE_META_TYPE_CATCH)
{
const opcode_counter_t catch_end_oc = (opcode_counter_t) (
read_meta_opcode_counter (OPCODE_META_TYPE_CATCH, frame_ctx_p) + frame_ctx_p->pos);
frame_ctx_p->pos++;
if (ecma_is_completion_value_throw (try_completion))
{
next_opcode = vm_get_opcode (frame_ctx_p->opcodes_p, frame_ctx_p->pos);
JERRY_ASSERT (next_opcode.op_idx == __op__idx_meta);
JERRY_ASSERT (next_opcode.data.meta.type == OPCODE_META_TYPE_CATCH_EXCEPTION_IDENTIFIER);
lit_cpointer_t catch_exc_val_var_name_lit_cp = serializer_get_literal_cp_by_uid (next_opcode.data.meta.data_1,
frame_ctx_p->opcodes_p,
frame_ctx_p->pos);
frame_ctx_p->pos++;
ecma_string_t *catch_exc_var_name_str_p = ecma_new_ecma_string_from_lit_cp (catch_exc_val_var_name_lit_cp);
ecma_object_t *old_env_p = frame_ctx_p->lex_env_p;
ecma_object_t *catch_env_p = ecma_create_decl_lex_env (old_env_p);
ecma_completion_value_t completion = ecma_op_create_mutable_binding (catch_env_p,
catch_exc_var_name_str_p,
false);
JERRY_ASSERT (ecma_is_completion_value_empty (completion));
completion = ecma_op_set_mutable_binding (catch_env_p,
catch_exc_var_name_str_p,
ecma_get_completion_value_value (try_completion),
false);
JERRY_ASSERT (ecma_is_completion_value_empty (completion));
ecma_deref_ecma_string (catch_exc_var_name_str_p);
frame_ctx_p->lex_env_p = catch_env_p;
ecma_free_completion_value (try_completion);
vm_run_scope_t run_scope_catch = { frame_ctx_p->pos, catch_end_oc };
try_completion = vm_loop (frame_ctx_p, &run_scope_catch);
frame_ctx_p->lex_env_p = old_env_p;
ecma_deref_object (catch_env_p);
JERRY_ASSERT ((!ecma_is_completion_value_empty (try_completion) && frame_ctx_p->pos <= catch_end_oc)
|| (ecma_is_completion_value_empty (try_completion) && frame_ctx_p->pos == catch_end_oc));
}
frame_ctx_p->pos = catch_end_oc;
}
next_opcode = vm_get_opcode (frame_ctx_p->opcodes_p, frame_ctx_p->pos);
JERRY_ASSERT (next_opcode.op_idx == __op__idx_meta);
if (next_opcode.data.meta.type == OPCODE_META_TYPE_FINALLY)
{
const opcode_counter_t finally_end_oc = (opcode_counter_t) (
read_meta_opcode_counter (OPCODE_META_TYPE_FINALLY, frame_ctx_p) + frame_ctx_p->pos);
frame_ctx_p->pos++;
vm_run_scope_t run_scope_finally = { frame_ctx_p->pos, finally_end_oc };
ecma_completion_value_t finally_completion = vm_loop (frame_ctx_p, &run_scope_finally);
JERRY_ASSERT ((!ecma_is_completion_value_empty (finally_completion) && frame_ctx_p->pos <= finally_end_oc)
|| (ecma_is_completion_value_empty (finally_completion) && frame_ctx_p->pos == finally_end_oc));
frame_ctx_p->pos = finally_end_oc;
if (!ecma_is_completion_value_empty (finally_completion))
{
ecma_free_completion_value (try_completion);
try_completion = finally_completion;
}
}
next_opcode = vm_get_opcode (frame_ctx_p->opcodes_p, frame_ctx_p->pos++);
JERRY_ASSERT (next_opcode.op_idx == __op__idx_meta);
JERRY_ASSERT (next_opcode.data.meta.type == OPCODE_META_TYPE_END_TRY_CATCH_FINALLY);
return try_completion;
} /* opfunc_try_block */
/**
* SetMutableBinding operation.
*
* See also: ECMA-262 v5, 10.2.1
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value.
*/
ecma_completion_value_t
ecma_op_set_mutable_binding (ecma_object_t *lex_env_p, /**< lexical environment */
ecma_string_t *name_p, /**< argument N */
ecma_value_t value, /**< argument V */
bool is_strict) /**< argument S */
{
JERRY_ASSERT (lex_env_p != NULL
&& ecma_is_lexical_environment (lex_env_p));
JERRY_ASSERT (name_p != NULL);
if (ecma_get_lex_env_type (lex_env_p) == ECMA_LEXICAL_ENVIRONMENT_DECLARATIVE)
{
#ifndef JERRY_NDEBUG
# ifdef CONFIG_ECMA_COMPACT_PROFILE
bool is_equal = false;
ecma_string_t *arguments_magic_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_ARGUMENTS);
if (ecma_compare_ecma_strings (name_p, arguments_magic_string_p))
{
is_equal = true;
}
ecma_deref_ecma_string (arguments_magic_string_p);
JERRY_ASSERT (!is_equal);
if (is_equal)
{
return ecma_make_throw_obj_completion_value (ecma_builtin_get (ECMA_BUILTIN_ID_COMPACT_PROFILE_ERROR));
}
# endif /* CONFIG_ECMA_COMPACT_PROFILE */
#endif /* !JERRY_NDEBUG */
ecma_property_t *property_p = ecma_get_named_data_property (lex_env_p, name_p);
if (ecma_is_property_writable (property_p))
{
ecma_named_data_property_assign_value (lex_env_p, property_p, value);
}
else if (is_strict)
{
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
}
else
{
JERRY_ASSERT (ecma_get_lex_env_type (lex_env_p) == ECMA_LEXICAL_ENVIRONMENT_OBJECTBOUND);
ecma_object_t *binding_obj_p = ecma_get_lex_env_binding_object (lex_env_p);
ecma_completion_value_t completion = ecma_op_object_put (binding_obj_p,
name_p,
value,
is_strict);
if (ecma_is_completion_value_throw (completion))
{
return completion;
}
else
{
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion)
|| ecma_is_completion_value_normal_false (completion));
}
}
return ecma_make_empty_completion_value ();
} /* ecma_op_set_mutable_binding */
/**
* 'for-in' opcode handler
*
* See also:
* ECMA-262 v5, 12.6.4
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
opfunc_for_in (vm_instr_t instr, /**< instruction */
vm_frame_ctx_t *int_data_p) /**< interpreter context */
{
const idx_t expr_idx = instr.data.for_in.expr;
const idx_t block_end_oc_idx_1 = instr.data.for_in.oc_idx_1;
const idx_t block_end_oc_idx_2 = instr.data.for_in.oc_idx_2;
const vm_instr_counter_t for_in_end_oc = (vm_instr_counter_t) (
vm_calc_instr_counter_from_idx_idx (block_end_oc_idx_1,
block_end_oc_idx_2) + int_data_p->pos);
ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
/* 1., 2. */
ECMA_TRY_CATCH (expr_value,
get_variable_value (int_data_p,
expr_idx,
false),
ret_value);
int_data_p->pos++;
vm_instr_t meta_instr = vm_get_instr (int_data_p->instrs_p, for_in_end_oc);
JERRY_ASSERT (meta_instr.op_idx == VM_OP_META);
JERRY_ASSERT (meta_instr.data.meta.type == OPCODE_META_TYPE_END_FOR_IN);
/* 3. */
if (!ecma_is_value_undefined (expr_value)
&& !ecma_is_value_null (expr_value))
{
/* 4. */
ECMA_TRY_CATCH (obj_expr_value,
ecma_op_to_object (expr_value),
ret_value);
ecma_object_t *obj_p = ecma_get_object_from_value (obj_expr_value);
ecma_collection_iterator_t names_iterator;
ecma_collection_header_t *names_p = vm_helper_for_in_enumerate_properties_names (obj_p);
if (names_p != NULL)
{
ecma_collection_iterator_init (&names_iterator, names_p);
const vm_instr_counter_t for_in_body_begin_oc = int_data_p->pos;
const vm_instr_counter_t for_in_body_end_oc = for_in_end_oc;
while (ecma_collection_iterator_next (&names_iterator))
{
ecma_value_t name_value = *names_iterator.current_value_p;
ecma_string_t *name_p = ecma_get_string_from_value (name_value);
if (ecma_op_object_get_property (obj_p, name_p) != NULL)
{
ecma_completion_value_t completion = set_variable_value (int_data_p,
int_data_p->pos,
OPCODE_REG_SPECIAL_FOR_IN_PROPERTY_NAME,
name_value);
JERRY_ASSERT (ecma_is_completion_value_empty (completion));
vm_run_scope_t run_scope_for_in = { for_in_body_begin_oc, for_in_body_end_oc };
ecma_completion_value_t for_in_body_completion = vm_loop (int_data_p, &run_scope_for_in);
if (ecma_is_completion_value_empty (for_in_body_completion))
{
JERRY_ASSERT (int_data_p->pos == for_in_body_end_oc);
int_data_p->pos = for_in_body_begin_oc;
}
else
{
JERRY_ASSERT (ecma_is_completion_value_throw (for_in_body_completion)
|| ecma_is_completion_value_return (for_in_body_completion)
|| ecma_is_completion_value_jump (for_in_body_completion));
JERRY_ASSERT (int_data_p->pos <= for_in_body_end_oc);
ret_value = for_in_body_completion;
break;
}
}
}
ecma_free_values_collection (names_p, true);
}
ECMA_FINALIZE (obj_expr_value);
}
int_data_p->pos = (vm_instr_counter_t) (for_in_end_oc + 1u);
ECMA_FINALIZE (expr_value);
return ret_value;
} /* opfunc_for_in */
/**
* Recursive function for RegExp matching. Tests for a regular expression
* match and returns a MatchResult value.
*
* See also:
* ECMA-262 v5, 15.10.2.1
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
static ecma_completion_value_t
re_match_regexp (re_matcher_ctx_t *re_ctx_p, /**< RegExp matcher context */
re_bytecode_t *bc_p, /**< pointer to the current RegExp bytecode */
lit_utf8_iterator_t iter, /**< input string iterator */
lit_utf8_iterator_t *out_iter_p) /**< Output: matching substring iterator */
{
ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
re_opcode_t op;
while ((op = re_get_opcode (&bc_p)))
{
switch (op)
{
case RE_OP_MATCH:
{
JERRY_DDLOG ("Execute RE_OP_MATCH: match\n");
*out_iter_p = iter;
ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
return ret_value; /* match */
}
case RE_OP_CHAR:
{
if (lit_utf8_iterator_is_eos (&iter))
{
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
bool is_ignorecase = re_ctx_p->flags & RE_FLAG_IGNORE_CASE;
ecma_char_t ch1 = (ecma_char_t) re_get_value (&bc_p); /* Already canonicalized. */
ecma_char_t ch2 = re_canonicalize (lit_utf8_iterator_read_next (&iter), is_ignorecase);
JERRY_DDLOG ("Character matching %d to %d: ", ch1, ch2);
if (ch1 != ch2)
{
JERRY_DDLOG ("fail\n");
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
JERRY_DDLOG ("match\n");
break; /* tail merge */
}
case RE_OP_PERIOD:
{
if (lit_utf8_iterator_is_eos (&iter))
{
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
ecma_char_t ch = lit_utf8_iterator_read_next (&iter);
JERRY_DDLOG ("Period matching '.' to %d: ", (uint32_t) ch);
if (lit_char_is_line_terminator (ch))
{
JERRY_DDLOG ("fail\n");
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
JERRY_DDLOG ("match\n");
break; /* tail merge */
}
case RE_OP_ASSERT_START:
{
JERRY_DDLOG ("Execute RE_OP_ASSERT_START: ");
if ((iter.buf_p + iter.buf_pos.offset) <= re_ctx_p->input_start_p)
{
JERRY_DDLOG ("match\n");
break;
}
if (!(re_ctx_p->flags & RE_FLAG_MULTILINE))
{
JERRY_DDLOG ("fail\n");
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
if (lit_char_is_line_terminator (lit_utf8_iterator_peek_prev (&iter)))
{
JERRY_DDLOG ("match\n");
break;
}
JERRY_DDLOG ("fail\n");
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
case RE_OP_ASSERT_END:
{
JERRY_DDLOG ("Execute RE_OP_ASSERT_END: ");
if ((iter.buf_p + iter.buf_pos.offset) >= re_ctx_p->input_end_p)
{
JERRY_DDLOG ("match\n");
break; /* tail merge */
}
if (!(re_ctx_p->flags & RE_FLAG_MULTILINE))
{
JERRY_DDLOG ("fail\n");
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
if (lit_char_is_line_terminator (lit_utf8_iterator_peek_next (&iter)))
{
JERRY_DDLOG ("match\n");
break; /* tail merge */
}
JERRY_DDLOG ("fail\n");
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
case RE_OP_ASSERT_WORD_BOUNDARY:
case RE_OP_ASSERT_NOT_WORD_BOUNDARY:
{
bool is_wordchar_left, is_wordchar_right;
if ((iter.buf_p + iter.buf_pos.offset) <= re_ctx_p->input_start_p)
{
is_wordchar_left = false; /* not a wordchar */
}
else
{
is_wordchar_left = lit_char_is_word_char (lit_utf8_iterator_peek_prev (&iter));
}
if ((iter.buf_p + iter.buf_pos.offset) >= re_ctx_p->input_end_p)
{
is_wordchar_right = false; /* not a wordchar */
}
else
{
is_wordchar_right = lit_char_is_word_char (lit_utf8_iterator_peek_next (&iter));
}
if (op == RE_OP_ASSERT_WORD_BOUNDARY)
{
JERRY_DDLOG ("Execute RE_OP_ASSERT_WORD_BOUNDARY: ");
if (is_wordchar_left == is_wordchar_right)
{
JERRY_DDLOG ("fail\n");
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
}
else
{
JERRY_ASSERT (op == RE_OP_ASSERT_NOT_WORD_BOUNDARY);
JERRY_DDLOG ("Execute RE_OP_ASSERT_NOT_WORD_BOUNDARY: ");
if (is_wordchar_left != is_wordchar_right)
{
JERRY_DDLOG ("fail\n");
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
}
JERRY_DDLOG ("match\n");
break; /* tail merge */
}
case RE_OP_LOOKAHEAD_POS:
case RE_OP_LOOKAHEAD_NEG:
{
ecma_completion_value_t match_value = ecma_make_empty_completion_value ();
lit_utf8_iterator_t sub_iter = lit_utf8_iterator_create (NULL, 0);
uint32_t array_size = re_ctx_p->num_of_captures + re_ctx_p->num_of_non_captures;
MEM_DEFINE_LOCAL_ARRAY (saved_bck_p, array_size, lit_utf8_iterator_t);
size_t size = (size_t) (array_size) * sizeof (lit_utf8_iterator_t);
memcpy (saved_bck_p, re_ctx_p->saved_p, size);
do
{
uint32_t offset = re_get_value (&bc_p);
if (!sub_iter.buf_p)
{
match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
if (ecma_is_completion_value_throw (match_value))
{
break;
}
}
bc_p += offset;
}
while (re_get_opcode (&bc_p) == RE_OP_ALTERNATIVE);
if (!ecma_is_completion_value_throw (match_value))
{
JERRY_DDLOG ("Execute RE_OP_LOOKAHEAD_POS/NEG: ");
ecma_free_completion_value (match_value);
if ((op == RE_OP_LOOKAHEAD_POS && sub_iter.buf_p)
|| (op == RE_OP_LOOKAHEAD_NEG && !sub_iter.buf_p))
{
JERRY_DDLOG ("match\n");
match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
}
else
{
JERRY_DDLOG ("fail\n");
match_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
}
if (!ecma_is_completion_value_throw (match_value))
{
if (ecma_is_value_true (match_value))
{
*out_iter_p = sub_iter;
}
else
{
JERRY_ASSERT (ecma_is_value_boolean (match_value));
/* restore saved */
memcpy (re_ctx_p->saved_p, saved_bck_p, size);
}
}
MEM_FINALIZE_LOCAL_ARRAY (saved_bck_p);
return match_value;
}
case RE_OP_CHAR_CLASS:
case RE_OP_INV_CHAR_CLASS:
{
uint32_t num_of_ranges;
bool is_match;
JERRY_DDLOG ("Execute RE_OP_CHAR_CLASS/RE_OP_INV_CHAR_CLASS, ");
if (lit_utf8_iterator_is_eos (&iter))
{
JERRY_DDLOG ("fail\n");
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
bool is_ignorecase = re_ctx_p->flags & RE_FLAG_IGNORE_CASE;
ecma_char_t curr_ch = re_canonicalize (lit_utf8_iterator_read_next (&iter), is_ignorecase);
num_of_ranges = re_get_value (&bc_p);
is_match = false;
while (num_of_ranges)
{
ecma_char_t ch1 = re_canonicalize ((ecma_char_t) re_get_value (&bc_p), is_ignorecase);
ecma_char_t ch2 = re_canonicalize ((ecma_char_t) re_get_value (&bc_p), is_ignorecase);
JERRY_DDLOG ("num_of_ranges=%d, ch1=%d, ch2=%d, curr_ch=%d; ",
num_of_ranges, ch1, ch2, curr_ch);
if (curr_ch >= ch1 && curr_ch <= ch2)
{
/* We must read all the ranges from bytecode. */
is_match = true;
}
num_of_ranges--;
}
if (op == RE_OP_CHAR_CLASS)
{
if (!is_match)
{
JERRY_DDLOG ("fail\n");
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
}
else
{
JERRY_ASSERT (op == RE_OP_INV_CHAR_CLASS);
if (is_match)
{
JERRY_DDLOG ("fail\n");
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
}
JERRY_DDLOG ("match\n");
break; /* tail merge */
}
case RE_OP_BACKREFERENCE:
{
uint32_t backref_idx;
backref_idx = re_get_value (&bc_p);
JERRY_DDLOG ("Execute RE_OP_BACKREFERENCE (idx: %d): ", backref_idx);
backref_idx *= 2; /* backref n -> saved indices [n*2, n*2+1] */
JERRY_ASSERT (backref_idx >= 2 && backref_idx + 1 < re_ctx_p->num_of_captures);
if (!re_ctx_p->saved_p[backref_idx].buf_p || !re_ctx_p->saved_p[backref_idx + 1].buf_p)
{
JERRY_DDLOG ("match\n");
break; /* capture is 'undefined', always matches! */
}
lit_utf8_iterator_t sub_iter = re_ctx_p->saved_p[backref_idx];
while (sub_iter.buf_pos.offset < re_ctx_p->saved_p[backref_idx + 1].buf_pos.offset)
{
ecma_char_t ch1, ch2;
if ((iter.buf_p + iter.buf_pos.offset) >= re_ctx_p->input_end_p)
{
JERRY_DDLOG ("fail\n");
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
ch1 = lit_utf8_iterator_read_next (&sub_iter);
ch2 = lit_utf8_iterator_read_next (&iter);
if (ch1 != ch2)
{
JERRY_DDLOG ("fail\n");
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
}
JERRY_DDLOG ("match\n");
break; /* tail merge */
}
case RE_OP_SAVE_AT_START:
{
re_bytecode_t *old_bc_p;
JERRY_DDLOG ("Execute RE_OP_SAVE_AT_START\n");
lit_utf8_iterator_t old_start_p = re_ctx_p->saved_p[RE_GLOBAL_START_IDX];
re_ctx_p->saved_p[RE_GLOBAL_START_IDX] = iter;
do
{
uint32_t offset = re_get_value (&bc_p);
lit_utf8_iterator_t sub_iter = lit_utf8_iterator_create (NULL, 0);
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
if (ecma_is_value_true (match_value))
{
*out_iter_p = sub_iter;
return match_value; /* match */
}
else if (ecma_is_completion_value_throw (match_value))
{
return match_value;
}
bc_p += offset;
old_bc_p = bc_p;
}
while (re_get_opcode (&bc_p) == RE_OP_ALTERNATIVE);
bc_p = old_bc_p;
re_ctx_p->saved_p[RE_GLOBAL_START_IDX] = old_start_p;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
case RE_OP_SAVE_AND_MATCH:
{
JERRY_DDLOG ("End of pattern is reached: match\n");
re_ctx_p->saved_p[RE_GLOBAL_END_IDX] = iter;
*out_iter_p = iter;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE); /* match */
}
case RE_OP_ALTERNATIVE:
{
/*
* Alternatives should be jump over, when alternative opcode appears.
*/
uint32_t offset = re_get_value (&bc_p);
JERRY_DDLOG ("Execute RE_OP_ALTERNATIVE");
bc_p += offset;
while (*bc_p == RE_OP_ALTERNATIVE)
{
JERRY_DDLOG (", jump: %d");
bc_p++;
offset = re_get_value (&bc_p);
bc_p += offset;
}
JERRY_DDLOG ("\n");
break; /* tail merge */
}
case RE_OP_CAPTURE_NON_GREEDY_ZERO_GROUP_START:
case RE_OP_NON_CAPTURE_NON_GREEDY_ZERO_GROUP_START:
{
/*
* On non-greedy iterations we have to execute the bytecode
* after the group first, if zero iteration is allowed.
*/
uint32_t start_idx, iter_idx, offset;
lit_utf8_iterator_t old_start = lit_utf8_iterator_create (NULL, 0);
lit_utf8_iterator_t sub_iter = lit_utf8_iterator_create (NULL, 0);
re_bytecode_t *old_bc_p;
old_bc_p = bc_p; /* save the bytecode start position of the group start */
start_idx = re_get_value (&bc_p);
offset = re_get_value (&bc_p);
if (RE_IS_CAPTURE_GROUP (op))
{
JERRY_ASSERT (start_idx <= re_ctx_p->num_of_captures / 2);
iter_idx = start_idx - 1;
start_idx *= 2;
old_start = re_ctx_p->saved_p[start_idx];
re_ctx_p->saved_p[start_idx] = iter;
}
else
{
JERRY_ASSERT (start_idx < re_ctx_p->num_of_non_captures);
iter_idx = start_idx + (re_ctx_p->num_of_captures / 2) - 1;
start_idx += re_ctx_p->num_of_captures;
}
re_ctx_p->num_of_iterations_p[iter_idx] = 0;
/* Jump all over to the end of the END opcode. */
bc_p += offset;
/* Try to match after the close paren if zero is allowed */
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
if (ecma_is_value_true (match_value))
{
*out_iter_p = sub_iter;
return match_value; /* match */
}
else if (ecma_is_completion_value_throw (match_value))
{
return match_value;
}
if (RE_IS_CAPTURE_GROUP (op))
{
re_ctx_p->saved_p[start_idx] = old_start;
}
bc_p = old_bc_p;
/* FALLTHRU */
}
case RE_OP_CAPTURE_GROUP_START:
case RE_OP_CAPTURE_GREEDY_ZERO_GROUP_START:
case RE_OP_NON_CAPTURE_GROUP_START:
case RE_OP_NON_CAPTURE_GREEDY_ZERO_GROUP_START:
{
uint32_t start_idx, iter_idx, old_iteration_cnt, offset;
lit_utf8_iterator_t sub_iter = lit_utf8_iterator_create (NULL, 0);
re_bytecode_t *old_bc_p;
re_bytecode_t *end_bc_p = NULL;
start_idx = re_get_value (&bc_p);
if (op != RE_OP_CAPTURE_GROUP_START
&& op != RE_OP_NON_CAPTURE_GROUP_START)
{
offset = re_get_value (&bc_p);
end_bc_p = bc_p + offset;
}
if (RE_IS_CAPTURE_GROUP (op))
{
JERRY_ASSERT (start_idx <= re_ctx_p->num_of_captures / 2);
iter_idx = start_idx - 1;
start_idx *= 2;
}
else
{
JERRY_ASSERT (start_idx < re_ctx_p->num_of_non_captures);
iter_idx = start_idx + (re_ctx_p->num_of_captures / 2) - 1;
start_idx += re_ctx_p->num_of_captures;
}
lit_utf8_iterator_t old_start = re_ctx_p->saved_p[start_idx];
old_iteration_cnt = re_ctx_p->num_of_iterations_p[iter_idx];
re_ctx_p->saved_p[start_idx] = iter;
re_ctx_p->num_of_iterations_p[iter_idx] = 0;
do
{
offset = re_get_value (&bc_p);
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
if (ecma_is_value_true (match_value))
{
*out_iter_p = sub_iter;
return match_value; /* match */
}
else if (ecma_is_completion_value_throw (match_value))
{
return match_value;
}
bc_p += offset;
old_bc_p = bc_p;
}
while (re_get_opcode (&bc_p) == RE_OP_ALTERNATIVE);
bc_p = old_bc_p;
re_ctx_p->num_of_iterations_p[iter_idx] = old_iteration_cnt;
/* Try to match after the close paren if zero is allowed. */
if (op == RE_OP_CAPTURE_GREEDY_ZERO_GROUP_START
|| op == RE_OP_NON_CAPTURE_GREEDY_ZERO_GROUP_START)
{
JERRY_ASSERT (end_bc_p);
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, end_bc_p, iter, &sub_iter);
if (ecma_is_value_true (match_value))
{
*out_iter_p = sub_iter;
return match_value; /* match */
}
else if (ecma_is_completion_value_throw (match_value))
{
return match_value;
}
}
re_ctx_p->saved_p[start_idx] = old_start;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
case RE_OP_CAPTURE_NON_GREEDY_GROUP_END:
case RE_OP_NON_CAPTURE_NON_GREEDY_GROUP_END:
{
uint32_t end_idx, iter_idx, min, max;
re_bytecode_t *old_bc_p;
/*
* On non-greedy iterations we have to execute the bytecode
* after the group first. Try to iterate only if it fails.
*/
old_bc_p = bc_p; /* save the bytecode start position of the group end */
end_idx = re_get_value (&bc_p);
min = re_get_value (&bc_p);
max = re_get_value (&bc_p);
re_get_value (&bc_p); /* start offset */
if (RE_IS_CAPTURE_GROUP (op))
{
JERRY_ASSERT (end_idx <= re_ctx_p->num_of_captures / 2);
iter_idx = end_idx - 1;
end_idx = (end_idx * 2) + 1;
}
else
{
JERRY_ASSERT (end_idx <= re_ctx_p->num_of_non_captures);
iter_idx = end_idx + (re_ctx_p->num_of_captures / 2) - 1;
end_idx += re_ctx_p->num_of_captures;
}
re_ctx_p->num_of_iterations_p[iter_idx]++;
if (re_ctx_p->num_of_iterations_p[iter_idx] >= min
&& re_ctx_p->num_of_iterations_p[iter_idx] <= max)
{
lit_utf8_iterator_t old_end = re_ctx_p->saved_p[end_idx];
re_ctx_p->saved_p[end_idx] = iter;
lit_utf8_iterator_t sub_iter = lit_utf8_iterator_create (NULL, 0);
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
if (ecma_is_value_true (match_value))
{
*out_iter_p = sub_iter;
return match_value; /* match */
}
else if (ecma_is_completion_value_throw (match_value))
{
return match_value;
}
re_ctx_p->saved_p[end_idx] = old_end;
}
re_ctx_p->num_of_iterations_p[iter_idx]--;
bc_p = old_bc_p;
/* If non-greedy fails and try to iterate... */
/* FALLTHRU */
}
case RE_OP_CAPTURE_GREEDY_GROUP_END:
case RE_OP_NON_CAPTURE_GREEDY_GROUP_END:
{
uint32_t start_idx, end_idx, iter_idx, min, max, offset;
lit_utf8_iterator_t old_start = lit_utf8_iterator_create (NULL, 0);
lit_utf8_iterator_t old_end = lit_utf8_iterator_create (NULL, 0);
lit_utf8_iterator_t sub_iter = lit_utf8_iterator_create (NULL, 0);
re_bytecode_t *old_bc_p;
end_idx = re_get_value (&bc_p);
min = re_get_value (&bc_p);
max = re_get_value (&bc_p);
offset = re_get_value (&bc_p);
if (RE_IS_CAPTURE_GROUP (op))
{
JERRY_ASSERT (end_idx <= re_ctx_p->num_of_captures / 2);
iter_idx = end_idx - 1;
start_idx = end_idx * 2;
end_idx = start_idx + 1;
}
else
{
JERRY_ASSERT (end_idx <= re_ctx_p->num_of_non_captures);
iter_idx = end_idx + (re_ctx_p->num_of_captures / 2) - 1;
end_idx += re_ctx_p->num_of_captures;
start_idx = end_idx;
}
/* Check the empty iteration if the minimum number of iterations is reached. */
if (re_ctx_p->num_of_iterations_p[iter_idx] >= min
&& iter.buf_p == re_ctx_p->saved_p[start_idx].buf_p
&& iter.buf_pos.offset == re_ctx_p->saved_p[start_idx].buf_pos.offset)
{
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
re_ctx_p->num_of_iterations_p[iter_idx]++;
old_bc_p = bc_p; /* Save the bytecode end position of the END opcodes for matching after it. */
old_end = re_ctx_p->saved_p[end_idx];
re_ctx_p->saved_p[end_idx] = iter;
if (re_ctx_p->num_of_iterations_p[iter_idx] < max)
{
bc_p -= offset;
offset = re_get_value (&bc_p);
old_start = re_ctx_p->saved_p[start_idx];
re_ctx_p->saved_p[start_idx] = iter;
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
if (ecma_is_value_true (match_value))
{
*out_iter_p = sub_iter;
return match_value; /* match */
}
else if (ecma_is_completion_value_throw (match_value))
{
return match_value;
}
re_ctx_p->saved_p[start_idx] = old_start;
/* Try to match alternatives if any. */
bc_p += offset;
while (*bc_p == RE_OP_ALTERNATIVE)
{
bc_p++; /* RE_OP_ALTERNATIVE */
offset = re_get_value (&bc_p);
old_start = re_ctx_p->saved_p[start_idx];
re_ctx_p->saved_p[start_idx] = iter;
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
if (ecma_is_value_true (match_value))
{
*out_iter_p = sub_iter;
return match_value; /* match */
}
else if (ecma_is_completion_value_throw (match_value))
{
return match_value;
}
re_ctx_p->saved_p[start_idx] = old_start;
bc_p += offset;
}
}
if (re_ctx_p->num_of_iterations_p[iter_idx] >= min
&& re_ctx_p->num_of_iterations_p[iter_idx] <= max)
{
/* Try to match the rest of the bytecode. */
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, old_bc_p, iter, &sub_iter);
if (ecma_is_value_true (match_value))
{
*out_iter_p = sub_iter;
return match_value; /* match */
}
else if (ecma_is_completion_value_throw (match_value))
{
return match_value;
}
}
/* restore if fails */
re_ctx_p->saved_p[end_idx] = old_end;
re_ctx_p->num_of_iterations_p[iter_idx]--;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
case RE_OP_NON_GREEDY_ITERATOR:
{
uint32_t min, max, offset, num_of_iter;
lit_utf8_iterator_t sub_iter = lit_utf8_iterator_create (NULL, 0);
min = re_get_value (&bc_p);
max = re_get_value (&bc_p);
offset = re_get_value (&bc_p);
JERRY_DDLOG ("Non-greedy iterator, min=%lu, max=%lu, offset=%ld\n",
(unsigned long) min, (unsigned long) max, (long) offset);
num_of_iter = 0;
while (num_of_iter <= max)
{
if (num_of_iter >= min)
{
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p + offset, iter, &sub_iter);
if (ecma_is_value_true (match_value))
{
*out_iter_p = sub_iter;
return match_value; /* match */
}
else if (ecma_is_completion_value_throw (match_value))
{
return match_value;
}
}
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
if (!ecma_is_value_true (match_value))
{
if (ecma_is_completion_value_throw (match_value))
{
return match_value;
}
break;
}
iter = sub_iter;
num_of_iter++;
}
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
case RE_OP_GREEDY_ITERATOR:
{
uint32_t min, max, offset, num_of_iter;
lit_utf8_iterator_t sub_iter = lit_utf8_iterator_create (NULL, 0);
min = re_get_value (&bc_p);
max = re_get_value (&bc_p);
offset = re_get_value (&bc_p);
JERRY_DDLOG ("Greedy iterator, min=%lu, max=%lu, offset=%ld\n",
(unsigned long) min, (unsigned long) max, (long) offset);
num_of_iter = 0;
while (num_of_iter < max)
{
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p, iter, &sub_iter);
if (!ecma_is_value_true (match_value))
{
if (ecma_is_completion_value_throw (match_value))
{
return match_value;
}
break;
}
iter = sub_iter;
num_of_iter++;
}
while (num_of_iter >= min)
{
ecma_completion_value_t match_value = re_match_regexp (re_ctx_p, bc_p + offset, iter, &sub_iter);
if (ecma_is_value_true (match_value))
{
*out_iter_p = sub_iter;
return match_value; /* match */
}
else if (ecma_is_completion_value_throw (match_value))
{
return match_value;
}
if (num_of_iter == min)
{
break;
}
lit_utf8_iterator_read_prev (&iter);
num_of_iter--;
}
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
}
default:
{
JERRY_DDLOG ("UNKNOWN opcode (%d)!\n", (uint32_t) op);
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_COMMON));
}
}
}
JERRY_UNREACHABLE ();
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE); /* fail */
} /* regexp_match */
/**
* Parse alternatives
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
static ecma_completion_value_t
re_parse_alternative (re_compiler_ctx_t *re_ctx_p, /**< RegExp compiler context */
bool expect_eof) /**< expect end of file */
{
uint32_t idx;
re_bytecode_ctx_t *bc_ctx_p = re_ctx_p->bytecode_ctx_p;
ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
uint32_t alterantive_offset = re_get_bytecode_length (re_ctx_p->bytecode_ctx_p);
while (true)
{
ECMA_TRY_CATCH (empty,
re_parse_next_token (re_ctx_p->parser_ctx_p,
&(re_ctx_p->current_token)),
ret_value);
ECMA_FINALIZE (empty);
if (!ecma_is_completion_value_empty (ret_value))
{
return ret_value; /* error */
}
uint32_t new_atom_start_offset = re_get_bytecode_length (re_ctx_p->bytecode_ctx_p);
switch (re_ctx_p->current_token.type)
{
case RE_TOK_START_CAPTURE_GROUP:
{
idx = re_ctx_p->num_of_captures++;
JERRY_DDLOG ("Compile a capture group start (idx: %d)\n", idx);
ret_value = re_parse_alternative (re_ctx_p, false);
if (ecma_is_completion_value_empty (ret_value))
{
re_insert_into_group (re_ctx_p, new_atom_start_offset, idx, true);
}
else
{
return ret_value; /* error */
}
break;
}
case RE_TOK_START_NON_CAPTURE_GROUP:
{
idx = re_ctx_p->num_of_non_captures++;
JERRY_DDLOG ("Compile a non-capture group start (idx: %d)\n", idx);
ret_value = re_parse_alternative (re_ctx_p, false);
if (ecma_is_completion_value_empty (ret_value))
{
re_insert_into_group (re_ctx_p, new_atom_start_offset, idx, false);
}
else
{
return ret_value; /* error */
}
break;
}
case RE_TOK_CHAR:
{
JERRY_DDLOG ("Compile character token: %c, qmin: %d, qmax: %d\n",
re_ctx_p->current_token.value, re_ctx_p->current_token.qmin, re_ctx_p->current_token.qmax);
re_append_opcode (bc_ctx_p, RE_OP_CHAR);
re_append_u32 (bc_ctx_p, re_canonicalize ((ecma_char_t) re_ctx_p->current_token.value,
re_ctx_p->flags & RE_FLAG_IGNORE_CASE));
if ((re_ctx_p->current_token.qmin != 1) || (re_ctx_p->current_token.qmax != 1))
{
re_insert_simple_iterator (re_ctx_p, new_atom_start_offset);
}
break;
}
case RE_TOK_PERIOD:
{
JERRY_DDLOG ("Compile a period\n");
re_append_opcode (bc_ctx_p, RE_OP_PERIOD);
if ((re_ctx_p->current_token.qmin != 1) || (re_ctx_p->current_token.qmax != 1))
{
re_insert_simple_iterator (re_ctx_p, new_atom_start_offset);
}
break;
}
case RE_TOK_ALTERNATIVE:
{
JERRY_DDLOG ("Compile an alternative\n");
re_insert_u32 (bc_ctx_p, alterantive_offset, re_get_bytecode_length (bc_ctx_p) - alterantive_offset);
re_append_opcode (bc_ctx_p, RE_OP_ALTERNATIVE);
alterantive_offset = re_get_bytecode_length (re_ctx_p->bytecode_ctx_p);
break;
}
case RE_TOK_ASSERT_START:
{
JERRY_DDLOG ("Compile a start assertion\n");
re_append_opcode (bc_ctx_p, RE_OP_ASSERT_START);
break;
}
case RE_TOK_ASSERT_END:
{
JERRY_DDLOG ("Compile an end assertion\n");
re_append_opcode (bc_ctx_p, RE_OP_ASSERT_END);
break;
}
case RE_TOK_ASSERT_WORD_BOUNDARY:
{
JERRY_DDLOG ("Compile a word boundary assertion\n");
re_append_opcode (bc_ctx_p, RE_OP_ASSERT_WORD_BOUNDARY);
break;
}
case RE_TOK_ASSERT_NOT_WORD_BOUNDARY:
{
JERRY_DDLOG ("Compile a not word boundary assertion\n");
re_append_opcode (bc_ctx_p, RE_OP_ASSERT_NOT_WORD_BOUNDARY);
break;
}
case RE_TOK_ASSERT_START_POS_LOOKAHEAD:
{
JERRY_DDLOG ("Compile a positive lookahead assertion\n");
idx = re_ctx_p->num_of_non_captures++;
re_append_opcode (bc_ctx_p, RE_OP_LOOKAHEAD_POS);
ret_value = re_parse_alternative (re_ctx_p, false);
if (ecma_is_completion_value_empty (ret_value))
{
re_append_opcode (bc_ctx_p, RE_OP_MATCH);
re_insert_into_group_with_jump (re_ctx_p, new_atom_start_offset, idx, false);
}
else
{
return ret_value; /* error */
}
break;
}
case RE_TOK_ASSERT_START_NEG_LOOKAHEAD:
{
JERRY_DDLOG ("Compile a negative lookahead assertion\n");
idx = re_ctx_p->num_of_non_captures++;
re_append_opcode (bc_ctx_p, RE_OP_LOOKAHEAD_NEG);
ret_value = re_parse_alternative (re_ctx_p, false);
if (ecma_is_completion_value_empty (ret_value))
{
re_append_opcode (bc_ctx_p, RE_OP_MATCH);
re_insert_into_group_with_jump (re_ctx_p, new_atom_start_offset, idx, false);
}
else
{
return ret_value; /* error */
}
break;
}
case RE_TOK_BACKREFERENCE:
{
uint32_t backref = (uint32_t) re_ctx_p->current_token.value;
idx = re_ctx_p->num_of_non_captures++;
if (backref > re_ctx_p->highest_backref)
{
re_ctx_p->highest_backref = backref;
}
JERRY_DDLOG ("Compile a backreference: %d\n", backref);
re_append_opcode (bc_ctx_p, RE_OP_BACKREFERENCE);
re_append_u32 (bc_ctx_p, backref);
re_insert_into_group_with_jump (re_ctx_p, new_atom_start_offset, idx, false);
break;
}
case RE_TOK_DIGIT:
case RE_TOK_NOT_DIGIT:
case RE_TOK_WHITE:
case RE_TOK_NOT_WHITE:
case RE_TOK_WORD_CHAR:
case RE_TOK_NOT_WORD_CHAR:
case RE_TOK_START_CHAR_CLASS:
case RE_TOK_START_INV_CHAR_CLASS:
{
JERRY_DDLOG ("Compile a character class\n");
re_append_opcode (bc_ctx_p,
re_ctx_p->current_token.type == RE_TOK_START_INV_CHAR_CLASS
? RE_OP_INV_CHAR_CLASS
: RE_OP_CHAR_CLASS);
uint32_t offset = re_get_bytecode_length (re_ctx_p->bytecode_ctx_p);
ECMA_TRY_CATCH (empty,
re_parse_char_class (re_ctx_p->parser_ctx_p,
re_append_char_class,
re_ctx_p,
&(re_ctx_p->current_token)),
ret_value);
re_insert_u32 (bc_ctx_p, offset, re_ctx_p->parser_ctx_p->num_of_classes);
if ((re_ctx_p->current_token.qmin != 1) || (re_ctx_p->current_token.qmax != 1))
{
re_insert_simple_iterator (re_ctx_p, new_atom_start_offset);
}
ECMA_FINALIZE (empty);
if (ecma_is_completion_value_throw (ret_value))
{
return ret_value; /* error */
}
break;
}
case RE_TOK_END_GROUP:
{
JERRY_DDLOG ("Compile a group end\n");
if (expect_eof)
{
ret_value = ecma_raise_syntax_error ("Unexpected end of paren.");
}
else
{
re_insert_u32 (bc_ctx_p, alterantive_offset, re_get_bytecode_length (bc_ctx_p) - alterantive_offset);
}
return ret_value;
}
case RE_TOK_EOF:
{
if (!expect_eof)
{
ret_value = ecma_raise_syntax_error ("Unexpected end of pattern.");
}
else
{
re_insert_u32 (bc_ctx_p, alterantive_offset, re_get_bytecode_length (bc_ctx_p) - alterantive_offset);
}
return ret_value;
}
default:
{
ret_value = ecma_raise_syntax_error ("Unexpected RegExp token.");
return ret_value;
}
}
}
JERRY_UNREACHABLE ();
return ret_value;
} /* re_parse_alternative */
/**
* [[DefineOwnProperty]] ecma array object's operation
*
* See also:
* ECMA-262 v5, 8.6.2; ECMA-262 v5, Table 8
* ECMA-262 v5, 15.4.5.1
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
ecma_op_array_object_define_own_property (ecma_object_t *obj_p, /**< the array object */
ecma_string_t *property_name_p, /**< property name */
const ecma_property_descriptor_t* property_desc_p, /**< property descriptor */
bool is_throw) /**< flag that controls failure handling */
{
JERRY_ASSERT (ecma_get_object_type (obj_p) == ECMA_OBJECT_TYPE_ARRAY);
// 1.
ecma_string_t* magic_string_length_p = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
ecma_property_t *len_prop_p = ecma_op_object_get_own_property (obj_p, magic_string_length_p);
JERRY_ASSERT (len_prop_p != NULL && len_prop_p->type == ECMA_PROPERTY_NAMEDDATA);
// 2.
ecma_value_t old_len_value = ecma_get_named_data_property_value (len_prop_p);
ecma_number_t *num_p = ecma_get_number_from_value (old_len_value);
uint32_t old_len_uint32 = ecma_number_to_uint32 (*num_p);
// 3.
bool is_property_name_equal_length = ecma_compare_ecma_strings (property_name_p,
magic_string_length_p);
ecma_deref_ecma_string (magic_string_length_p);
if (is_property_name_equal_length)
{
// a.
if (!property_desc_p->is_value_defined)
{
// i.
return ecma_op_general_object_define_own_property (obj_p, property_name_p, property_desc_p, is_throw);
}
ecma_number_t new_len_num;
// c.
ecma_completion_value_t completion = ecma_op_to_number (property_desc_p->value);
if (ecma_is_completion_value_throw (completion))
{
return completion;
}
JERRY_ASSERT (ecma_is_completion_value_normal (completion)
&& ecma_is_value_number (ecma_get_completion_value_value (completion)));
new_len_num = *ecma_get_number_from_completion_value (completion);
ecma_free_completion_value (completion);
uint32_t new_len_uint32 = ecma_number_to_uint32 (new_len_num);
// d.
if (ecma_uint32_to_number (new_len_uint32) != new_len_num)
{
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_RANGE));
}
else
{
// b., e.
ecma_number_t *new_len_num_p = ecma_alloc_number ();
*new_len_num_p = new_len_num;
ecma_property_descriptor_t new_len_property_desc = *property_desc_p;
new_len_property_desc.value = ecma_make_number_value (new_len_num_p);
ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
// f.
if (new_len_uint32 >= old_len_uint32)
{
// i.
magic_string_length_p = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
ret_value = ecma_op_general_object_define_own_property (obj_p,
magic_string_length_p,
&new_len_property_desc,
is_throw);
ecma_deref_ecma_string (magic_string_length_p);
}
else
{
// g.
if (!ecma_is_property_writable (len_prop_p))
{
ret_value = ecma_reject (is_throw);
}
else
{
// h.
bool new_writable;
if (!new_len_property_desc.is_writable_defined
|| new_len_property_desc.is_writable)
{
new_writable = true;
}
else
{
// ii.
new_writable = false;
// iii.
new_len_property_desc.is_writable_defined = true;
new_len_property_desc.is_writable = true;
}
// j.
magic_string_length_p = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
ecma_completion_value_t succeeded = ecma_op_general_object_define_own_property (obj_p,
magic_string_length_p,
&new_len_property_desc,
is_throw);
ecma_deref_ecma_string (magic_string_length_p);
/* Handling normal false and throw values */
if (!ecma_is_completion_value_normal_true (succeeded))
{
JERRY_ASSERT (ecma_is_completion_value_normal_false (succeeded)
|| ecma_is_completion_value_throw (succeeded));
// k.
ret_value = succeeded;
}
else
{
// l
JERRY_ASSERT (new_len_uint32 < old_len_uint32);
bool reduce_succeeded = true;
while (new_len_uint32 < old_len_uint32)
{
// i
old_len_uint32--;
// ii
ecma_string_t *old_length_string_p = ecma_new_ecma_string_from_uint32 (old_len_uint32);
ecma_completion_value_t delete_succeeded = ecma_op_object_delete (obj_p,
old_length_string_p,
false);
ecma_deref_ecma_string (old_length_string_p);
// iii
if (ecma_is_completion_value_normal_false (delete_succeeded))
{
JERRY_ASSERT (ecma_is_value_number (new_len_property_desc.value));
ecma_number_t *new_len_num_p = ecma_get_number_from_value (new_len_property_desc.value);
// 1.
*new_len_num_p = ecma_uint32_to_number (old_len_uint32 + 1);
// 2.
if (!new_writable)
{
new_len_property_desc.is_writable_defined = true;
new_len_property_desc.is_writable = false;
}
// 3.
ecma_string_t *magic_string_length_p = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
ecma_completion_value_t completion = ecma_op_general_object_define_own_property (obj_p,
magic_string_length_p,
&new_len_property_desc,
false);
ecma_deref_ecma_string (magic_string_length_p);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion)
|| ecma_is_completion_value_normal_false (completion));
reduce_succeeded = false;
break;
}
}
if (!reduce_succeeded)
{
ret_value = ecma_reject (is_throw);
}
else
{
// m.
if (!new_writable)
{
ecma_property_descriptor_t prop_desc_not_writable = ecma_make_empty_property_descriptor ();
prop_desc_not_writable.is_writable_defined = true;
prop_desc_not_writable.is_writable = false;
ecma_completion_value_t completion_set_not_writable;
magic_string_length_p = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
completion_set_not_writable = ecma_op_general_object_define_own_property (obj_p,
magic_string_length_p,
&prop_desc_not_writable,
false);
ecma_deref_ecma_string (magic_string_length_p);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion_set_not_writable));
}
ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
}
}
}
ecma_dealloc_number (new_len_num_p);
return ret_value;
}
JERRY_UNREACHABLE ();
}
else
{
// 4.a.
uint32_t index;
if (!ecma_string_get_array_index (property_name_p, &index))
{
// 5.
return ecma_op_general_object_define_own_property (obj_p,
property_name_p,
property_desc_p,
is_throw);
}
// 4.
// b.
if (index >= old_len_uint32
&& !ecma_is_property_writable (len_prop_p))
{
return ecma_reject (is_throw);
}
// c.
ecma_completion_value_t succeeded = ecma_op_general_object_define_own_property (obj_p,
property_name_p,
property_desc_p,
false);
// d.
JERRY_ASSERT (ecma_is_completion_value_normal_true (succeeded)
|| ecma_is_completion_value_normal_false (succeeded));
if (ecma_is_completion_value_normal_false (succeeded))
{
return ecma_reject (is_throw);
}
// e.
if (index >= old_len_uint32)
{
// i., ii.
ecma_number_t *num_p = ecma_alloc_number ();
*num_p = ecma_number_add (ecma_uint32_to_number (index), ECMA_NUMBER_ONE);
ecma_named_data_property_assign_value (obj_p, len_prop_p, ecma_make_number_value (num_p));
ecma_dealloc_number (num_p);
}
// f.
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
JERRY_UNREACHABLE ();
} /* ecma_op_array_object_define_own_property */
/**
* Setup variables for arguments listed in formal parameter list,
* and, if necessary, Arguments object with 'arguments' binding.
*
* See also:
* Declaration binding instantiation (ECMA-262 v5, 10.5), block 4 and 7
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
static ecma_completion_value_t
ecma_function_call_setup_args_variables (ecma_object_t *func_obj_p, /**< Function object */
ecma_object_t *env_p, /**< lexical environment */
const ecma_value_t *arguments_list_p, /**< arguments list */
ecma_length_t arguments_list_len, /**< length of argument list */
bool is_strict, /**< flag indicating strict mode */
bool do_instantiate_arguments_object) /**< flag indicating whether
* Arguments object should be
* instantiated */
{
ecma_property_t *formal_parameters_prop_p = ecma_get_internal_property (func_obj_p,
ECMA_INTERNAL_PROPERTY_FORMAL_PARAMETERS);
ecma_collection_header_t *formal_parameters_p;
formal_parameters_p = ECMA_GET_POINTER (ecma_collection_header_t,
formal_parameters_prop_p->u.internal_property.value);
if (formal_parameters_p != NULL)
{
ecma_length_t formal_parameters_count = formal_parameters_p->unit_number;
ecma_collection_iterator_t formal_params_iterator;
ecma_collection_iterator_init (&formal_params_iterator, formal_parameters_p);
/*
* Formal parameter list is stored in reversed order
*
* Although, specification defines ascending order of formal parameters list enumeration,
* implementation enumerates the parameters in descending order.
*
* In the case, redundant SetMutableBinding invocation could be avoided.
*/
for (ssize_t n = (ssize_t) formal_parameters_count - 1;
n >= 0;
n--)
{
ecma_value_t v;
if (n >= (ssize_t) arguments_list_len)
{
v = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
}
else
{
v = arguments_list_p[n];
}
bool is_moved = ecma_collection_iterator_next (&formal_params_iterator);
JERRY_ASSERT (is_moved);
ecma_value_t formal_parameter_name_value = *formal_params_iterator.current_value_p;
ecma_string_t *formal_parameter_name_string_p = ecma_get_string_from_value (formal_parameter_name_value);
bool arg_already_declared = ecma_op_has_binding (env_p, formal_parameter_name_string_p);
if (!arg_already_declared)
{
ecma_completion_value_t completion = ecma_op_create_mutable_binding (env_p,
formal_parameter_name_string_p,
false);
if (ecma_is_completion_value_throw (completion))
{
return completion;
}
JERRY_ASSERT (ecma_is_completion_value_empty (completion));
completion = ecma_op_set_mutable_binding (env_p,
formal_parameter_name_string_p,
v,
is_strict);
if (ecma_is_completion_value_throw (completion))
{
return completion;
}
JERRY_ASSERT (ecma_is_completion_value_empty (completion));
}
}
}
if (do_instantiate_arguments_object)
{
/*
* According to ECMA-262 v5, 10.5, the Arguments object should be instantiated
* after instantiating declared functions, and only if there is no binding named 'arguments'
* by that time.
*
* However, we can setup Arguments object and 'arguments' binding here, because:
* - instantiation of Arguments object itself doesn't have any side effects;
* - if 'arguments' is name of a declared function in current scope,
* value of the binding would be overwritten, execution would proceed in correct state.
* - declaration of function, named 'arguments', is considered to be unrecommended (and so, rare) case,
* so instantiation of Arguments object here, in general, is supposed to not affect resource consumption
* significantly.
*/
ecma_string_t *arguments_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_ARGUMENTS);
bool binding_already_declared = ecma_op_has_binding (env_p, arguments_string_p);
if (!binding_already_declared)
{
ecma_object_t *args_obj_p = ecma_op_create_arguments_object (func_obj_p,
env_p,
formal_parameters_p,
arguments_list_p,
arguments_list_len,
is_strict);
if (is_strict)
{
ecma_op_create_immutable_binding (env_p, arguments_string_p);
ecma_op_initialize_immutable_binding (env_p, arguments_string_p, ecma_make_object_value (args_obj_p));
}
else
{
ecma_completion_value_t completion = ecma_op_create_mutable_binding (env_p,
arguments_string_p,
false);
JERRY_ASSERT (ecma_is_completion_value_empty (completion));
completion = ecma_op_set_mutable_binding (env_p,
arguments_string_p,
ecma_make_object_value (args_obj_p),
false);
JERRY_ASSERT (ecma_is_completion_value_empty (completion));
}
ecma_deref_object (args_obj_p);
}
ecma_deref_ecma_string (arguments_string_p);
}
return ecma_make_empty_completion_value ();
} /* ecma_function_call_setup_args_variables */
/**
* ToPropertyDescriptor operation.
*
* See also:
* ECMA-262 v5, 8.10.5
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
ecma_op_to_property_descriptor (ecma_value_t obj_value, /**< object value */
ecma_property_descriptor_t *out_prop_desc_p) /**< out: filled property descriptor
if return value is normal
empty completion value */
{
ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
// 1.
if (!ecma_is_value_object (obj_value))
{
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
ecma_object_t *obj_p = ecma_get_object_from_value (obj_value);
// 2.
ecma_property_descriptor_t prop_desc = ecma_make_empty_property_descriptor ();
// 3.
ecma_string_t *enumerable_magic_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_ENUMERABLE);
if (ecma_op_object_get_property (obj_p, enumerable_magic_string_p) != NULL)
{
ECMA_TRY_CATCH (enumerable_prop_value,
ecma_op_object_get (obj_p, enumerable_magic_string_p),
ret_value);
ECMA_TRY_CATCH (boolean_enumerable_prop_value,
ecma_op_to_boolean (enumerable_prop_value),
ret_value);
prop_desc.is_enumerable_defined = true;
if (ecma_is_value_true (boolean_enumerable_prop_value))
{
prop_desc.is_enumerable = true;
}
else
{
JERRY_ASSERT (ecma_is_value_boolean (boolean_enumerable_prop_value));
prop_desc.is_enumerable = false;
}
ECMA_FINALIZE (boolean_enumerable_prop_value);
ECMA_FINALIZE (enumerable_prop_value);
}
ecma_deref_ecma_string (enumerable_magic_string_p);
if (!ecma_is_completion_value_throw (ret_value))
{
JERRY_ASSERT (ecma_is_completion_value_empty (ret_value));
// 4.
ecma_string_t *configurable_magic_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_CONFIGURABLE);
if (ecma_op_object_get_property (obj_p, configurable_magic_string_p) != NULL)
{
ECMA_TRY_CATCH (configurable_prop_value,
ecma_op_object_get (obj_p, configurable_magic_string_p),
ret_value);
ECMA_TRY_CATCH (boolean_configurable_prop_value,
ecma_op_to_boolean (configurable_prop_value),
ret_value);
prop_desc.is_configurable_defined = true;
if (ecma_is_value_true (boolean_configurable_prop_value))
{
prop_desc.is_configurable = true;
}
else
{
JERRY_ASSERT (ecma_is_value_boolean (boolean_configurable_prop_value));
prop_desc.is_configurable = false;
}
ECMA_FINALIZE (boolean_configurable_prop_value);
ECMA_FINALIZE (configurable_prop_value);
}
ecma_deref_ecma_string (configurable_magic_string_p);
}
if (!ecma_is_completion_value_throw (ret_value))
{
JERRY_ASSERT (ecma_is_completion_value_empty (ret_value));
// 5.
ecma_string_t *value_magic_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_VALUE);
if (ecma_op_object_get_property (obj_p, value_magic_string_p) != NULL)
{
ECMA_TRY_CATCH (value_prop_value,
ecma_op_object_get (obj_p, value_magic_string_p),
ret_value);
prop_desc.is_value_defined = true;
prop_desc.value = ecma_copy_value (value_prop_value, true);
ECMA_FINALIZE (value_prop_value);
}
ecma_deref_ecma_string (value_magic_string_p);
}
if (!ecma_is_completion_value_throw (ret_value))
{
JERRY_ASSERT (ecma_is_completion_value_empty (ret_value));
// 6.
ecma_string_t *writable_magic_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_WRITABLE);
if (ecma_op_object_get_property (obj_p, writable_magic_string_p) != NULL)
{
ECMA_TRY_CATCH (writable_prop_value,
ecma_op_object_get (obj_p, writable_magic_string_p),
ret_value);
ECMA_TRY_CATCH (boolean_writable_prop_value,
ecma_op_to_boolean (writable_prop_value),
ret_value);
prop_desc.is_writable_defined = true;
if (ecma_is_value_true (boolean_writable_prop_value))
{
prop_desc.is_writable = true;
}
else
{
JERRY_ASSERT (ecma_is_value_boolean (boolean_writable_prop_value));
prop_desc.is_writable = false;
}
ECMA_FINALIZE (boolean_writable_prop_value);
ECMA_FINALIZE (writable_prop_value);
}
ecma_deref_ecma_string (writable_magic_string_p);
}
if (!ecma_is_completion_value_throw (ret_value))
{
JERRY_ASSERT (ecma_is_completion_value_empty (ret_value));
// 7.
ecma_string_t *get_magic_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_GET);
if (ecma_op_object_get_property (obj_p, get_magic_string_p) != NULL)
{
ECMA_TRY_CATCH (get_prop_value,
ecma_op_object_get (obj_p, get_magic_string_p),
ret_value);
if (!ecma_op_is_callable (get_prop_value)
&& !ecma_is_value_undefined (get_prop_value))
{
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
prop_desc.is_get_defined = true;
if (ecma_is_value_undefined (get_prop_value))
{
prop_desc.get_p = NULL;
}
else
{
JERRY_ASSERT (ecma_is_value_object (get_prop_value));
ecma_object_t *get_p = ecma_get_object_from_value (get_prop_value);
ecma_ref_object (get_p);
prop_desc.get_p = get_p;
}
}
ECMA_FINALIZE (get_prop_value);
}
ecma_deref_ecma_string (get_magic_string_p);
}
if (!ecma_is_completion_value_throw (ret_value))
{
JERRY_ASSERT (ecma_is_completion_value_empty (ret_value));
// 8.
ecma_string_t *set_magic_string_p = ecma_get_magic_string (LIT_MAGIC_STRING_SET);
if (ecma_op_object_get_property (obj_p, set_magic_string_p) != NULL)
{
ECMA_TRY_CATCH (set_prop_value,
ecma_op_object_get (obj_p, set_magic_string_p),
ret_value);
if (!ecma_op_is_callable (set_prop_value)
&& !ecma_is_value_undefined (set_prop_value))
{
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
prop_desc.is_set_defined = true;
if (ecma_is_value_undefined (set_prop_value))
{
prop_desc.set_p = NULL;
}
else
{
JERRY_ASSERT (ecma_is_value_object (set_prop_value));
ecma_object_t *set_p = ecma_get_object_from_value (set_prop_value);
ecma_ref_object (set_p);
prop_desc.set_p = set_p;
}
}
ECMA_FINALIZE (set_prop_value);
}
ecma_deref_ecma_string (set_magic_string_p);
}
if (!ecma_is_completion_value_throw (ret_value))
{
JERRY_ASSERT (ecma_is_completion_value_empty (ret_value));
// 9.
if (prop_desc.is_get_defined
|| prop_desc.is_set_defined)
{
if (prop_desc.is_value_defined
|| prop_desc.is_writable_defined)
{
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
}
}
if (!ecma_is_completion_value_throw (ret_value))
{
JERRY_ASSERT (ecma_is_completion_value_empty (ret_value));
}
else
{
ecma_free_property_descriptor (&prop_desc);
}
*out_prop_desc_p = prop_desc;
}
return ret_value;
} /* ecma_op_to_property_descriptor */
/**
* Perform 'eval' with code stored in continuous character buffer
*
* See also:
* ecma_op_eval
* ECMA-262 v5, 15.1.2.1 (steps 2 to 8)
*
* @return completion value
*/
ecma_completion_value_t
ecma_op_eval_chars_buffer (const jerry_api_char_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) */
bool is_called_from_strict_mode_code) /**< is eval is called from strict mode code */
{
JERRY_ASSERT (code_p != NULL);
ecma_completion_value_t completion;
const vm_instr_t *instrs_p;
jsp_status_t parse_status;
bool is_strict_call = (is_direct && is_called_from_strict_mode_code);
parse_status = parser_parse_eval (code_p,
code_buffer_size,
is_strict_call,
&instrs_p);
if (parse_status == JSP_STATUS_SYNTAX_ERROR)
{
completion = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_SYNTAX));
}
else if (parse_status == JSP_STATUS_REFERENCE_ERROR)
{
completion = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_REFERENCE));
}
else
{
JERRY_ASSERT (parse_status == JSP_STATUS_OK);
vm_instr_counter_t first_instr_index = 0u;
bool is_strict_prologue = false;
opcode_scope_code_flags_t scope_flags = vm_get_scope_flags (instrs_p,
first_instr_index++);
if (scope_flags & OPCODE_SCOPE_CODE_FLAGS_STRICT)
{
is_strict_prologue = true;
}
bool is_strict = (is_strict_call || is_strict_prologue);
ecma_value_t this_binding;
ecma_object_t *lex_env_p;
/* ECMA-262 v5, 10.4.2 */
if (is_direct)
{
this_binding = vm_get_this_binding ();
lex_env_p = vm_get_lex_env ();
}
else
{
this_binding = ecma_make_object_value (ecma_builtin_get (ECMA_BUILTIN_ID_GLOBAL));
lex_env_p = ecma_get_global_environment ();
}
if (is_strict)
{
ecma_object_t *strict_lex_env_p = ecma_create_decl_lex_env (lex_env_p);
ecma_deref_object (lex_env_p);
lex_env_p = strict_lex_env_p;
}
completion = vm_run_from_pos (instrs_p,
first_instr_index,
this_binding,
lex_env_p,
is_strict,
true);
if (ecma_is_completion_value_return (completion))
{
completion = ecma_make_normal_completion_value (ecma_get_completion_value_value (completion));
}
else
{
JERRY_ASSERT (ecma_is_completion_value_throw (completion));
}
ecma_deref_object (lex_env_p);
ecma_free_value (this_binding, true);
}
return completion;
} /* ecma_op_eval_chars_buffer */
/**
* Run the code, starting from specified instruction position
*/
ecma_completion_value_t
vm_run_from_pos (const bytecode_data_header_t *header_p, /**< byte-code data header */
vm_instr_counter_t start_pos, /**< position of starting instruction */
ecma_value_t this_binding_value, /**< value of 'ThisBinding' */
ecma_object_t *lex_env_p, /**< lexical environment to use */
bool is_strict, /**< is the code is strict mode code (ECMA-262 v5, 10.1.1) */
bool is_eval_code, /**< is the code is eval code (ECMA-262 v5, 10.1) */
ecma_collection_header_t *arg_collection_p) /**<
* - collection of function call arguments,
* if arguments for the called function
* are placed on registers;
* - NULL - otherwise.
*/
{
ecma_completion_value_t completion;
const vm_instr_t *instrs_p = header_p->instrs_p;
const vm_instr_t *curr = &instrs_p[start_pos];
JERRY_ASSERT (curr->op_idx == VM_OP_REG_VAR_DECL);
const uint32_t tmp_regs_num = curr->data.reg_var_decl.tmp_regs_num;
const uint32_t local_var_regs_num = curr->data.reg_var_decl.local_var_regs_num;
const uint32_t arg_regs_num = curr->data.reg_var_decl.arg_regs_num;
uint32_t regs_num = VM_SPECIAL_REGS_NUMBER + tmp_regs_num + local_var_regs_num + arg_regs_num;
MEM_DEFINE_LOCAL_ARRAY (regs, regs_num, ecma_value_t);
vm_frame_ctx_t frame_ctx;
frame_ctx.bytecode_header_p = header_p;
frame_ctx.pos = (vm_instr_counter_t) (start_pos + 1);
frame_ctx.lex_env_p = lex_env_p;
frame_ctx.is_strict = is_strict;
frame_ctx.is_eval_code = is_eval_code;
frame_ctx.is_call_in_direct_eval_form = false;
frame_ctx.tmp_num_p = ecma_alloc_number ();
vm_stack_add_frame (&frame_ctx.stack_frame, regs, regs_num, local_var_regs_num, arg_regs_num, arg_collection_p);
vm_stack_frame_set_reg_value (&frame_ctx.stack_frame,
VM_REG_SPECIAL_THIS_BINDING,
ecma_copy_value (this_binding_value, false));
vm_frame_ctx_t *prev_context_p = vm_top_context_p;
vm_top_context_p = &frame_ctx;
#ifdef MEM_STATS
interp_mem_stats_context_enter (&frame_ctx, start_pos);
#endif /* MEM_STATS */
completion = vm_loop (&frame_ctx, NULL);
JERRY_ASSERT (ecma_is_completion_value_throw (completion)
|| ecma_is_completion_value_return (completion));
vm_top_context_p = prev_context_p;
vm_stack_free_frame (&frame_ctx.stack_frame);
ecma_dealloc_number (frame_ctx.tmp_num_p);
#ifdef MEM_STATS
interp_mem_stats_context_exit (&frame_ctx, start_pos);
#endif /* MEM_STATS */
MEM_FINALIZE_LOCAL_ARRAY (regs);
return completion;
} /* vm_run_from_pos */