/**
* 'Object' object creation operation with one argument.
*
* See also: ECMA-262 v5, 15.2.2.1
*
* @return pointer to newly created 'Object' object
*/
ecma_value_t
ecma_op_create_object_object_arg (ecma_value_t value) /**< argument of constructor */
{
ecma_check_value_type_is_spec_defined (value);
if (ecma_is_value_object (value)
|| ecma_is_value_number (value)
|| ecma_is_value_string (value)
|| ecma_is_value_boolean (value))
{
// 1.b, 1.c, 1.d
return ecma_op_to_object (value);
}
else
{
// 2.
JERRY_ASSERT (ecma_is_value_undefined (value)
|| ecma_is_value_null (value));
ecma_object_t *obj_p = ecma_op_create_object_object_noarg ();
return ecma_make_object_value (obj_p);
}
} /* ecma_op_create_object_object_arg */
/**
* RegExp helper function to start the recursive matching algorithm
* and create the result Array object
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
ecma_regexp_exec_helper (ecma_value_t regexp_value, /**< RegExp object */
ecma_value_t input_string, /**< input string */
bool ignore_global) /**< ignore global flag */
{
ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
JERRY_ASSERT (ecma_is_value_object (regexp_value));
JERRY_ASSERT (ecma_is_value_string (input_string));
ecma_object_t *regexp_object_p = ecma_get_object_from_value (regexp_value);
JERRY_ASSERT (ecma_object_get_class_name (regexp_object_p) == LIT_MAGIC_STRING_REGEXP_UL);
ecma_property_t *bytecode_prop_p = ecma_get_internal_property (regexp_object_p,
ECMA_INTERNAL_PROPERTY_REGEXP_BYTECODE);
re_bytecode_t *bc_p = ECMA_GET_POINTER (re_bytecode_t, bytecode_prop_p->u.internal_property.value);
ecma_string_t *input_string_p = ecma_get_string_from_value (input_string);
lit_utf8_size_t input_string_size = ecma_string_get_size (input_string_p);
MEM_DEFINE_LOCAL_ARRAY (input_utf8_buffer_p, input_string_size, lit_utf8_byte_t);
ecma_string_to_utf8_string (input_string_p, input_utf8_buffer_p, (ssize_t) input_string_size);
lit_utf8_iterator_t iterator = lit_utf8_iterator_create (input_utf8_buffer_p, input_string_size);
re_matcher_ctx_t re_ctx;
re_ctx.input_start_p = iterator.buf_p;
re_ctx.input_end_p = iterator.buf_p + iterator.buf_size;
/* 1. Read bytecode header and init regexp matcher context. */
re_ctx.flags = (uint8_t) re_get_value (&bc_p);
if (ignore_global)
{
re_ctx.flags &= (uint8_t) ~RE_FLAG_GLOBAL;
}
JERRY_DDLOG ("Exec with flags [global: %d, ignoreCase: %d, multiline: %d]\n",
re_ctx.flags & RE_FLAG_GLOBAL,
re_ctx.flags & RE_FLAG_IGNORE_CASE,
re_ctx.flags & RE_FLAG_MULTILINE);
re_ctx.num_of_captures = re_get_value (&bc_p);
JERRY_ASSERT (re_ctx.num_of_captures % 2 == 0);
re_ctx.num_of_non_captures = re_get_value (&bc_p);
/* We create an invalid iterator, that will be used to identify unused result values. */
lit_utf8_iterator_t unused_iter = lit_utf8_iterator_create (NULL, 0);
unused_iter.buf_p = (lit_utf8_byte_t *) 1;
MEM_DEFINE_LOCAL_ARRAY (saved_p, re_ctx.num_of_captures + re_ctx.num_of_non_captures, lit_utf8_iterator_t);
for (uint32_t i = 0; i < re_ctx.num_of_captures + re_ctx.num_of_non_captures; i++)
{
saved_p[i] = unused_iter;
}
re_ctx.saved_p = saved_p;
uint32_t num_of_iter_length = (re_ctx.num_of_captures / 2) + (re_ctx.num_of_non_captures - 1);
MEM_DEFINE_LOCAL_ARRAY (num_of_iter_p, num_of_iter_length, uint32_t);
for (uint32_t i = 0; i < num_of_iter_length; i++)
{
num_of_iter_p[i] = 0u;
}
bool is_match = false;
re_ctx.num_of_iterations_p = num_of_iter_p;
int32_t index = 0;
ecma_length_t input_str_len = lit_utf8_string_length (iterator.buf_p, iterator.buf_size);
if (iterator.buf_p && (re_ctx.flags & RE_FLAG_GLOBAL))
{
ecma_string_t *magic_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_LASTINDEX_UL);
ecma_property_t *lastindex_prop_p = ecma_op_object_get_property (regexp_object_p, magic_str_p);
ECMA_OP_TO_NUMBER_TRY_CATCH (lastindex_num, lastindex_prop_p->u.named_data_property.value, ret_value)
index = ecma_number_to_int32 (lastindex_num);
JERRY_ASSERT (iterator.buf_pos.offset == 0 && !iterator.buf_pos.is_non_bmp_middle);
if (!lit_utf8_iterator_is_eos (&iterator)
&& index <= (int32_t) input_str_len
&& index > 0)
{
lit_utf8_iterator_advance (&iterator, (ecma_length_t) index);
}
ECMA_OP_TO_NUMBER_FINALIZE (lastindex_num);
ecma_deref_ecma_string (magic_str_p);
}
/* 2. Try to match */
lit_utf8_iterator_t sub_iter = lit_utf8_iterator_create (NULL, 0);
while (ecma_is_completion_value_empty (ret_value))
{
if (index < 0 || index > (int32_t) input_str_len)
{
if (re_ctx.flags & RE_FLAG_GLOBAL)
{
ecma_string_t *magic_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_LASTINDEX_UL);
ecma_number_t *lastindex_num_p = ecma_alloc_number ();
*lastindex_num_p = ECMA_NUMBER_ZERO;
ecma_op_object_put (regexp_object_p, magic_str_p, ecma_make_number_value (lastindex_num_p), true);
ecma_dealloc_number (lastindex_num_p);
ecma_deref_ecma_string (magic_str_p);
}
is_match = false;
break;
}
else
{
ECMA_TRY_CATCH (match_value, re_match_regexp (&re_ctx, bc_p, iterator, &sub_iter), ret_value);
if (ecma_is_value_true (match_value))
{
is_match = true;
break;
}
if (!lit_utf8_iterator_is_eos (&iterator))
{
lit_utf8_iterator_advance (&iterator, 1);
}
index++;
ECMA_FINALIZE (match_value);
}
}
if (iterator.buf_p && (re_ctx.flags & RE_FLAG_GLOBAL))
{
ecma_string_t *magic_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_LASTINDEX_UL);
ecma_number_t *lastindex_num_p = ecma_alloc_number ();
*lastindex_num_p = sub_iter.buf_pos.offset;
ecma_op_object_put (regexp_object_p, magic_str_p, ecma_make_number_value (lastindex_num_p), true);
ecma_dealloc_number (lastindex_num_p);
ecma_deref_ecma_string (magic_str_p);
}
/* 3. Fill the result array or return with 'undefiend' */
if (ecma_is_completion_value_empty (ret_value))
{
if (is_match)
{
ecma_completion_value_t result_array = ecma_op_create_array_object (0, 0, false);
ecma_object_t *result_array_obj_p = ecma_get_object_from_completion_value (result_array);
ecma_string_t *input_str_p = ecma_new_ecma_string_from_utf8 (iterator.buf_p, iterator.buf_size);
re_set_result_array_properties (result_array_obj_p, input_str_p, re_ctx.num_of_captures / 2, index);
ecma_deref_ecma_string (input_str_p);
for (uint32_t i = 0; i < re_ctx.num_of_captures; i += 2)
{
ecma_string_t *index_str_p = ecma_new_ecma_string_from_uint32 (i / 2);
/* Note: 'iter_p->buf_p == NULL' means the input is empty string */
if ((re_ctx.saved_p[i].buf_p != unused_iter.buf_p && re_ctx.saved_p[i + 1].buf_p != unused_iter.buf_p)
&& re_ctx.saved_p[i + 1].buf_pos.offset >= re_ctx.saved_p[i].buf_pos.offset)
{
ecma_length_t capture_str_len;
capture_str_len = (ecma_length_t) re_ctx.saved_p[i + 1].buf_pos.offset - re_ctx.saved_p[i].buf_pos.offset;
ecma_string_t *capture_str_p;
if (capture_str_len > 0)
{
const lit_utf8_byte_t *utf8_str_p = re_ctx.saved_p[i].buf_p + re_ctx.saved_p[i].buf_pos.offset;
capture_str_p = ecma_new_ecma_string_from_utf8 (utf8_str_p, capture_str_len);
}
else
{
capture_str_p = ecma_get_magic_string (LIT_MAGIC_STRING__EMPTY);
}
ecma_op_object_put (result_array_obj_p, index_str_p, ecma_make_string_value (capture_str_p), true);
ecma_deref_ecma_string (capture_str_p);
}
else
{
ecma_op_object_put (result_array_obj_p,
index_str_p,
ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED),
true);
}
ecma_deref_ecma_string (index_str_p);
}
ret_value = result_array;
}
else
{
ret_value = ecma_make_normal_completion_value (ecma_make_simple_value (ECMA_SIMPLE_VALUE_NULL));
}
}
MEM_FINALIZE_LOCAL_ARRAY (num_of_iter_p);
MEM_FINALIZE_LOCAL_ARRAY (saved_p);
MEM_FINALIZE_LOCAL_ARRAY (input_utf8_buffer_p);
return ret_value;
} /* ecma_regexp_exec_helper */
/**
* String object creation operation.
*
* See also: ECMA-262 v5, 15.5.2.1
*
* @return ecma value
* Returned value must be freed with ecma_free_value
*/
ecma_value_t
ecma_op_create_string_object (const ecma_value_t *arguments_list_p, /**< list of arguments that
are passed to String constructor */
ecma_length_t arguments_list_len) /**< length of the arguments' list */
{
JERRY_ASSERT (arguments_list_len == 0
|| arguments_list_p != NULL);
ecma_string_t *prim_prop_str_value_p;
ecma_number_t length_value;
if (arguments_list_len == 0)
{
prim_prop_str_value_p = ecma_new_ecma_string_from_magic_string_id (LIT_MAGIC_STRING__EMPTY);
length_value = ECMA_NUMBER_ZERO;
}
else
{
ecma_value_t to_str_arg_value = ecma_op_to_string (arguments_list_p[0]);
if (ECMA_IS_VALUE_ERROR (to_str_arg_value))
{
return to_str_arg_value;
}
else
{
JERRY_ASSERT (!ECMA_IS_VALUE_ERROR (to_str_arg_value));
JERRY_ASSERT (ecma_is_value_string (to_str_arg_value));
prim_prop_str_value_p = ecma_get_string_from_value (to_str_arg_value);
ecma_length_t string_len = ecma_string_get_length (prim_prop_str_value_p);
length_value = ((ecma_number_t) (uint32_t) string_len);
}
}
#ifndef CONFIG_DISABLE_STRING_BUILTIN
ecma_object_t *prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_STRING_PROTOTYPE);
#else /* CONFIG_DISABLE_STRING_BUILTIN */
ecma_object_t *prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_OBJECT_PROTOTYPE);
#endif /* !CONFIG_DISABLE_STRING_BUILTIN */
ecma_object_t *obj_p = ecma_create_object (prototype_obj_p,
false,
true,
ECMA_OBJECT_TYPE_STRING);
ecma_deref_object (prototype_obj_p);
/*
* [[Class]] property is not stored explicitly for objects of ECMA_OBJECT_TYPE_STRING type.
*
* See also: ecma_object_get_class_name
*/
ecma_property_t *prim_value_prop_p = ecma_create_internal_property (obj_p,
ECMA_INTERNAL_PROPERTY_ECMA_VALUE);
ecma_set_internal_property_value (prim_value_prop_p, ecma_make_string_value (prim_prop_str_value_p));
// 15.5.5.1
ecma_string_t *length_magic_string_p = ecma_new_ecma_length_string ();
ecma_property_t *length_prop_p = ecma_create_named_data_property (obj_p,
length_magic_string_p,
ECMA_PROPERTY_FIXED);
ecma_set_named_data_property_value (length_prop_p, ecma_make_number_value (length_value));
ecma_deref_ecma_string (length_magic_string_p);
return ecma_make_object_value (obj_p);
} /* ecma_op_create_string_object */
/**
* ECMA abstract equality comparison routine.
*
* See also: ECMA-262 v5, 11.9.3
*
* Note:
* This function might raise an exception, so the
* returned value must be freed with ecma_free_value.
*
* @return true - if values are equal,
* false - otherwise
* error - in case of any problems
*/
ecma_value_t
ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
ecma_value_t y) /**< second operand */
{
if (x == y)
{
return ECMA_VALUE_TRUE;
}
if (ecma_are_values_integer_numbers (x, y))
{
/* Note: the (x == y) comparison captures the true case. */
return ECMA_VALUE_FALSE;
}
if (ecma_is_value_number (x))
{
if (ecma_is_value_number (y))
{
/* 1.c */
ecma_number_t x_num = ecma_get_number_from_value (x);
ecma_number_t y_num = ecma_get_number_from_value (y);
bool is_x_equal_to_y = (x_num == y_num);
#ifndef JERRY_NDEBUG
bool is_x_equal_to_y_check;
if (ecma_number_is_nan (x_num)
|| ecma_number_is_nan (y_num))
{
is_x_equal_to_y_check = false;
}
else if (x_num == y_num
|| (ecma_number_is_zero (x_num)
&& ecma_number_is_zero (y_num)))
{
is_x_equal_to_y_check = true;
}
else
{
is_x_equal_to_y_check = false;
}
JERRY_ASSERT (is_x_equal_to_y == is_x_equal_to_y_check);
#endif /* !JERRY_NDEBUG */
return ecma_make_boolean_value (is_x_equal_to_y);
}
/* Swap values. */
ecma_value_t tmp = x;
x = y;
y = tmp;
}
if (ecma_is_value_string (x))
{
if (ecma_is_value_string (y))
{
/* 1., d. */
ecma_string_t *x_str_p = ecma_get_string_from_value (x);
ecma_string_t *y_str_p = ecma_get_string_from_value (y);
bool is_equal = ecma_compare_ecma_strings (x_str_p, y_str_p);
return ecma_make_boolean_value (is_equal);
}
if (ecma_is_value_number (y))
{
/* 4. */
ecma_value_t x_num_value = ecma_op_to_number (x);
if (ECMA_IS_VALUE_ERROR (x_num_value))
{
return x_num_value;
}
ecma_value_t compare_result = ecma_op_abstract_equality_compare (x_num_value, y);
ecma_free_value (x_num_value);
return compare_result;
}
/* Swap values. */
ecma_value_t tmp = x;
x = y;
y = tmp;
}
#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
if (ecma_is_value_symbol (x))
{
return ECMA_VALUE_FALSE;
}
#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
if (ecma_is_value_boolean (y))
{
if (ecma_is_value_boolean (x))
{
/* 1., e. */
/* Note: the (x == y) comparison captures the true case. */
return ECMA_VALUE_FALSE;
}
/* 7. */
return ecma_op_abstract_equality_compare (x, ecma_make_integer_value (ecma_is_value_true (y) ? 1 : 0));
}
if (ecma_is_value_object (x))
{
if (ecma_is_value_string (y)
#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
|| ecma_is_value_symbol (y)
#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
|| ecma_is_value_number (y))
{
/* 9. */
ecma_value_t x_prim_value = ecma_op_to_primitive (x, ECMA_PREFERRED_TYPE_NO);
if (ECMA_IS_VALUE_ERROR (x_prim_value))
{
return x_prim_value;
}
ecma_value_t compare_result = ecma_op_abstract_equality_compare (x_prim_value, y);
ecma_free_value (x_prim_value);
return compare_result;
}
/* 1., f. */
/* Note: the (x == y) comparison captures the true case. */
return ECMA_VALUE_FALSE;
}
if (ecma_is_value_boolean (x))
{
/* 6. */
return ecma_op_abstract_equality_compare (ecma_make_integer_value (ecma_is_value_true (x) ? 1 : 0), y);
}
if (ecma_is_value_undefined (x)
|| ecma_is_value_null (x))
{
/* 1. a., b. */
/* 2., 3. */
bool is_equal = ecma_is_value_undefined (y) || ecma_is_value_null (y);
return ecma_make_boolean_value (is_equal);
}
return ECMA_VALUE_FALSE;
} /* ecma_op_abstract_equality_compare */
/**
* ECMA abstract relational comparison routine.
*
* See also: ECMA-262 v5, 11.8.5
*
* @return ecma value
* Returned value must be freed with ecma_free_value
*/
ecma_value_t
ecma_op_abstract_relational_compare (ecma_value_t x, /**< first operand */
ecma_value_t y, /**< second operand */
bool left_first) /**< 'LeftFirst' flag */
{
ecma_value_t ret_value = ECMA_VALUE_EMPTY;
/* 1., 2. */
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;
const bool is_px_string = ecma_is_value_string (px);
const bool is_py_string = ecma_is_value_string (py);
if (!(is_px_string && is_py_string))
{
/* 3. */
/* a. */
ECMA_OP_TO_NUMBER_TRY_CATCH (nx, px, ret_value);
ECMA_OP_TO_NUMBER_TRY_CATCH (ny, py, ret_value);
/* b. */
if (ecma_number_is_nan (nx)
|| ecma_number_is_nan (ny))
{
/* c., d. */
ret_value = ECMA_VALUE_UNDEFINED;
}
else
{
bool is_x_less_than_y = (nx < ny);
#ifndef JERRY_NDEBUG
bool is_x_less_than_y_check;
if (nx == ny
|| (ecma_number_is_zero (nx)
&& ecma_number_is_zero (ny)))
{
/* e., f., g. */
is_x_less_than_y_check = false;
}
else if (ecma_number_is_infinity (nx)
&& !ecma_number_is_negative (nx))
{
/* h. */
is_x_less_than_y_check = false;
}
else if (ecma_number_is_infinity (ny)
&& !ecma_number_is_negative (ny))
{
/* i. */
is_x_less_than_y_check = true;
}
else if (ecma_number_is_infinity (ny)
&& ecma_number_is_negative (ny))
{
/* j. */
is_x_less_than_y_check = false;
}
else if (ecma_number_is_infinity (nx)
&& ecma_number_is_negative (nx))
{
/* k. */
is_x_less_than_y_check = true;
}
else
{
/* l. */
JERRY_ASSERT (!ecma_number_is_nan (nx)
&& !ecma_number_is_infinity (nx));
JERRY_ASSERT (!ecma_number_is_nan (ny)
&& !ecma_number_is_infinity (ny));
JERRY_ASSERT (!(ecma_number_is_zero (nx)
&& ecma_number_is_zero (ny)));
if (nx < ny)
{
is_x_less_than_y_check = true;
}
else
{
is_x_less_than_y_check = false;
}
}
JERRY_ASSERT (is_x_less_than_y_check == is_x_less_than_y);
#endif /* !JERRY_NDEBUG */
ret_value = ecma_make_boolean_value (is_x_less_than_y);
}
ECMA_OP_TO_NUMBER_FINALIZE (ny);
ECMA_OP_TO_NUMBER_FINALIZE (nx);
}
else
{ /* 4. */
JERRY_ASSERT (is_px_string && is_py_string);
ecma_string_t *str_x_p = ecma_get_string_from_value (px);
ecma_string_t *str_y_p = ecma_get_string_from_value (py);
bool is_px_less = ecma_compare_ecma_strings_relational (str_x_p, str_y_p);
ret_value = ecma_make_boolean_value (is_px_less);
}
ecma_free_value (prim_second_converted_value);
ecma_free_value (prim_first_converted_value);
return ret_value;
} /* ecma_op_abstract_relational_compare */
/**
* ECMA strict equality comparison routine.
*
* See also: ECMA-262 v5, 11.9.6
*
* @return true - if values are strict equal,
* false - otherwise
*/
bool
ecma_op_strict_equality_compare (ecma_value_t x, /**< first operand */
ecma_value_t y) /**< second operand */
{
if (ecma_is_value_direct (x)
|| ecma_is_value_direct (y)
#if ENABLED (JERRY_ES2015_BUILTIN_SYMBOL)
|| ecma_is_value_symbol (x)
|| ecma_is_value_symbol (y)
#endif /* ENABLED (JERRY_ES2015_BUILTIN_SYMBOL) */
|| ecma_is_value_object (x)
|| ecma_is_value_object (y))
{
JERRY_ASSERT (!ecma_is_value_direct (x)
|| ecma_is_value_undefined (x)
|| ecma_is_value_null (x)
|| ecma_is_value_boolean (x)
|| ecma_is_value_integer_number (x));
JERRY_ASSERT (!ecma_is_value_direct (y)
|| ecma_is_value_undefined (y)
|| ecma_is_value_null (y)
|| ecma_is_value_boolean (y)
|| ecma_is_value_integer_number (y));
if ((x != ecma_make_integer_value (0) || !ecma_is_value_float_number (y))
&& (y != ecma_make_integer_value (0) || !ecma_is_value_float_number (x)))
{
return (x == y);
}
/* The +0 === -0 case handled below. */
}
JERRY_ASSERT (ecma_is_value_number (x) || ecma_is_value_string (x));
JERRY_ASSERT (ecma_is_value_number (y) || ecma_is_value_string (y));
if (ecma_is_value_string (x))
{
if (!ecma_is_value_string (y))
{
return false;
}
ecma_string_t *x_str_p = ecma_get_string_from_value (x);
ecma_string_t *y_str_p = ecma_get_string_from_value (y);
return ecma_compare_ecma_strings (x_str_p, y_str_p);
}
if (!ecma_is_value_number (y))
{
return false;
}
ecma_number_t x_num = ecma_get_number_from_value (x);
ecma_number_t y_num = ecma_get_number_from_value (y);
bool is_x_equal_to_y = (x_num == y_num);
#ifndef JERRY_NDEBUG
bool is_x_equal_to_y_check;
if (ecma_number_is_nan (x_num)
|| ecma_number_is_nan (y_num))
{
is_x_equal_to_y_check = false;
}
else if (x_num == y_num
|| (ecma_number_is_zero (x_num)
&& ecma_number_is_zero (y_num)))
{
is_x_equal_to_y_check = true;
}
else
{
is_x_equal_to_y_check = false;
}
JERRY_ASSERT (is_x_equal_to_y == is_x_equal_to_y_check);
#endif /* !JERRY_NDEBUG */
return is_x_equal_to_y;
} /* ecma_op_strict_equality_compare */
/*
* Converts an standard error into a string.
*
* @return standard error string
*/
static ecma_string_t *
jerry_debugger_exception_object_to_string (ecma_value_t exception_obj_value) /**< exception object */
{
ecma_object_t *object_p = ecma_get_object_from_value (exception_obj_value);
ecma_object_t *prototype_p = ecma_get_object_prototype (object_p);
if (prototype_p == NULL
|| ecma_get_object_type (prototype_p) != ECMA_OBJECT_TYPE_GENERAL
|| !ecma_get_object_is_builtin (prototype_p))
{
return NULL;
}
lit_magic_string_id_t string_id;
switch (((ecma_extended_object_t *) prototype_p)->u.built_in.id)
{
#ifndef CONFIG_DISABLE_ERROR_BUILTINS
case ECMA_BUILTIN_ID_EVAL_ERROR_PROTOTYPE:
{
string_id = LIT_MAGIC_STRING_EVAL_ERROR_UL;
break;
}
case ECMA_BUILTIN_ID_RANGE_ERROR_PROTOTYPE:
{
string_id = LIT_MAGIC_STRING_RANGE_ERROR_UL;
break;
}
case ECMA_BUILTIN_ID_REFERENCE_ERROR_PROTOTYPE:
{
string_id = LIT_MAGIC_STRING_REFERENCE_ERROR_UL;
break;
}
case ECMA_BUILTIN_ID_SYNTAX_ERROR_PROTOTYPE:
{
string_id = LIT_MAGIC_STRING_SYNTAX_ERROR_UL;
break;
}
case ECMA_BUILTIN_ID_TYPE_ERROR_PROTOTYPE:
{
string_id = LIT_MAGIC_STRING_TYPE_ERROR_UL;
break;
}
case ECMA_BUILTIN_ID_URI_ERROR_PROTOTYPE:
{
string_id = LIT_MAGIC_STRING_URI_ERROR_UL;
break;
}
#endif /* !CONFIG_DISABLE_ERROR_BUILTINS */
case ECMA_BUILTIN_ID_ERROR_PROTOTYPE:
{
string_id = LIT_MAGIC_STRING_ERROR_UL;
break;
}
default:
{
return NULL;
}
}
lit_utf8_size_t size = lit_get_magic_string_size (string_id);
JERRY_ASSERT (size <= 14);
lit_utf8_byte_t data[16];
memcpy (data, lit_get_magic_string_utf8 (string_id), size);
ecma_property_t *property_p;
property_p = ecma_find_named_property (ecma_get_object_from_value (exception_obj_value),
ecma_get_magic_string (LIT_MAGIC_STRING_MESSAGE));
if (property_p == NULL
|| ECMA_PROPERTY_GET_TYPE (*property_p) != ECMA_PROPERTY_TYPE_NAMEDDATA)
{
return ecma_new_ecma_string_from_utf8 (data, size);
}
ecma_property_value_t *prop_value_p = ECMA_PROPERTY_VALUE_PTR (property_p);
if (!ecma_is_value_string (prop_value_p->value))
{
return ecma_new_ecma_string_from_utf8 (data, size);
}
data[size] = LIT_CHAR_COLON;
data[size + 1] = LIT_CHAR_SP;
return ecma_concat_ecma_strings (ecma_new_ecma_string_from_utf8 (data, size + 2),
ecma_get_string_from_value (prop_value_p->value));
} /* jerry_debugger_exception_object_to_string */
/**
* ToNumber operation.
*
* See also:
* ECMA-262 v5, 9.3
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
ecma_completion_value_t
ecma_op_to_number (ecma_value_t value) /**< ecma-value */
{
ecma_check_value_type_is_spec_defined (value);
if (ecma_is_value_number (value))
{
return ecma_make_normal_completion_value (ecma_copy_value (value, true));
}
else if (ecma_is_value_string (value))
{
ecma_string_t *str_p = ecma_get_string_from_value (value);
ecma_number_t *num_p = ecma_alloc_number ();
*num_p = ecma_string_to_number (str_p);
return ecma_make_normal_completion_value (ecma_make_number_value (num_p));
}
else if (ecma_is_value_object (value))
{
ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
ECMA_TRY_CATCH (primitive_value,
ecma_op_to_primitive (value, ECMA_PREFERRED_TYPE_NUMBER),
ret_value);
ret_value = ecma_op_to_number (primitive_value);
ECMA_FINALIZE (primitive_value);
return ret_value;
}
else
{
ecma_number_t *num_p = ecma_alloc_number ();
if (ecma_is_value_undefined (value))
{
*num_p = ecma_number_make_nan ();
}
else if (ecma_is_value_null (value))
{
*num_p = ECMA_NUMBER_ZERO;
}
else
{
JERRY_ASSERT (ecma_is_value_boolean (value));
if (ecma_is_value_true (value))
{
*num_p = ECMA_NUMBER_ONE;
}
else
{
*num_p = ECMA_NUMBER_ZERO;
}
}
return ecma_make_normal_completion_value (ecma_make_number_value (num_p));
}
} /* ecma_op_to_number */
/**
* SameValue operation.
*
* See also:
* ECMA-262 v5, 9.12
*
* @return true - if the value are same according to ECMA-defined SameValue algorithm,
* false - otherwise.
*/
bool
ecma_op_same_value (ecma_value_t x, /**< ecma value */
ecma_value_t y) /**< ecma value */
{
const bool is_x_undefined = ecma_is_value_undefined (x);
const bool is_x_null = ecma_is_value_null (x);
const bool is_x_boolean = ecma_is_value_boolean (x);
const bool is_x_number = ecma_is_value_number (x);
const bool is_x_string = ecma_is_value_string (x);
const bool is_x_object = ecma_is_value_object (x);
const bool is_y_undefined = ecma_is_value_undefined (y);
const bool is_y_null = ecma_is_value_null (y);
const bool is_y_boolean = ecma_is_value_boolean (y);
const bool is_y_number = ecma_is_value_number (y);
const bool is_y_string = ecma_is_value_string (y);
const bool is_y_object = ecma_is_value_object (y);
const bool is_types_equal = ((is_x_undefined && is_y_undefined)
|| (is_x_null && is_y_null)
|| (is_x_boolean && is_y_boolean)
|| (is_x_number && is_y_number)
|| (is_x_string && is_y_string)
|| (is_x_object && is_y_object));
if (!is_types_equal)
{
return false;
}
else if (is_x_undefined || is_x_null)
{
return true;
}
else if (is_x_number)
{
ecma_number_t x_num = ecma_get_number_from_value (x);
ecma_number_t y_num = ecma_get_number_from_value (y);
bool is_x_nan = ecma_number_is_nan (x_num);
bool is_y_nan = ecma_number_is_nan (y_num);
if (is_x_nan || is_y_nan)
{
/*
* If both are NaN
* return true;
* else
* // one of the numbers is NaN, and another - is not
* return false;
*/
return (is_x_nan && is_y_nan);
}
else if (ecma_number_is_zero (x_num)
&& ecma_number_is_zero (y_num)
&& ecma_number_is_negative (x_num) != ecma_number_is_negative (y_num))
{
return false;
}
else
{
return (x_num == y_num);
}
}
else if (is_x_string)
{
ecma_string_t *x_str_p = ecma_get_string_from_value (x);
ecma_string_t *y_str_p = ecma_get_string_from_value (y);
return ecma_compare_ecma_strings (x_str_p, y_str_p);
}
else if (is_x_boolean)
{
return (ecma_is_value_true (x) == ecma_is_value_true (y));
}
else
{
JERRY_ASSERT (is_x_object);
return (ecma_get_object_from_value (x) == ecma_get_object_from_value (y));
}
} /* ecma_op_same_value */
/**
* ToString operation.
*
* See also:
* ECMA-262 v5, 9.8
*
* @return ecma value
* Returned value must be freed with ecma_free_value
*/
ecma_value_t
ecma_op_to_string (ecma_value_t value) /**< ecma value */
{
ecma_check_value_type_is_spec_defined (value);
if (unlikely (ecma_is_value_object (value)))
{
ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
ECMA_TRY_CATCH (prim_value,
ecma_op_to_primitive (value, ECMA_PREFERRED_TYPE_STRING),
ret_value);
ret_value = ecma_op_to_string (prim_value);
ECMA_FINALIZE (prim_value);
return ret_value;
}
else
{
ecma_string_t *res_p = NULL;
if (ecma_is_value_string (value))
{
res_p = ecma_get_string_from_value (value);
res_p = ecma_copy_or_ref_ecma_string (res_p);
}
else if (ecma_is_value_integer_number (value))
{
ecma_integer_value_t num = ecma_get_integer_from_value (value);
if (num < 0)
{
res_p = ecma_new_ecma_string_from_number ((ecma_number_t) num);
}
else
{
res_p = ecma_new_ecma_string_from_uint32 ((uint32_t) num);
}
}
else if (ecma_is_value_float_number (value))
{
ecma_number_t num = ecma_get_float_from_value (value);
res_p = ecma_new_ecma_string_from_number (num);
}
else if (ecma_is_value_undefined (value))
{
res_p = ecma_get_magic_string (LIT_MAGIC_STRING_UNDEFINED);
}
else if (ecma_is_value_null (value))
{
res_p = ecma_get_magic_string (LIT_MAGIC_STRING_NULL);
}
else
{
JERRY_ASSERT (ecma_is_value_boolean (value));
if (ecma_is_value_true (value))
{
res_p = ecma_get_magic_string (LIT_MAGIC_STRING_TRUE);
}
else
{
res_p = ecma_get_magic_string (LIT_MAGIC_STRING_FALSE);
}
}
return ecma_make_string_value (res_p);
}
} /* ecma_op_to_string */
/**
* ToNumber operation.
*
* See also:
* ECMA-262 v5, 9.3
*
* @return ecma value
* Returned value must be freed with ecma_free_value
*/
ecma_value_t
ecma_op_to_number (ecma_value_t value) /**< ecma value */
{
ecma_check_value_type_is_spec_defined (value);
if (ecma_is_value_integer_number (value))
{
return value;
}
else if (ecma_is_value_float_number (value))
{
return ecma_copy_value (value);
}
else if (ecma_is_value_string (value))
{
ecma_string_t *str_p = ecma_get_string_from_value (value);
return ecma_make_number_value (ecma_string_to_number (str_p));
}
else if (ecma_is_value_object (value))
{
ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
ECMA_TRY_CATCH (primitive_value,
ecma_op_to_primitive (value, ECMA_PREFERRED_TYPE_NUMBER),
ret_value);
ret_value = ecma_op_to_number (primitive_value);
ECMA_FINALIZE (primitive_value);
return ret_value;
}
else
{
int16_t num = 0;
if (ecma_is_value_undefined (value))
{
return ecma_make_nan_value ();
}
else if (ecma_is_value_null (value))
{
num = 0;
}
else
{
JERRY_ASSERT (ecma_is_value_boolean (value));
if (ecma_is_value_true (value))
{
num = 1;
}
else
{
num = 0;
}
}
return ecma_make_integer_value (num);
}
} /* ecma_op_to_number */
/**
* The JSON object's 'stringify' routine
*
* See also:
* ECMA-262 v5, 15.12.3
*
* @return ecma value
* Returned value must be freed with ecma_free_value.
*/
static ecma_value_t
ecma_builtin_json_stringify (ecma_value_t this_arg __attr_unused___, /**< 'this' argument */
ecma_value_t arg1, /**< value */
ecma_value_t arg2, /**< replacer */
ecma_value_t arg3) /**< space */
{
ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
ecma_json_stringify_context_t context;
/* 1. */
context.occurence_stack_p = ecma_new_values_collection (NULL, 0, false);
/* 2. */
context.indent_str_p = ecma_get_magic_string (LIT_MAGIC_STRING__EMPTY);
/* 3. */
context.property_list_p = ecma_new_values_collection (NULL, 0, false);
context.replacer_function_p = NULL;
/* 4. */
if (ecma_is_value_object (arg2))
{
ecma_object_t *obj_p = ecma_get_object_from_value (arg2);
/* 4.a */
if (ecma_op_is_callable (arg2))
{
context.replacer_function_p = obj_p;
}
/* 4.b */
else if (ecma_object_get_class_name (obj_p) == LIT_MAGIC_STRING_ARRAY_UL)
{
ecma_string_t *length_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
ECMA_TRY_CATCH (array_length,
ecma_op_object_get (obj_p, length_str_p),
ret_value);
ECMA_OP_TO_NUMBER_TRY_CATCH (array_length_num,
array_length,
ret_value);
uint32_t array_length = ecma_number_to_uint32 (array_length_num);
uint32_t index = 0;
/* 4.b.ii */
while ((index < array_length) && ecma_is_value_empty (ret_value))
{
ecma_string_t *index_str_p = ecma_new_ecma_string_from_uint32 (index);
ECMA_TRY_CATCH (value,
ecma_op_object_get (obj_p, index_str_p),
ret_value);
/* 4.b.ii.1 */
ecma_value_t item = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
/* 4.b.ii.2 */
if (ecma_is_value_string (value))
{
item = ecma_copy_value (value, true);
}
/* 4.b.ii.3 */
else if (ecma_is_value_number (value))
{
ECMA_TRY_CATCH (str_val,
ecma_op_to_string (value),
ret_value);
item = ecma_copy_value (str_val, true);
ECMA_FINALIZE (str_val);
}
/* 4.b.ii.4 */
else if (ecma_is_value_object (value))
{
ecma_object_t *obj_val_p = ecma_get_object_from_value (value);
lit_magic_string_id_t class_name = ecma_object_get_class_name (obj_val_p);
/* 4.b.ii.4.a */
if (class_name == LIT_MAGIC_STRING_NUMBER_UL
|| class_name == LIT_MAGIC_STRING_STRING_UL)
{
ECMA_TRY_CATCH (val,
ecma_op_to_string (value),
ret_value);
item = ecma_copy_value (val, true);
ECMA_FINALIZE (val);
}
}
/* 4.b.ii.5 */
if (!ecma_is_value_undefined (item))
{
if (!ecma_has_string_value_in_collection (context.property_list_p, item))
{
ecma_append_to_values_collection (context.property_list_p, item, true);
ecma_deref_ecma_string (ecma_get_string_from_value (item));
}
else
{
ecma_free_value (item);
}
}
ECMA_FINALIZE (value);
ecma_deref_ecma_string (index_str_p);
index++;
}
ECMA_OP_TO_NUMBER_FINALIZE (array_length_num);
ECMA_FINALIZE (array_length);
ecma_deref_ecma_string (length_str_p);
}
}
if (ecma_is_value_empty (ret_value))
{
ecma_value_t space = ecma_copy_value (arg3, true);
/* 5. */
if (ecma_is_value_object (arg3))
{
ecma_object_t *obj_p = ecma_get_object_from_value (arg3);
lit_magic_string_id_t class_name = ecma_object_get_class_name (obj_p);
/* 5.a */
if (class_name == LIT_MAGIC_STRING_NUMBER_UL)
{
ECMA_TRY_CATCH (val,
ecma_op_to_number (arg3),
ret_value);
ecma_free_value (space);
space = ecma_copy_value (val, true);
ECMA_FINALIZE (val);
}
/* 5.b */
else if (class_name == LIT_MAGIC_STRING_STRING_UL)
{
ECMA_TRY_CATCH (val,
ecma_op_to_string (arg3),
ret_value);
ecma_free_value (space);
space = ecma_copy_value (val, true);
ECMA_FINALIZE (val);
}
}
if (ecma_is_value_empty (ret_value))
{
/* 6. */
if (ecma_is_value_number (space))
{
ECMA_OP_TO_NUMBER_TRY_CATCH (array_length_num,
arg3,
ret_value);
/* 6.a */
int32_t num_of_spaces = ecma_number_to_int32 (array_length_num);
int32_t space = (num_of_spaces > 10) ? 10 : num_of_spaces;
/* 6.b */
if (space < 1)
{
context.gap_str_p = ecma_get_magic_string (LIT_MAGIC_STRING__EMPTY);
}
else
{
MEM_DEFINE_LOCAL_ARRAY (space_buff, space, char);
for (int32_t i = 0; i < space; i++)
{
space_buff[i] = LIT_CHAR_SP;
}
context.gap_str_p = ecma_new_ecma_string_from_utf8 ((lit_utf8_byte_t *) space_buff, (lit_utf8_size_t) space);
MEM_FINALIZE_LOCAL_ARRAY (space_buff);
}
ECMA_OP_TO_NUMBER_FINALIZE (array_length_num);
}
/* 7. */
else if (ecma_is_value_string (space))
{
ecma_string_t *space_str_p = ecma_get_string_from_value (space);
ecma_length_t num_of_chars = ecma_string_get_length (space_str_p);
if (num_of_chars < 10)
{
context.gap_str_p = ecma_copy_or_ref_ecma_string (space_str_p);
}
else
{
context.gap_str_p = ecma_string_substr (space_str_p, 0, 10);
}
}
/* 8. */
else
{
context.gap_str_p = ecma_get_magic_string (LIT_MAGIC_STRING__EMPTY);
}
}
ecma_free_value (space);
if (ecma_is_value_empty (ret_value))
{
/* 9. */
ecma_object_t *obj_wrapper_p = ecma_op_create_object_object_noarg ();
ecma_string_t *empty_str_p = ecma_get_magic_string (LIT_MAGIC_STRING__EMPTY);
/* 10. */
ecma_value_t put_comp_val = ecma_op_object_put (obj_wrapper_p,
empty_str_p,
arg1,
false);
JERRY_ASSERT (ecma_is_value_true (put_comp_val));
ecma_free_value (put_comp_val);
/* 11. */
ECMA_TRY_CATCH (str_val,
ecma_builtin_json_str (empty_str_p, obj_wrapper_p, &context),
ret_value);
ret_value = ecma_copy_value (str_val, true);
ECMA_FINALIZE (str_val);
ecma_deref_object (obj_wrapper_p);
ecma_deref_ecma_string (empty_str_p);
}
ecma_deref_ecma_string (context.gap_str_p);
}
ecma_deref_ecma_string (context.indent_str_p);
ecma_free_values_collection (context.property_list_p, true);
ecma_free_values_collection (context.occurence_stack_p, true);
return ret_value;
} /* ecma_builtin_json_stringify */
/**
* Abstract operation 'Str' defined in 15.12.3
*
* See also:
* ECMA-262 v5, 15.12.3
*
* @return ecma value
* Returned value must be freed with ecma_free_value.
*/
static ecma_value_t
ecma_builtin_json_str (ecma_string_t *key_p, /**< property key*/
ecma_object_t *holder_p, /**< the object*/
ecma_json_stringify_context_t *context_p) /**< context*/
{
ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
/* 1. */
ECMA_TRY_CATCH (value,
ecma_op_object_get (holder_p, key_p),
ret_value);
ecma_value_t my_val = ecma_copy_value (value, true);
/* 2. */
if (ecma_is_value_object (my_val))
{
ecma_object_t *value_obj_p = ecma_get_object_from_value (my_val);
ecma_string_t *to_json_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_TO_JSON_UL);
/* 2.a */
ECMA_TRY_CATCH (toJSON,
ecma_op_object_get (value_obj_p, to_json_str_p),
ret_value);
/* 2.b */
if (ecma_op_is_callable (toJSON))
{
ecma_value_t key_value = ecma_make_string_value (key_p);
ecma_value_t call_args[] = { key_value };
ecma_object_t *toJSON_obj_p = ecma_get_object_from_value (toJSON);
ECMA_TRY_CATCH (func_ret_val,
ecma_op_function_call (toJSON_obj_p, my_val, call_args, 1),
ret_value);
ecma_free_value (my_val);
my_val = ecma_copy_value (func_ret_val, true);
ECMA_FINALIZE (func_ret_val);
}
ECMA_FINALIZE (toJSON);
ecma_deref_ecma_string (to_json_str_p);
}
/* 3. */
if (context_p->replacer_function_p && ecma_is_value_empty (ret_value))
{
ecma_value_t holder_value = ecma_make_object_value (holder_p);
ecma_value_t key_value = ecma_make_string_value (key_p);
ecma_value_t call_args[] = { key_value, my_val };
ECMA_TRY_CATCH (func_ret_val,
ecma_op_function_call (context_p->replacer_function_p, holder_value, call_args, 2),
ret_value);
ecma_free_value (my_val);
my_val = ecma_copy_value (func_ret_val, true);
ECMA_FINALIZE (func_ret_val);
}
/* 4. */
if (ecma_is_value_object (my_val) && ecma_is_value_empty (ret_value))
{
ecma_object_t *obj_p = ecma_get_object_from_value (my_val);
lit_magic_string_id_t class_name = ecma_object_get_class_name (obj_p);
/* 4.a */
if (class_name == LIT_MAGIC_STRING_NUMBER_UL)
{
ECMA_TRY_CATCH (val,
ecma_op_to_number (my_val),
ret_value);
ecma_free_value (my_val);
my_val = ecma_copy_value (val, true);
ECMA_FINALIZE (val);
}
/* 4.b */
else if (class_name == LIT_MAGIC_STRING_STRING_UL)
{
ECMA_TRY_CATCH (val,
ecma_op_to_string (my_val),
ret_value);
ecma_free_value (my_val);
my_val = ecma_copy_value (val, true);
ECMA_FINALIZE (val);
}
/* 4.c */
else if (class_name == LIT_MAGIC_STRING_BOOLEAN_UL)
{
ECMA_TRY_CATCH (val,
ecma_op_to_primitive (my_val, ECMA_PREFERRED_TYPE_NO),
ret_value);
ecma_free_value (my_val);
my_val = ecma_copy_value (val, true);
ECMA_FINALIZE (val);
}
}
if (ecma_is_value_empty (ret_value))
{
/* 5. - 7. */
if (ecma_is_value_null (my_val) || ecma_is_value_boolean (my_val))
{
ret_value = ecma_op_to_string (my_val);
JERRY_ASSERT (!ecma_is_value_error (ret_value));
}
/* 8. */
else if (ecma_is_value_string (my_val))
{
ecma_string_t *value_str_p = ecma_get_string_from_value (my_val);
ret_value = ecma_builtin_json_quote (value_str_p);
}
/* 9. */
else if (ecma_is_value_number (my_val))
{
ecma_number_t num_value_p = *ecma_get_number_from_value (my_val);
/* 9.a */
if (!ecma_number_is_nan (num_value_p) && !ecma_number_is_infinity (num_value_p))
{
ret_value = ecma_op_to_string (my_val);
JERRY_ASSERT (!ecma_is_value_error (ret_value));
}
else
{
/* 9.b */
ecma_string_t *null_str_p = ecma_get_magic_string (LIT_MAGIC_STRING_NULL);
ret_value = ecma_make_string_value (null_str_p);
}
}
/* 10. */
else if (ecma_is_value_object (my_val) && !ecma_op_is_callable (my_val))
{
ecma_object_t *obj_p = ecma_get_object_from_value (my_val);
lit_magic_string_id_t class_name = ecma_object_get_class_name (obj_p);
/* 10.a */
if (class_name == LIT_MAGIC_STRING_ARRAY_UL)
{
ECMA_TRY_CATCH (val,
ecma_builtin_json_array (obj_p, context_p),
ret_value);
ret_value = ecma_copy_value (val, true);
ECMA_FINALIZE (val);
}
/* 10.b */
else
{
ECMA_TRY_CATCH (val,
ecma_builtin_json_object (obj_p, context_p),
ret_value);
ret_value = ecma_copy_value (val, true);
ECMA_FINALIZE (val);
}
}
else
{
/* 11. */
ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
}
}
ecma_free_value (my_val);
ECMA_FINALIZE (value);
return ret_value;
} /* ecma_builtin_json_str */
/**
* SameValue operation.
*
* See also:
* ECMA-262 v5, 9.12
*
* @return true - if the value are same according to ECMA-defined SameValue algorithm,
* false - otherwise.
*/
bool
ecma_op_same_value (ecma_value_t x, /**< ecma-value */
ecma_value_t y) /**< ecma-value */
{
const bool is_x_undefined = ecma_is_value_undefined (x);
const bool is_x_null = ecma_is_value_null (x);
const bool is_x_boolean = ecma_is_value_boolean (x);
const bool is_x_number = ecma_is_value_number (x);
const bool is_x_string = ecma_is_value_string (x);
const bool is_x_object = ecma_is_value_object (x);
const bool is_y_undefined = ecma_is_value_undefined (y);
const bool is_y_null = ecma_is_value_null (y);
const bool is_y_boolean = ecma_is_value_boolean (y);
const bool is_y_number = ecma_is_value_number (y);
const bool is_y_string = ecma_is_value_string (y);
const bool is_y_object = ecma_is_value_object (y);
const bool is_types_equal = ((is_x_undefined && is_y_undefined)
|| (is_x_null && is_y_null)
|| (is_x_boolean && is_y_boolean)
|| (is_x_number && is_y_number)
|| (is_x_string && is_y_string)
|| (is_x_object && is_y_object));
if (!is_types_equal)
{
return false;
}
if (is_x_undefined
|| is_x_null)
{
return true;
}
if (is_x_number)
{
ecma_number_t *x_num_p = ecma_get_number_from_value (x);
ecma_number_t *y_num_p = ecma_get_number_from_value (y);
if (ecma_number_is_nan (*x_num_p)
&& ecma_number_is_nan (*y_num_p))
{
return true;
}
else if (ecma_number_is_zero (*x_num_p)
&& ecma_number_is_zero (*y_num_p)
&& ecma_number_is_negative (*x_num_p) != ecma_number_is_negative (*y_num_p))
{
return false;
}
return (*x_num_p == *y_num_p);
}
if (is_x_string)
{
ecma_string_t* x_str_p = ecma_get_string_from_value (x);
ecma_string_t* y_str_p = ecma_get_string_from_value (y);
return ecma_compare_ecma_strings (x_str_p, y_str_p);
}
if (is_x_boolean)
{
return (ecma_is_value_true (x) == ecma_is_value_true (y));
}
JERRY_ASSERT (is_x_object);
return (ecma_get_object_from_value (x) == ecma_get_object_from_value (y));
} /* ecma_op_same_value */
/**
* PutValue operation part (object base).
*
* See also: ECMA-262 v5, 8.7.2, section 4
*
* @return ecma value
* Returned value must be freed with ecma_free_value.
*/
ecma_value_t
ecma_op_put_value_object_base (ecma_reference_t ref, /**< ECMA-reference */
ecma_value_t value) /**< ECMA-value */
{
const ecma_value_t base = ref.base;
const bool is_unresolvable_reference = ecma_is_value_undefined (base);
const bool has_primitive_base = (ecma_is_value_boolean (base)
|| ecma_is_value_number (base)
|| ecma_is_value_string (base));
const bool has_object_base = (ecma_is_value_object (base)
&& !(ecma_is_lexical_environment (ecma_get_object_from_value (base))));
const bool is_property_reference = has_primitive_base || has_object_base;
JERRY_ASSERT (!is_unresolvable_reference);
JERRY_ASSERT (is_property_reference);
// 4.a
if (!has_primitive_base)
{
// 4.b case 1
ecma_object_t *obj_p = ecma_get_object_from_value (base);
JERRY_ASSERT (obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
ECMA_TRY_CATCH (put_ret_value,
ecma_op_object_put (obj_p,
ECMA_GET_NON_NULL_POINTER (ecma_string_t,
ref.referenced_name_cp),
value,
ref.is_strict),
ret_value);
ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
ECMA_FINALIZE (put_ret_value);
return ret_value;
}
else
{
// 4.b case 2
ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
// sub_1.
ECMA_TRY_CATCH (obj_base, ecma_op_to_object (base), ret_value);
ecma_object_t *obj_p = ecma_get_object_from_value (obj_base);
JERRY_ASSERT (obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
ecma_string_t *referenced_name_p = ECMA_GET_NON_NULL_POINTER (ecma_string_t,
ref.referenced_name_cp);
// sub_2.
if (!ecma_op_object_can_put (obj_p, referenced_name_p))
{
ret_value = ecma_reject_put (ref.is_strict);
}
else
{
// sub_3.
ecma_property_t *own_prop_p = ecma_op_object_get_own_property (obj_p, referenced_name_p);
// sub_5.
ecma_property_t *prop_p = ecma_op_object_get_property (obj_p, referenced_name_p);
// sub_4., sub_7
if ((own_prop_p != NULL && (own_prop_p->flags & ECMA_PROPERTY_FLAG_NAMEDDATA))
|| (prop_p == NULL)
|| !(prop_p->flags & ECMA_PROPERTY_FLAG_NAMEDACCESSOR))
{
ret_value = ecma_reject_put (ref.is_strict);
}
else
{
// sub_6.
JERRY_ASSERT (prop_p != NULL && (prop_p->flags & ECMA_PROPERTY_FLAG_NAMEDACCESSOR));
ecma_object_t *setter_p = ecma_get_named_accessor_property_setter (prop_p);
JERRY_ASSERT (setter_p != NULL);
ECMA_TRY_CATCH (call_ret,
ecma_op_function_call (setter_p, base, &value, 1),
ret_value);
ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
ECMA_FINALIZE (call_ret);
}
}
ECMA_FINALIZE (obj_base);
return ret_value;
}
} /* ecma_op_put_value_object_base */
/**
* GetValue operation part (object base).
*
* See also: ECMA-262 v5, 8.7.1, section 4
*
* @return ecma value
* Returned value must be freed with ecma_free_value.
*/
ecma_value_t
ecma_op_get_value_object_base (ecma_reference_t ref) /**< ECMA-reference */
{
const ecma_value_t base = ref.base;
const bool is_unresolvable_reference = ecma_is_value_undefined (base);
const bool has_primitive_base = (ecma_is_value_boolean (base)
|| ecma_is_value_number (base)
|| ecma_is_value_string (base));
const bool has_object_base = (ecma_is_value_object (base)
&& !(ecma_is_lexical_environment (ecma_get_object_from_value (base))));
const bool is_property_reference = has_primitive_base || has_object_base;
JERRY_ASSERT (!is_unresolvable_reference);
JERRY_ASSERT (is_property_reference);
ecma_string_t *referenced_name_p = ECMA_GET_NON_NULL_POINTER (ecma_string_t,
ref.referenced_name_cp);
// 4.a
if (!has_primitive_base)
{
// 4.b case 1
ecma_object_t *obj_p = ecma_get_object_from_value (base);
JERRY_ASSERT (obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
return ecma_op_object_get (obj_p, referenced_name_p);
}
else
{
// 4.b case 2
ecma_value_t ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
// 1.
ECMA_TRY_CATCH (obj_base, ecma_op_to_object (base), ret_value);
ecma_object_t *obj_p = ecma_get_object_from_value (obj_base);
JERRY_ASSERT (obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
// 2.
ecma_property_t *prop_p = ecma_op_object_get_property (obj_p, referenced_name_p);
if (prop_p == NULL)
{
// 3.
ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
}
else if (prop_p->flags & ECMA_PROPERTY_FLAG_NAMEDDATA)
{
// 4.
ret_value = ecma_copy_value (ecma_get_named_data_property_value (prop_p), true);
}
else
{
// 5.
JERRY_ASSERT (prop_p->flags & ECMA_PROPERTY_FLAG_NAMEDACCESSOR);
ecma_object_t *obj_p = ecma_get_named_accessor_property_getter (prop_p);
// 6.
if (obj_p == NULL)
{
ret_value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
}
else
{
// 7.
ret_value = ecma_op_function_call (obj_p, base, NULL, 0);
}
}
ECMA_FINALIZE (obj_base);
return ret_value;
}
} /* ecma_op_get_value_object_base */
/**
* Send result of evaluated expression or throw an error.
*
* @return true - if execution should be resumed
* false - otherwise
*/
static bool
jerry_debugger_send_eval (const lit_utf8_byte_t *eval_string_p, /**< evaluated string */
size_t eval_string_size) /**< evaluated string size */
{
JERRY_ASSERT (JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_CONNECTED);
JERRY_ASSERT (!(JERRY_CONTEXT (debugger_flags) & JERRY_DEBUGGER_VM_IGNORE));
JERRY_DEBUGGER_SET_FLAGS (JERRY_DEBUGGER_VM_IGNORE);
ecma_value_t result = ecma_op_eval_chars_buffer (eval_string_p + 1, eval_string_size - 1, true, false);
JERRY_DEBUGGER_CLEAR_FLAGS (JERRY_DEBUGGER_VM_IGNORE);
if (!ECMA_IS_VALUE_ERROR (result))
{
if (eval_string_p[0] != JERRY_DEBUGGER_EVAL_EVAL)
{
JERRY_DEBUGGER_SET_FLAGS (JERRY_DEBUGGER_VM_EXCEPTION_THROWN);
JERRY_CONTEXT (error_value) = result;
/* Stop where the error is caught. */
JERRY_DEBUGGER_SET_FLAGS (JERRY_DEBUGGER_VM_STOP);
JERRY_CONTEXT (debugger_stop_context) = NULL;
if (eval_string_p[0] == JERRY_DEBUGGER_EVAL_THROW)
{
JERRY_CONTEXT (status_flags) |= ECMA_STATUS_EXCEPTION;
}
else
{
JERRY_CONTEXT (status_flags) &= (uint32_t) ~ECMA_STATUS_EXCEPTION;
}
return true;
}
if (!ecma_is_value_string (result))
{
ecma_value_t to_string_value = ecma_op_to_string (result);
ecma_free_value (result);
result = to_string_value;
}
}
ecma_value_t message = result;
uint8_t type = JERRY_DEBUGGER_EVAL_OK;
if (ECMA_IS_VALUE_ERROR (result))
{
type = JERRY_DEBUGGER_EVAL_ERROR;
result = JERRY_CONTEXT (error_value);
if (ecma_is_value_object (result))
{
message = ecma_op_object_find (ecma_get_object_from_value (result),
ecma_get_magic_string (LIT_MAGIC_STRING_MESSAGE));
if (!ecma_is_value_string (message)
|| ecma_string_is_empty (ecma_get_string_from_value (message)))
{
ecma_free_value (message);
lit_magic_string_id_t id = ecma_object_get_class_name (ecma_get_object_from_value (result));
ecma_free_value (result);
const lit_utf8_byte_t *string_p = lit_get_magic_string_utf8 (id);
jerry_debugger_send_string (JERRY_DEBUGGER_EVAL_RESULT,
type,
string_p,
strlen ((const char *) string_p));
return false;
}
}
else
{
/* Primitive type. */
message = ecma_op_to_string (result);
JERRY_ASSERT (!ECMA_IS_VALUE_ERROR (message));
}
ecma_free_value (result);
}
ecma_string_t *string_p = ecma_get_string_from_value (message);
ECMA_STRING_TO_UTF8_STRING (string_p, buffer_p, buffer_size);
jerry_debugger_send_string (JERRY_DEBUGGER_EVAL_RESULT, type, buffer_p, buffer_size);
ECMA_FINALIZE_UTF8_STRING (buffer_p, buffer_size);
ecma_free_value (message);
return false;
} /* jerry_debugger_send_eval */
