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

Introducing ecma_get_[type]_from_value, ecma_get_[type]_from_completion_value and ecma_get_completion_value_value interfaces.

Browse Source
This commit is contained in:
Ruben Ayrapetyan 2014-11-27 14:19:53 +03:00
parent 22e1941050
commit 815309c7e9
35 changed files with 370 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/libcoreint/interpreter.c
View File

@ -375,7 +375,7 @@ run_int (void)
ecma_finalize ();
ecma_gc_run (ECMA_GC_GEN_COUNT - 1);
return ecma_is_value_true (completion.u.value);
return ecma_is_value_true (ecma_get_completion_value_value (completion));
}
case ECMA_COMPLETION_TYPE_BREAK:
case ECMA_COMPLETION_TYPE_CONTINUE:

16
src/libcoreint/opcodes-agnostic.c
View File

@ -35,10 +35,10 @@ opfunc_is_true_jmp_down (opcode_t opdata, /**< operation data */
ECMA_TRY_CATCH (cond_value, get_variable_value (int_data, cond_var_idx, false), ret_value);
ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (cond_value.u.value);
ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (ecma_get_completion_value_value (cond_value));
JERRY_ASSERT (ecma_is_completion_value_normal (to_bool_completion));
if (ecma_is_value_true (to_bool_completion.u.value))
if (ecma_is_value_true (ecma_get_completion_value_value (to_bool_completion)))
{
JERRY_ASSERT (offset != 0 && ((uint32_t) int_data->pos + offset < MAX_OPCODES));
int_data->pos = (opcode_counter_t) (int_data->pos + offset);
@ -68,10 +68,10 @@ opfunc_is_true_jmp_up (opcode_t opdata, /**< operation data */
ECMA_TRY_CATCH (cond_value, get_variable_value (int_data, cond_var_idx, false), ret_value);
ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (cond_value.u.value);
ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (ecma_get_completion_value_value (cond_value));
JERRY_ASSERT (ecma_is_completion_value_normal (to_bool_completion));
if (ecma_is_value_true (to_bool_completion.u.value))
if (ecma_is_value_true (ecma_get_completion_value_value (to_bool_completion)))
{
JERRY_ASSERT (offset != 0 && (uint32_t) int_data->pos >= offset);
int_data->pos = (opcode_counter_t) (int_data->pos - offset);
@ -107,10 +107,10 @@ opfunc_is_false_jmp_down (opcode_t opdata, /**< operation data */
ECMA_TRY_CATCH (cond_value, get_variable_value (int_data, cond_var_idx, false), ret_value);
ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (cond_value.u.value);
ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (ecma_get_completion_value_value (cond_value));
JERRY_ASSERT (ecma_is_completion_value_normal (to_bool_completion));
if (!ecma_is_value_true (to_bool_completion.u.value))
if (!ecma_is_value_true (ecma_get_completion_value_value (to_bool_completion)))
{
JERRY_ASSERT (offset != 0 && ((uint32_t) int_data->pos + offset < MAX_OPCODES));
int_data->pos = (opcode_counter_t) (int_data->pos + offset);
@ -140,10 +140,10 @@ opfunc_is_false_jmp_up (opcode_t opdata, /**< operation data */
ECMA_TRY_CATCH (cond_value, get_variable_value (int_data, cond_var_idx, false), ret_value);
ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (cond_value.u.value);
ecma_completion_value_t to_bool_completion = ecma_op_to_boolean (ecma_get_completion_value_value (cond_value));
JERRY_ASSERT (ecma_is_completion_value_normal (to_bool_completion));
if (!ecma_is_value_true (to_bool_completion.u.value))
if (!ecma_is_value_true (ecma_get_completion_value_value (to_bool_completion)))
{
JERRY_ASSERT (offset != 0 && (uint32_t) int_data->pos >= offset);
int_data->pos = (opcode_counter_t) (int_data->pos - offset);

54
src/libcoreint/opcodes-ecma-arithmetics.c
View File

@ -54,8 +54,8 @@ do_number_arithmetic (int_data_t *int_data, /**< interpreter context */
ECMA_TRY_CATCH (num_right_value, ecma_op_to_number (right_value), ret_value);
ecma_number_t *left_p, *right_p, *res_p;
left_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (num_left_value.u.value.value);
right_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (num_right_value.u.value.value);
left_p = ecma_get_number_from_completion_value (num_left_value);
right_p = ecma_get_number_from_completion_value (num_right_value);
res_p = ecma_alloc_number ();
@ -122,17 +122,23 @@ opfunc_addition (opcode_t opdata, /**< operation data */
ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
ECMA_TRY_CATCH (prim_left_value, ecma_op_to_primitive (left_value.u.value, ECMA_PREFERRED_TYPE_NO), ret_value);
ECMA_TRY_CATCH (prim_right_value, ecma_op_to_primitive (right_value.u.value, ECMA_PREFERRED_TYPE_NO), ret_value);
ECMA_TRY_CATCH (prim_left_value,
ecma_op_to_primitive (ecma_get_completion_value_value (left_value),
ECMA_PREFERRED_TYPE_NO),
ret_value);
ECMA_TRY_CATCH (prim_right_value,
ecma_op_to_primitive (ecma_get_completion_value_value (right_value),
ECMA_PREFERRED_TYPE_NO),
ret_value);
if (ecma_is_value_string (prim_left_value.u.value)
|| ecma_is_value_string (prim_right_value.u.value))
if (ecma_is_value_string (ecma_get_completion_value_value (prim_left_value))
|| ecma_is_value_string (ecma_get_completion_value_value (prim_right_value)))
{
ECMA_TRY_CATCH (str_left_value, ecma_op_to_string (prim_left_value.u.value), ret_value);
ECMA_TRY_CATCH (str_right_value, ecma_op_to_string (prim_right_value.u.value), ret_value);
ECMA_TRY_CATCH (str_left_value, ecma_op_to_string (ecma_get_completion_value_value (prim_left_value)), ret_value);
ECMA_TRY_CATCH (str_right_value, ecma_op_to_string (ecma_get_completion_value_value (prim_right_value)), ret_value);
ecma_string_t *string1_p = ECMA_GET_NON_NULL_POINTER (str_left_value.u.value.value);
ecma_string_t *string2_p = ECMA_GET_NON_NULL_POINTER (str_right_value.u.value.value);
ecma_string_t *string1_p = ecma_get_string_from_completion_value (str_left_value);
ecma_string_t *string2_p = ecma_get_string_from_completion_value (str_right_value);
ecma_string_t *concat_str_p = ecma_concat_ecma_strings (string1_p, string2_p);
@ -148,8 +154,8 @@ opfunc_addition (opcode_t opdata, /**< operation data */
ret_value = do_number_arithmetic (int_data,
dst_var_idx,
number_arithmetic_addition,
prim_left_value.u.value,
prim_right_value.u.value);
ecma_get_completion_value_value (prim_left_value),
ecma_get_completion_value_value (prim_right_value));
}
ECMA_FINALIZE (prim_right_value);
@ -186,8 +192,8 @@ opfunc_substraction (opcode_t opdata, /**< operation data */
ret_value = do_number_arithmetic (int_data,
dst_var_idx,
number_arithmetic_substraction,
left_value.u.value,
right_value.u.value);
ecma_get_completion_value_value (left_value),
ecma_get_completion_value_value (right_value));
ECMA_FINALIZE (right_value);
ECMA_FINALIZE (left_value);
@ -221,8 +227,8 @@ opfunc_multiplication (opcode_t opdata, /**< operation data */
ret_value = do_number_arithmetic (int_data,
dst_var_idx,
number_arithmetic_multiplication,
left_value.u.value,
right_value.u.value);
ecma_get_completion_value_value (left_value),
ecma_get_completion_value_value (right_value));
ECMA_FINALIZE (right_value);
ECMA_FINALIZE (left_value);
@ -256,8 +262,8 @@ opfunc_division (opcode_t opdata, /**< operation data */
ret_value = do_number_arithmetic (int_data,
dst_var_idx,
number_arithmetic_division,
left_value.u.value,
right_value.u.value);
ecma_get_completion_value_value (left_value),
ecma_get_completion_value_value (right_value));
ECMA_FINALIZE (right_value);
ECMA_FINALIZE (left_value);
@ -291,8 +297,8 @@ opfunc_remainder (opcode_t opdata, /**< operation data */
ret_value = do_number_arithmetic (int_data,
dst_var_idx,
number_arithmetic_remainder,
left_value.u.value,
right_value.u.value);
ecma_get_completion_value_value (left_value),
ecma_get_completion_value_value (right_value));
ECMA_FINALIZE (right_value);
ECMA_FINALIZE (left_value);
@ -320,9 +326,9 @@ opfunc_unary_plus (opcode_t opdata, /**< operation data */
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (var_value, get_variable_value (int_data, var_idx, false), ret_value);
ECMA_TRY_CATCH (num_value, ecma_op_to_number (var_value.u.value), ret_value);
ECMA_TRY_CATCH (num_value, ecma_op_to_number (ecma_get_completion_value_value (var_value)), ret_value);
ecma_number_t *var_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (num_value.u.value.value);
ecma_number_t *var_p = ecma_get_number_from_completion_value (num_value);
ret_value = set_variable_value (int_data,
dst_var_idx,
ecma_make_number_value (var_p));
@ -353,10 +359,10 @@ opfunc_unary_minus (opcode_t opdata, /**< operation data */
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (var_value, get_variable_value (int_data, var_idx, false), ret_value);
ECMA_TRY_CATCH (num_value, ecma_op_to_number (var_value.u.value), ret_value);
ECMA_TRY_CATCH (num_value, ecma_op_to_number (ecma_get_completion_value_value (var_value)), ret_value);
ecma_number_t *var_p, *res_p;
var_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (num_value.u.value.value);
var_p = ecma_get_number_from_completion_value (num_value);
res_p = ecma_alloc_number ();
*res_p = ecma_number_negate (*var_p);

32
src/libcoreint/opcodes-ecma-bitwise.c
View File

@ -54,8 +54,8 @@ do_number_bitwise_logic (int_data_t *int_data, /**< interpreter context */
ECMA_TRY_CATCH (num_right_value, ecma_op_to_number (right_value), ret_value);
ecma_number_t *left_p, *right_p;
left_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (num_left_value.u.value.value);
right_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (num_right_value.u.value.value);
left_p = ecma_get_number_from_completion_value (num_left_value);
right_p = ecma_get_number_from_completion_value (num_right_value);
ecma_number_t* res_p = ecma_alloc_number ();
@ -142,8 +142,8 @@ opfunc_b_and (opcode_t opdata, /**< operation data */
ret_value = do_number_bitwise_logic (int_data,
dst_var_idx,
number_bitwise_logic_and,
left_value.u.value,
right_value.u.value);
ecma_get_completion_value_value (left_value),
ecma_get_completion_value_value (right_value));
ECMA_FINALIZE (right_value);
ECMA_FINALIZE (left_value);
@ -177,8 +177,8 @@ opfunc_b_or (opcode_t opdata, /**< operation data */
ret_value = do_number_bitwise_logic (int_data,
dst_var_idx,
number_bitwise_logic_or,
left_value.u.value,
right_value.u.value);
ecma_get_completion_value_value (left_value),
ecma_get_completion_value_value (right_value));
ECMA_FINALIZE (right_value);
ECMA_FINALIZE (left_value);
@ -212,8 +212,8 @@ opfunc_b_xor (opcode_t opdata, /**< operation data */
ret_value = do_number_bitwise_logic (int_data,
dst_var_idx,
number_bitwise_logic_xor,
left_value.u.value,
right_value.u.value);
ecma_get_completion_value_value (left_value),
ecma_get_completion_value_value (right_value));
ECMA_FINALIZE (right_value);
ECMA_FINALIZE (left_value);
@ -247,8 +247,8 @@ opfunc_b_shift_left (opcode_t opdata, /**< operation data */
ret_value = do_number_bitwise_logic (int_data,
dst_var_idx,
number_bitwise_shift_left,
left_value.u.value,
right_value.u.value);
ecma_get_completion_value_value (left_value),
ecma_get_completion_value_value (right_value));
ECMA_FINALIZE (right_value);
ECMA_FINALIZE (left_value);
@ -282,8 +282,8 @@ opfunc_b_shift_right (opcode_t opdata, /**< operation data */
ret_value = do_number_bitwise_logic (int_data,
dst_var_idx,
number_bitwise_shift_right,
left_value.u.value,
right_value.u.value);
ecma_get_completion_value_value (left_value),
ecma_get_completion_value_value (right_value));
ECMA_FINALIZE (right_value);
ECMA_FINALIZE (left_value);
@ -317,8 +317,8 @@ opfunc_b_shift_uright (opcode_t opdata, /**< operation data */
ret_value = do_number_bitwise_logic (int_data,
dst_var_idx,
number_bitwise_shift_uright,
left_value.u.value,
right_value.u.value);
ecma_get_completion_value_value (left_value),
ecma_get_completion_value_value (right_value));
ECMA_FINALIZE (right_value);
ECMA_FINALIZE (left_value);
@ -350,8 +350,8 @@ opfunc_b_not (opcode_t opdata, /**< operation data */
ret_value = do_number_bitwise_logic (int_data,
dst_var_idx,
number_bitwise_not,
right_value.u.value,
right_value.u.value);
ecma_get_completion_value_value (right_value),
ecma_get_completion_value_value (right_value));
ECMA_FINALIZE (right_value);

14
src/libcoreint/opcodes-ecma-equality.c
View File

@ -39,13 +39,14 @@ opfunc_equal_value (opcode_t opdata, /**< operation data */
ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
ECMA_TRY_CATCH (compare_result,
ecma_op_abstract_equality_compare (left_value.u.value, right_value.u.value),
ecma_op_abstract_equality_compare (ecma_get_completion_value_value (left_value),
ecma_get_completion_value_value (right_value)),
ret_value);
JERRY_ASSERT (ecma_is_completion_value_normal_true (compare_result)
|| ecma_is_completion_value_normal_false (compare_result));
ret_value = set_variable_value (int_data, dst_var_idx, compare_result.u.value);
ret_value = set_variable_value (int_data, dst_var_idx, ecma_get_completion_value_value (compare_result));
ECMA_FINALIZE (compare_result);
ECMA_FINALIZE (right_value);
@ -77,7 +78,8 @@ opfunc_not_equal_value (opcode_t opdata, /**< operation data */
ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
ECMA_TRY_CATCH (compare_result,
ecma_op_abstract_equality_compare (left_value.u.value, right_value.u.value),
ecma_op_abstract_equality_compare (ecma_get_completion_value_value (left_value),
ecma_get_completion_value_value (right_value)),
ret_value);
JERRY_ASSERT (ecma_is_completion_value_normal_true (compare_result)
@ -118,7 +120,8 @@ opfunc_equal_value_type (opcode_t opdata, /**< operation data */
ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
bool is_equal = ecma_op_strict_equality_compare (left_value.u.value, right_value.u.value);
bool is_equal = ecma_op_strict_equality_compare (ecma_get_completion_value_value (left_value),
ecma_get_completion_value_value (right_value));
ret_value = set_variable_value (int_data, dst_var_idx, ecma_make_simple_value (is_equal ? ECMA_SIMPLE_VALUE_TRUE
: ECMA_SIMPLE_VALUE_FALSE));
@ -152,7 +155,8 @@ opfunc_not_equal_value_type (opcode_t opdata, /**< operation data */
ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
bool is_equal = ecma_op_strict_equality_compare (left_value.u.value, right_value.u.value);
bool is_equal = ecma_op_strict_equality_compare (ecma_get_completion_value_value (left_value),
ecma_get_completion_value_value (right_value));
ret_value = set_variable_value (int_data, dst_var_idx, ecma_make_simple_value (is_equal ? ECMA_SIMPLE_VALUE_FALSE
: ECMA_SIMPLE_VALUE_TRUE));

56
src/libcoreint/opcodes-ecma-relational.c
View File

@ -39,22 +39,22 @@ opfunc_less_than (opcode_t opdata, /**< operation data */
ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
ECMA_TRY_CATCH (compare_result,
ecma_op_abstract_relational_compare (left_value.u.value,
right_value.u.value,
ecma_op_abstract_relational_compare (ecma_get_completion_value_value (left_value),
ecma_get_completion_value_value (right_value),
true),
ret_value);
ecma_simple_value_t res;
if (ecma_is_value_undefined (compare_result.u.value))
if (ecma_is_value_undefined (ecma_get_completion_value_value (compare_result)))
{
res = ECMA_SIMPLE_VALUE_FALSE;
}
else
{
JERRY_ASSERT (ecma_is_value_boolean (compare_result.u.value));
JERRY_ASSERT (ecma_is_value_boolean (ecma_get_completion_value_value (compare_result)));
res = compare_result.u.value.value;
res = ecma_get_completion_value_value (compare_result).value;
}
ret_value = set_variable_value (int_data, dst_var_idx, ecma_make_simple_value (res));
@ -89,22 +89,22 @@ opfunc_greater_than (opcode_t opdata, /**< operation data */
ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
ECMA_TRY_CATCH (compare_result,
ecma_op_abstract_relational_compare (right_value.u.value,
left_value.u.value,
ecma_op_abstract_relational_compare (ecma_get_completion_value_value (right_value),
ecma_get_completion_value_value (left_value),
false),
ret_value);
ecma_simple_value_t res;
if (ecma_is_value_undefined (compare_result.u.value))
if (ecma_is_value_undefined (ecma_get_completion_value_value (compare_result)))
{
res = ECMA_SIMPLE_VALUE_FALSE;
}
else
{
JERRY_ASSERT (ecma_is_value_boolean (compare_result.u.value));
JERRY_ASSERT (ecma_is_value_boolean (ecma_get_completion_value_value (compare_result)));
res = compare_result.u.value.value;
res = ecma_get_completion_value_value (compare_result).value;
}
ret_value = set_variable_value (int_data, dst_var_idx, ecma_make_simple_value (res));
@ -139,22 +139,22 @@ opfunc_less_or_equal_than (opcode_t opdata, /**< operation data */
ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
ECMA_TRY_CATCH (compare_result,
ecma_op_abstract_relational_compare (right_value.u.value,
left_value.u.value,
ecma_op_abstract_relational_compare (ecma_get_completion_value_value (right_value),
ecma_get_completion_value_value (left_value),
false),
ret_value);
ecma_simple_value_t res;
if (ecma_is_value_undefined (compare_result.u.value))
if (ecma_is_value_undefined (ecma_get_completion_value_value (compare_result)))
{
res = ECMA_SIMPLE_VALUE_FALSE;
}
else
{
JERRY_ASSERT (ecma_is_value_boolean (compare_result.u.value));
JERRY_ASSERT (ecma_is_value_boolean (ecma_get_completion_value_value (compare_result)));
if (compare_result.u.value.value == ECMA_SIMPLE_VALUE_TRUE)
if (ecma_get_completion_value_value (compare_result).value == ECMA_SIMPLE_VALUE_TRUE)
{
res = ECMA_SIMPLE_VALUE_FALSE;
}
@ -196,22 +196,22 @@ opfunc_greater_or_equal_than (opcode_t opdata, /**< operation data */
ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
ECMA_TRY_CATCH (compare_result,
ecma_op_abstract_relational_compare (left_value.u.value,
right_value.u.value,
ecma_op_abstract_relational_compare (ecma_get_completion_value_value (left_value),
ecma_get_completion_value_value (right_value),
true),
ret_value);
ecma_simple_value_t res;
if (ecma_is_value_undefined (compare_result.u.value))
if (ecma_is_value_undefined (ecma_get_completion_value_value (compare_result)))
{
res = ECMA_SIMPLE_VALUE_FALSE;
}
else
{
JERRY_ASSERT (ecma_is_value_boolean (compare_result.u.value));
JERRY_ASSERT (ecma_is_value_boolean (ecma_get_completion_value_value (compare_result)));
if (compare_result.u.value.value == ECMA_SIMPLE_VALUE_TRUE)
if (ecma_get_completion_value_value (compare_result).value == ECMA_SIMPLE_VALUE_TRUE)
{
res = ECMA_SIMPLE_VALUE_FALSE;
}
@ -253,20 +253,20 @@ opfunc_instanceof (opcode_t opdata __unused, /**< operation data */
ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
if (!ecma_is_value_object (right_value.u.value))
if (!ecma_is_value_object (ecma_get_completion_value_value (right_value)))
{
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
ecma_object_t *right_value_obj_p = ECMA_GET_NON_NULL_POINTER (right_value.u.value.value);
ecma_object_t *right_value_obj_p = ecma_get_object_from_completion_value (right_value);
ECMA_TRY_CATCH (is_instance_of,
ecma_op_object_has_instance (right_value_obj_p,
left_value.u.value),
ecma_get_completion_value_value (left_value)),
ret_value);
ret_value = set_variable_value (int_data, dst_idx, is_instance_of.u.value);
ret_value = set_variable_value (int_data, dst_idx, ecma_get_completion_value_value (is_instance_of));
ECMA_FINALIZE (is_instance_of);
}
@ -300,17 +300,17 @@ opfunc_in (opcode_t opdata __unused, /**< operation data */
ECMA_TRY_CATCH (left_value, get_variable_value (int_data, left_var_idx, false), ret_value);
ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
if (!ecma_is_value_object (right_value.u.value))
if (!ecma_is_value_object (ecma_get_completion_value_value (right_value)))
{
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
ECMA_TRY_CATCH (str_left_value, ecma_op_to_string (left_value.u.value), ret_value);
ECMA_TRY_CATCH (str_left_value, ecma_op_to_string (ecma_get_completion_value_value (left_value)), ret_value);
ecma_simple_value_t is_in = ECMA_SIMPLE_VALUE_UNDEFINED;
ecma_string_t *left_value_prop_name_p = ECMA_GET_NON_NULL_POINTER (str_left_value.u.value.value);
ecma_object_t *right_value_obj_p = ECMA_GET_NON_NULL_POINTER (right_value.u.value.value);
ecma_string_t *left_value_prop_name_p = ecma_get_string_from_completion_value (str_left_value);
ecma_object_t *right_value_obj_p = ecma_get_object_from_completion_value (right_value);
if (ecma_op_object_has_property (right_value_obj_p, left_value_prop_name_p))
{

2
src/libcoreint/opcodes-ecma-try-catch-finally.c
View File

@ -73,7 +73,7 @@ opfunc_try (opcode_t opdata, /**< operation data */
JERRY_ASSERT (ecma_is_completion_value_empty (completion));
completion = ecma_op_set_mutable_binding (catch_env_p,
catch_exc_var_name_str_p,
try_completion.u.value,
ecma_get_completion_value_value (try_completion),
false);
JERRY_ASSERT (ecma_is_completion_value_empty (completion));

2
src/libcoreint/opcodes-native-call.c
View File

@ -123,7 +123,7 @@ opfunc_native_call (opcode_t opdata, /**< operation data */
ecma_op_to_string (arg_values[0]),
ret_value);
ecma_string_t *str_p = ECMA_GET_NON_NULL_POINTER (str_value.u.value.value);
ecma_string_t *str_p = ecma_get_string_from_completion_value (str_value);
int32_t chars = ecma_string_get_length (str_p);
JERRY_ASSERT (chars >= 0);

2
src/libcoreint/opcodes-varg.c
View File

@ -54,7 +54,7 @@ fill_varg_list (int_data_t *int_data, /**< interpreter context */
if (ecma_is_completion_value_normal (get_arg_completion))
{
arg_values[arg_index] = get_arg_completion.u.value;
arg_values[arg_index] = ecma_get_completion_value_value (get_arg_completion);
}
else
{

148
src/libcoreint/opcodes.c
View File

@ -141,9 +141,10 @@ opfunc_assignment (opcode_t opdata, /**< operation data */
{
JERRY_ASSERT (ecma_is_completion_value_normal (get_value_completion));
ecma_value_t value_to_assign = ecma_get_completion_value_value (get_value_completion);
ecma_completion_value_t assignment_completion_value = set_variable_value (int_data,
dst_var_idx,
get_value_completion.u.value);
value_to_assign);
ecma_free_completion_value (get_value_completion);
@ -172,12 +173,12 @@ opfunc_pre_incr (opcode_t opdata, /**< operation data */
// 1., 2., 3.
ECMA_TRY_CATCH (old_value, get_variable_value (int_data, incr_var_idx, true), ret_value);
ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (old_value.u.value), ret_value);
ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (ecma_get_completion_value_value (old_value)), ret_value);
// 4.
ecma_number_t* new_num_p = ecma_alloc_number ();
ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (old_num_value.u.value.value);
ecma_number_t* old_num_p = ecma_get_number_from_completion_value (old_num_value);
*new_num_p = ecma_number_add (*old_num_p, ECMA_NUMBER_ONE);
ecma_value_t new_num_value = ecma_make_number_value (new_num_p);
@ -222,12 +223,12 @@ opfunc_pre_decr (opcode_t opdata, /**< operation data */
// 1., 2., 3.
ECMA_TRY_CATCH (old_value, get_variable_value (int_data, decr_var_idx, true), ret_value);
ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (old_value.u.value), ret_value);
ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (ecma_get_completion_value_value (old_value)), ret_value);
// 4.
ecma_number_t* new_num_p = ecma_alloc_number ();
ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (old_num_value.u.value.value);
ecma_number_t* old_num_p = ecma_get_number_from_completion_value (old_num_value);
*new_num_p = ecma_number_substract (*old_num_p, ECMA_NUMBER_ONE);
ecma_value_t new_num_value = ecma_make_number_value (new_num_p);
@ -272,12 +273,12 @@ opfunc_post_incr (opcode_t opdata, /**< operation data */
// 1., 2., 3.
ECMA_TRY_CATCH (old_value, get_variable_value (int_data, incr_var_idx, true), ret_value);
ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (old_value.u.value), ret_value);
ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (ecma_get_completion_value_value (old_value)), ret_value);
// 4.
ecma_number_t* new_num_p = ecma_alloc_number ();
ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (old_num_value.u.value.value);
ecma_number_t* old_num_p = ecma_get_number_from_completion_value (old_num_value);
*new_num_p = ecma_number_add (*old_num_p, ECMA_NUMBER_ONE);
// 5.
@ -290,7 +291,7 @@ opfunc_post_incr (opcode_t opdata, /**< operation data */
// assignment of operator result to register variable
ecma_completion_value_t reg_assignment_res = set_variable_value (int_data,
dst_var_idx,
old_num_value.u.value);
ecma_get_completion_value_value (old_num_value));
JERRY_ASSERT (ecma_is_completion_value_empty (reg_assignment_res));
ECMA_FINALIZE (old_num_value);
@ -320,12 +321,12 @@ opfunc_post_decr (opcode_t opdata, /**< operation data */
// 1., 2., 3.
ECMA_TRY_CATCH (old_value, get_variable_value (int_data, decr_var_idx, true), ret_value);
ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (old_value.u.value), ret_value);
ECMA_TRY_CATCH (old_num_value, ecma_op_to_number (ecma_get_completion_value_value (old_value)), ret_value);
// 4.
ecma_number_t* new_num_p = ecma_alloc_number ();
ecma_number_t* old_num_p = (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (old_num_value.u.value.value);
ecma_number_t* old_num_p = ecma_get_number_from_completion_value (old_num_value);
*new_num_p = ecma_number_substract (*old_num_p, ECMA_NUMBER_ONE);
// 5.
@ -338,7 +339,7 @@ opfunc_post_decr (opcode_t opdata, /**< operation data */
// assignment of operator result to register variable
ecma_completion_value_t reg_assignment_res = set_variable_value (int_data,
dst_var_idx,
old_num_value.u.value);
ecma_get_completion_value_value (old_num_value));
JERRY_ASSERT (ecma_is_completion_value_empty (reg_assignment_res));
ECMA_FINALIZE (old_num_value);
@ -629,19 +630,24 @@ opfunc_call_n (opcode_t opdata, /**< operation data */
}
JERRY_ASSERT (ecma_is_completion_value_normal (this_value));
if (!ecma_op_is_callable (func_value.u.value))
if (!ecma_op_is_callable (ecma_get_completion_value_value (func_value)))
{
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
ecma_object_t *func_obj_p = ECMA_GET_NON_NULL_POINTER (func_value.u.value.value);
ecma_object_t *func_obj_p = ecma_get_object_from_completion_value (func_value);
ECMA_TRY_CATCH (call_completion,
ecma_op_function_call (func_obj_p, this_value.u.value, arg_values, args_number),
ecma_op_function_call (func_obj_p,
ecma_get_completion_value_value (this_value),
arg_values,
args_number),
ret_value);
ret_value = set_variable_value (int_data, lhs_var_idx, call_completion.u.value);
ret_value = set_variable_value (int_data,
lhs_var_idx,
ecma_get_completion_value_value (call_completion));
ECMA_FINALIZE (call_completion);
@ -701,13 +707,13 @@ opfunc_construct_n (opcode_t opdata, /**< operation data */
{
JERRY_ASSERT (args_read == args_number);
if (!ecma_is_constructor (constructor_value.u.value))
if (!ecma_is_constructor (ecma_get_completion_value_value (constructor_value)))
{
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
ecma_object_t *constructor_obj_p = ECMA_GET_NON_NULL_POINTER (constructor_value.u.value.value);
ecma_object_t *constructor_obj_p = ecma_get_object_from_completion_value (constructor_value);
ECMA_TRY_CATCH (construction_completion,
ecma_op_function_construct (constructor_obj_p,
@ -715,7 +721,7 @@ opfunc_construct_n (opcode_t opdata, /**< operation data */
args_number),
ret_value);
ret_value = set_variable_value (int_data, lhs_var_idx, construction_completion.u.value);
ret_value = set_variable_value (int_data, lhs_var_idx, ecma_get_completion_value_value (construction_completion));
ECMA_FINALIZE (construction_completion);
}
@ -778,7 +784,7 @@ opfunc_array_decl (opcode_t opdata, /**< operation data */
ret_value = set_variable_value (int_data,
lhs_var_idx,
array_obj_value.u.value);
ecma_get_completion_value_value (array_obj_value));
ECMA_FINALIZE (array_obj_value);
}
@ -856,12 +862,12 @@ opfunc_obj_decl (opcode_t opdata, /**< operation data */
false),
ret_value);
ECMA_TRY_CATCH (prop_name_str_value,
ecma_op_to_string (prop_name_value.u.value),
ecma_op_to_string (ecma_get_completion_value_value (prop_name_value)),
ret_value);
bool is_throw_syntax_error = false;
ecma_string_t *prop_name_string_p = ECMA_GET_NON_NULL_POINTER (prop_name_str_value.u.value.value);
ecma_string_t *prop_name_string_p = ecma_get_string_from_completion_value (prop_name_str_value);
ecma_property_t *previous_p = ecma_op_object_get_own_property (obj_p, prop_name_string_p);
const bool is_previous_undefined = (previous_p == NULL);
@ -883,7 +889,7 @@ opfunc_obj_decl (opcode_t opdata, /**< operation data */
if (type == OPCODE_META_TYPE_VARG_PROP_DATA)
{
prop_desc.is_value_defined = true;
prop_desc.value = value_for_prop_desc.u.value;
prop_desc.value = ecma_get_completion_value_value (value_for_prop_desc);
prop_desc.is_writable_defined = true;
prop_desc.writable = ECMA_PROPERTY_WRITABLE;
@ -898,10 +904,8 @@ opfunc_obj_decl (opcode_t opdata, /**< operation data */
}
else if (type == OPCODE_META_TYPE_VARG_PROP_GETTER)
{
JERRY_ASSERT (ecma_is_value_object (value_for_prop_desc.u.value));
prop_desc.is_get_defined = true;
prop_desc.get_p = ECMA_GET_NON_NULL_POINTER (value_for_prop_desc.u.value.value);
prop_desc.get_p = ecma_get_object_from_completion_value (value_for_prop_desc);
if (!is_previous_undefined
&& is_previous_data_desc)
@ -911,10 +915,8 @@ opfunc_obj_decl (opcode_t opdata, /**< operation data */
}
else
{
JERRY_ASSERT (ecma_is_value_object (value_for_prop_desc.u.value));
prop_desc.is_set_defined = true;
prop_desc.set_p = ECMA_GET_NON_NULL_POINTER (value_for_prop_desc.u.value.value);
prop_desc.set_p = ecma_get_object_from_completion_value (value_for_prop_desc);
if (!is_previous_undefined
&& is_previous_data_desc)
@ -1003,7 +1005,7 @@ opfunc_retval (opcode_t opdata __unused, /**< operation data */
ECMA_TRY_CATCH (expr_val, get_variable_value (int_data, opdata.data.retval.ret_value, false), ret_value);
ret_value = ecma_make_return_completion_value (ecma_copy_value (expr_val.u.value, true));
ret_value = ecma_make_return_completion_value (ecma_copy_value (ecma_get_completion_value_value (expr_val), true));
ECMA_FINALIZE (expr_val);
@ -1031,19 +1033,27 @@ opfunc_prop_getter (opcode_t opdata __unused, /**< operation data */
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (base_value, get_variable_value (int_data, base_var_idx, false), ret_value);
ECMA_TRY_CATCH (prop_name_value, get_variable_value (int_data, prop_name_var_idx, false), ret_value);
ECMA_TRY_CATCH (check_coercible_ret, ecma_op_check_object_coercible (base_value.u.value), ret_value);
ECMA_TRY_CATCH (prop_name_str_value, ecma_op_to_string (prop_name_value.u.value), ret_value);
ECMA_TRY_CATCH (base_value,
get_variable_value (int_data, base_var_idx, false),
ret_value);
ECMA_TRY_CATCH (prop_name_value,
get_variable_value (int_data, prop_name_var_idx, false),
ret_value);
ECMA_TRY_CATCH (check_coercible_ret,
ecma_op_check_object_coercible (ecma_get_completion_value_value (base_value)),
ret_value);
ECMA_TRY_CATCH (prop_name_str_value,
ecma_op_to_string (ecma_get_completion_value_value (prop_name_value)),
ret_value);
ecma_string_t *prop_name_string_p = ECMA_GET_NON_NULL_POINTER (prop_name_str_value.u.value.value);
ecma_reference_t ref = ecma_make_reference (base_value.u.value,
ecma_string_t *prop_name_string_p = ecma_get_string_from_completion_value (prop_name_str_value);
ecma_reference_t ref = ecma_make_reference (ecma_get_completion_value_value (base_value),
prop_name_string_p,
int_data->is_strict);
ECMA_TRY_CATCH (prop_value, ecma_op_get_value_object_base (ref), ret_value);
ret_value = set_variable_value (int_data, lhs_var_idx, prop_value.u.value);
ret_value = set_variable_value (int_data, lhs_var_idx, ecma_get_completion_value_value (prop_value));
ECMA_FINALIZE (prop_value);
@ -1078,18 +1088,26 @@ opfunc_prop_setter (opcode_t opdata __unused, /**< operation data */
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (base_value, get_variable_value (int_data, base_var_idx, false), ret_value);
ECMA_TRY_CATCH (prop_name_value, get_variable_value (int_data, prop_name_var_idx, false), ret_value);
ECMA_TRY_CATCH (check_coercible_ret, ecma_op_check_object_coercible (base_value.u.value), ret_value);
ECMA_TRY_CATCH (prop_name_str_value, ecma_op_to_string (prop_name_value.u.value), ret_value);
ECMA_TRY_CATCH (base_value,
get_variable_value (int_data, base_var_idx, false),
ret_value);
ECMA_TRY_CATCH (prop_name_value,
get_variable_value (int_data, prop_name_var_idx, false),
ret_value);
ECMA_TRY_CATCH (check_coercible_ret,
ecma_op_check_object_coercible (ecma_get_completion_value_value (base_value)),
ret_value);
ECMA_TRY_CATCH (prop_name_str_value,
ecma_op_to_string (ecma_get_completion_value_value (prop_name_value)),
ret_value);
ecma_string_t *prop_name_string_p = ECMA_GET_NON_NULL_POINTER (prop_name_str_value.u.value.value);
ecma_reference_t ref = ecma_make_reference (base_value.u.value,
ecma_string_t *prop_name_string_p = ecma_get_string_from_completion_value (prop_name_str_value);
ecma_reference_t ref = ecma_make_reference (ecma_get_completion_value_value (base_value),
prop_name_string_p,
int_data->is_strict);
ECMA_TRY_CATCH (rhs_value, get_variable_value (int_data, rhs_var_idx, false), ret_value);
ret_value = ecma_op_put_value_object_base (ref, rhs_value.u.value);
ret_value = ecma_op_put_value_object_base (ref, ecma_get_completion_value_value (rhs_value));
ECMA_FINALIZE (rhs_value);
ecma_free_reference (ref);
@ -1147,9 +1165,9 @@ opfunc_logical_not (opcode_t opdata, /**< operation data */
ECMA_TRY_CATCH (right_value, get_variable_value (int_data, right_var_idx, false), ret_value);
ecma_simple_value_t old_value = ECMA_SIMPLE_VALUE_TRUE;
ecma_completion_value_t to_bool_value = ecma_op_to_boolean (right_value.u.value);
ecma_completion_value_t to_bool_value = ecma_op_to_boolean (ecma_get_completion_value_value (right_value));
if (ecma_is_value_true (to_bool_value.u.value))
if (ecma_is_value_true (ecma_get_completion_value_value (to_bool_value)))
{
old_value = ECMA_SIMPLE_VALUE_FALSE;
}
@ -1212,10 +1230,10 @@ opfunc_with (opcode_t opdata, /**< operation data */
false),
ret_value);
ECMA_TRY_CATCH (obj_expr_value,
ecma_op_to_object (expr_value.u.value),
ecma_op_to_object (ecma_get_completion_value_value (expr_value)),
ret_value);
ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (obj_expr_value.u.value.value);
ecma_object_t *obj_p = ecma_get_object_from_completion_value (obj_expr_value);
ecma_object_t *old_env_p = int_data->lex_env_p;
ecma_object_t *new_env_p = ecma_create_object_lex_env (old_env_p,
@ -1276,7 +1294,7 @@ opfunc_throw (opcode_t opdata, /**< operation data */
false),
ret_value);
ret_value = ecma_make_throw_completion_value (ecma_copy_value (var_value.u.value, true));
ret_value = ecma_make_throw_completion_value (ecma_copy_value (ecma_get_completion_value_value (var_value), true));
ECMA_FINALIZE (var_value);
@ -1352,7 +1370,7 @@ opfunc_typeof (opcode_t opdata, /**< operation data */
obj_var_idx),
ret_value);
ecma_value_t typeof_arg = typeof_evaluate_arg_completion.u.value;
ecma_value_t typeof_arg = ecma_get_completion_value_value (typeof_evaluate_arg_completion);
ecma_string_t *type_str_p = NULL;
@ -1450,7 +1468,7 @@ opfunc_delete_var (opcode_t opdata, /**< operation data */
ECMA_GET_NON_NULL_POINTER (ref.referenced_name_cp)),
ret_value);
ret_value = set_variable_value (int_data, dst_var_idx, delete_completion.u.value);
ret_value = set_variable_value (int_data, dst_var_idx, ecma_get_completion_value_value (delete_completion));
ECMA_FINALIZE (delete_completion);
}
@ -1484,15 +1502,23 @@ opfunc_delete_prop (opcode_t opdata, /**< operation data */
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (base_value, get_variable_value (int_data, base_var_idx, false), ret_value);
ECMA_TRY_CATCH (name_value, get_variable_value (int_data, name_var_idx, false), ret_value);
ECMA_TRY_CATCH (check_coercible_ret, ecma_op_check_object_coercible (base_value.u.value), ret_value);
ECMA_TRY_CATCH (str_name_value, ecma_op_to_string (name_value.u.value), ret_value);
ECMA_TRY_CATCH (base_value,
get_variable_value (int_data, base_var_idx, false),
ret_value);
ECMA_TRY_CATCH (name_value,
get_variable_value (int_data, name_var_idx, false),
ret_value);
ECMA_TRY_CATCH (check_coercible_ret,
ecma_op_check_object_coercible (ecma_get_completion_value_value (base_value)),
ret_value);
ECMA_TRY_CATCH (str_name_value,
ecma_op_to_string (ecma_get_completion_value_value (name_value)),
ret_value);
JERRY_ASSERT (ecma_is_value_string (str_name_value.u.value));
ecma_string_t *name_string_p = ECMA_GET_NON_NULL_POINTER (str_name_value.u.value.value);
JERRY_ASSERT (ecma_is_value_string (ecma_get_completion_value_value (str_name_value)));
ecma_string_t *name_string_p = ecma_get_string_from_completion_value (str_name_value);
if (ecma_is_value_undefined (base_value.u.value))
if (ecma_is_value_undefined (ecma_get_completion_value_value (base_value)))
{
if (int_data->is_strict)
{
@ -1506,17 +1532,17 @@ opfunc_delete_prop (opcode_t opdata, /**< operation data */
}
else
{
ECMA_TRY_CATCH (obj_value, ecma_op_to_object (base_value.u.value), ret_value);
ECMA_TRY_CATCH (obj_value, ecma_op_to_object (ecma_get_completion_value_value (base_value)), ret_value);
JERRY_ASSERT (ecma_is_value_object (obj_value.u.value));
ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (obj_value.u.value.value);
JERRY_ASSERT (ecma_is_value_object (ecma_get_completion_value_value (obj_value)));
ecma_object_t *obj_p = ecma_get_object_from_completion_value (obj_value);
JERRY_ASSERT (!ecma_is_lexical_environment (obj_p));
ECMA_TRY_CATCH (delete_op_completion,
ecma_op_object_delete (obj_p, name_string_p, int_data->is_strict),
ret_value);
ret_value = set_variable_value (int_data, dst_var_idx, delete_op_completion.u.value);
ret_value = set_variable_value (int_data, dst_var_idx, ecma_get_completion_value_value (delete_op_completion));
ECMA_FINALIZE (delete_op_completion);
ECMA_FINALIZE (obj_value);

12
src/libecmabuiltins/ecma-builtin-error-prototype.c
View File

@ -82,7 +82,7 @@ ecma_builtin_error_prototype_object_to_string (ecma_value_t this) /**< this argu
}
else
{
name_to_str_completion = ecma_op_to_string (name_get_completion.u.value);
name_to_str_completion = ecma_op_to_string (ecma_get_completion_value_value (name_get_completion));
}
if (unlikely (!ecma_is_completion_value_normal (name_to_str_completion)))
@ -107,7 +107,7 @@ ecma_builtin_error_prototype_object_to_string (ecma_value_t this) /**< this argu
}
else
{
msg_to_str_completion = ecma_op_to_string (msg_get_completion.u.value);
msg_to_str_completion = ecma_op_to_string (ecma_get_completion_value_value (msg_get_completion));
}
if (unlikely (!ecma_is_completion_value_normal (msg_to_str_completion)))
@ -116,11 +116,11 @@ ecma_builtin_error_prototype_object_to_string (ecma_value_t this) /**< this argu
}
else
{
JERRY_ASSERT (ecma_is_value_string (name_to_str_completion.u.value));
JERRY_ASSERT (ecma_is_value_string (msg_to_str_completion.u.value));
JERRY_ASSERT (ecma_is_value_string (ecma_get_completion_value_value (name_to_str_completion)));
JERRY_ASSERT (ecma_is_value_string (ecma_get_completion_value_value (msg_to_str_completion)));
ecma_string_t *name_string_p = ECMA_GET_NON_NULL_POINTER (name_to_str_completion.u.value.value);
ecma_string_t *msg_string_p = ECMA_GET_NON_NULL_POINTER (msg_to_str_completion.u.value.value);
ecma_string_t *name_string_p = ecma_get_string_from_completion_value (name_to_str_completion);
ecma_string_t *msg_string_p = ecma_get_string_from_completion_value (msg_to_str_completion);
ecma_string_t *ret_str_p;

2
src/libecmabuiltins/ecma-builtin-error.c
View File

@ -63,7 +63,7 @@ ecma_builtin_error_dispatch_call (ecma_value_t *arguments_list_p, /**< arguments
ecma_op_to_string (arguments_list_p[0]),
ret_value);
ecma_string_t *message_string_p = ECMA_GET_NON_NULL_POINTER (msg_to_str_completion.u.value.value);
ecma_string_t *message_string_p = ecma_get_string_from_completion_value (msg_to_str_completion);
ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_COMMON,
message_string_p);
ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));

2
src/libecmabuiltins/ecma-builtin-evalerror.c
View File

@ -63,7 +63,7 @@ ecma_builtin_eval_error_dispatch_call (ecma_value_t *arguments_list_p, /**< argu
ecma_op_to_string (arguments_list_p[0]),
ret_value);
ecma_string_t *message_string_p = ECMA_GET_NON_NULL_POINTER (msg_to_str_completion.u.value.value);
ecma_string_t *message_string_p = ecma_get_string_from_completion_value (msg_to_str_completion);
ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_EVAL,
message_string_p);
ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));

4
src/libecmabuiltins/ecma-builtin-global.c
View File

@ -105,7 +105,7 @@ ecma_builtin_global_object_is_nan (ecma_value_t this_arg __unused, /**< this arg
ECMA_TRY_CATCH (num_value, ecma_op_to_number (arg), ret_value);
ecma_number_t *num_p = ECMA_GET_NON_NULL_POINTER (num_value.u.value.value);
ecma_number_t *num_p = ecma_get_number_from_completion_value (num_value);
bool is_nan = ecma_number_is_nan (*num_p);
@ -134,7 +134,7 @@ ecma_builtin_global_object_is_finite (ecma_value_t this_arg __unused, /**< this
ECMA_TRY_CATCH (num_value, ecma_op_to_number (arg), ret_value);
ecma_number_t *num_p = ECMA_GET_NON_NULL_POINTER (num_value.u.value.value);
ecma_number_t *num_p = ecma_get_number_from_completion_value (num_value);
bool is_finite = !(ecma_number_is_nan (*num_p)
|| ecma_number_is_infinity (*num_p));

18
src/libecmabuiltins/ecma-builtin-math.c
View File

@ -66,7 +66,7 @@ ecma_builtin_math_object_abs (ecma_value_t this_arg __unused, /**< 'this' argume
ecma_number_t *num_p = ecma_alloc_number ();
const ecma_number_t arg_num = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_num_value.u.value.value);
const ecma_number_t arg_num = *ecma_get_number_from_completion_value (arg_num_value);
if (ecma_number_is_nan (arg_num))
{
@ -202,7 +202,7 @@ ecma_builtin_math_object_exp (ecma_value_t this_arg __unused, /**< 'this' argume
ecma_number_t *num_p = ecma_alloc_number ();
const ecma_number_t arg_num = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_num_value.u.value.value);
const ecma_number_t arg_num = *ecma_get_number_from_completion_value (arg_num_value);
if (ecma_number_is_nan (arg_num))
{
@ -272,7 +272,7 @@ ecma_builtin_math_object_log (ecma_value_t this_arg __unused, /**< 'this' argume
ecma_number_t *num_p = ecma_alloc_number ();
const ecma_number_t arg_num = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_num_value.u.value.value);
const ecma_number_t arg_num = *ecma_get_number_from_completion_value (arg_num_value);
if (ecma_number_is_nan (arg_num))
{
@ -332,7 +332,7 @@ ecma_builtin_math_object_max (ecma_value_t this_arg __unused, /**< 'this' argume
if (!is_just_convert)
{
ecma_number_t arg_num = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_num_value.u.value.value);
ecma_number_t arg_num = *ecma_get_number_from_completion_value (arg_num_value);
if (unlikely (ecma_number_is_nan (arg_num)))
{
@ -423,7 +423,7 @@ ecma_builtin_math_object_min (ecma_value_t this_arg __unused, /**< 'this' argume
if (!is_just_convert)
{
ecma_number_t arg_num = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_num_value.u.value.value);
ecma_number_t arg_num = *ecma_get_number_from_completion_value (arg_num_value);
if (unlikely (ecma_number_is_nan (arg_num)))
{
@ -509,8 +509,8 @@ ecma_builtin_math_object_pow (ecma_value_t this_arg __unused, /**< 'this' argume
ecma_number_t *num_p = ecma_alloc_number ();
const ecma_number_t x = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg1_num_value.u.value.value);
const ecma_number_t y = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg2_num_value.u.value.value);
const ecma_number_t x = *ecma_get_number_from_completion_value (arg1_num_value);
const ecma_number_t y = *ecma_get_number_from_completion_value (arg2_num_value);
if (ecma_number_is_nan (y)
|| (ecma_number_is_nan (x)
@ -787,7 +787,7 @@ ecma_builtin_math_object_round (ecma_value_t this_arg __unused, /**< 'this' argu
ecma_number_t *num_p = ecma_alloc_number ();
const ecma_number_t arg_num = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_num_value.u.value.value);
const ecma_number_t arg_num = *ecma_get_number_from_completion_value (arg_num_value);
if (ecma_number_is_nan (arg_num)
|| ecma_number_is_zero (arg_num)
@ -859,7 +859,7 @@ ecma_builtin_math_object_sqrt (ecma_value_t this_arg __unused, /**< 'this' argum
ecma_op_to_number (arg),
ret_value);
const ecma_number_t arg_num = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (arg_num_value.u.value.value);
const ecma_number_t arg_num = *ecma_get_number_from_completion_value (arg_num_value);
ecma_number_t ret_num;
if (ecma_number_is_nan (arg_num)

4
src/libecmabuiltins/ecma-builtin-object-prototype.c
View File

@ -73,9 +73,9 @@ ecma_builtin_object_prototype_object_to_string (ecma_value_t this) /**< this arg
return obj_this;
}
JERRY_ASSERT (ecma_is_value_object (obj_this.u.value));
JERRY_ASSERT (ecma_is_value_object (ecma_get_completion_value_value (obj_this)));
ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (obj_this.u.value.value);
ecma_object_t *obj_p = ecma_get_object_from_completion_value (obj_this);
ecma_property_t *class_prop_p = ecma_get_internal_property (obj_p,
ECMA_INTERNAL_PROPERTY_CLASS);

4
src/libecmabuiltins/ecma-builtin-object.c
View File

@ -96,7 +96,7 @@ ecma_builtin_object_dispatch_construct (ecma_value_t *arguments_list_p, /**< arg
}
else
{
return ecma_make_normal_completion_value (new_obj_value.u.value);
return ecma_make_normal_completion_value (ecma_get_completion_value_value (new_obj_value));
}
}
} /* ecma_builtin_object_dispatch_construct */
@ -325,7 +325,7 @@ ecma_builtin_object_object_define_property (ecma_value_t this_arg __unused, /**<
ecma_op_to_string (arg2),
ret_value);
ecma_string_t *name_str_p = ECMA_GET_NON_NULL_POINTER (name_str_value.u.value.value);
ecma_string_t *name_str_p = ecma_get_string_from_completion_value (name_str_value);
ecma_property_descriptor_t prop_desc;

2
src/libecmabuiltins/ecma-builtin-rangeerror.c
View File

@ -63,7 +63,7 @@ ecma_builtin_range_error_dispatch_call (ecma_value_t *arguments_list_p, /**< arg
ecma_op_to_string (arguments_list_p[0]),
ret_value);
ecma_string_t *message_string_p = ECMA_GET_NON_NULL_POINTER (msg_to_str_completion.u.value.value);
ecma_string_t *message_string_p = ecma_get_string_from_completion_value (msg_to_str_completion);
ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_RANGE,
message_string_p);
ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));

2
src/libecmabuiltins/ecma-builtin-referenceerror.c
View File

@ -63,7 +63,7 @@ ecma_builtin_reference_error_dispatch_call (ecma_value_t *arguments_list_p, /**<
ecma_op_to_string (arguments_list_p[0]),
ret_value);
ecma_string_t *message_string_p = ECMA_GET_NON_NULL_POINTER (msg_to_str_completion.u.value.value);
ecma_string_t *message_string_p = ecma_get_string_from_completion_value (msg_to_str_completion);
ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_REFERENCE,
message_string_p);
ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));

4
src/libecmabuiltins/ecma-builtin-string.c
View File

@ -74,8 +74,8 @@ ecma_builtin_string_object_from_char_code (ecma_value_t this_arg __unused, /**<
ecma_op_to_number (args[arg_index]),
ret_value);
JERRY_ASSERT (ecma_is_value_number (arg_num_value.u.value));
ecma_number_t *arg_num_p = ECMA_GET_NON_NULL_POINTER (arg_num_value.u.value.value);
JERRY_ASSERT (ecma_is_value_number (ecma_get_completion_value_value (arg_num_value)));
ecma_number_t *arg_num_p = ecma_get_number_from_completion_value (arg_num_value);
uint32_t uint32_char_code = ecma_number_to_uint32 (*arg_num_p);
uint16_t uint16_char_code = (uint16_t) uint32_char_code;

2
src/libecmabuiltins/ecma-builtin-syntaxerror.c
View File

@ -63,7 +63,7 @@ ecma_builtin_syntax_error_dispatch_call (ecma_value_t *arguments_list_p, /**< ar
ecma_op_to_string (arguments_list_p[0]),
ret_value);
ecma_string_t *message_string_p = ECMA_GET_NON_NULL_POINTER (msg_to_str_completion.u.value.value);
ecma_string_t *message_string_p = ecma_get_string_from_completion_value (msg_to_str_completion);
ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_SYNTAX,
message_string_p);
ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));

2
src/libecmabuiltins/ecma-builtin-typeerror.c
View File

@ -63,7 +63,7 @@ ecma_builtin_type_error_dispatch_call (ecma_value_t *arguments_list_p, /**< argu
ecma_op_to_string (arguments_list_p[0]),
ret_value);
ecma_string_t *message_string_p = ECMA_GET_NON_NULL_POINTER (msg_to_str_completion.u.value.value);
ecma_string_t *message_string_p = ecma_get_string_from_completion_value (msg_to_str_completion);
ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_TYPE,
message_string_p);
ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));

2
src/libecmabuiltins/ecma-builtin-urierror.c
View File

@ -63,7 +63,7 @@ ecma_builtin_uri_error_dispatch_call (ecma_value_t *arguments_list_p, /**< argum
ecma_op_to_string (arguments_list_p[0]),
ret_value);
ecma_string_t *message_string_p = ECMA_GET_NON_NULL_POINTER (msg_to_str_completion.u.value.value);
ecma_string_t *message_string_p = ecma_get_string_from_completion_value (msg_to_str_completion);
ecma_object_t *new_error_object_p = ecma_new_standard_error_with_message (ECMA_ERROR_URI,
message_string_p);
ret_value = ecma_make_normal_completion_value (ecma_make_object_value (new_error_object_p));

94
src/libecmaobjects/ecma-helpers-value.c
View File

@ -278,6 +278,45 @@ ecma_make_object_value (ecma_object_t* object_p) /**< object to reference in val
return object_value;
} /* ecma_make_object_value */
/**
* Get pointer to ecma-number from ecma-value
*
* @return the pointer
*/
ecma_number_t* __attribute_const__
ecma_get_number_from_value (ecma_value_t value) /**< ecma-value */
{
JERRY_ASSERT (value.value_type == ECMA_TYPE_NUMBER);
return (ecma_number_t*) ECMA_GET_NON_NULL_POINTER (value.value);
} /* ecma_get_number_from_value */
/**
* Get pointer to ecma-string from ecma-value
*
* @return the pointer
*/
ecma_string_t* __attribute_const__
ecma_get_string_from_value (ecma_value_t value) /**< ecma-value */
{
JERRY_ASSERT (value.value_type == ECMA_TYPE_STRING);
return (ecma_string_t*) ECMA_GET_NON_NULL_POINTER (value.value);
} /* ecma_get_string_from_value */
/**
* Get pointer to ecma-object from ecma-value
*
* @return the pointer
*/
ecma_object_t* __attribute_const__
ecma_get_object_from_value (ecma_value_t value) /**< ecma-value */
{
JERRY_ASSERT (value.value_type == ECMA_TYPE_OBJECT);
return (ecma_object_t*) ECMA_GET_NON_NULL_POINTER (value.value);
} /* ecma_get_object_from_value */
/**
* Copy ecma-value.
*
@ -589,6 +628,61 @@ ecma_make_meta_completion_value (void)
ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY));
} /* ecma_make_meta_completion_value */
/**
* Get ecma-value from specified completion value
*
* @return ecma-value
*/
ecma_value_t __attribute_const__
ecma_get_completion_value_value (ecma_completion_value_t completion_value) /**< completion value */
{
const ecma_completion_type_t type = completion_value.type;
const bool is_type_ok = (type == ECMA_COMPLETION_TYPE_NORMAL
#ifdef CONFIG_ECMA_EXCEPTION_SUPPORT
|| type == ECMA_COMPLETION_TYPE_THROW
#endif /* CONFIG_ECMA_EXCEPTION_SUPPORT */
|| type == ECMA_COMPLETION_TYPE_RETURN
|| type == ECMA_COMPLETION_TYPE_EXIT);
JERRY_ASSERT (is_type_ok);
return completion_value.u.value;
} /* ecma_get_completion_value_value */
/**
* Get pointer to ecma-number from completion value
*
* @return pointer
*/
ecma_number_t* __attribute_const__
ecma_get_number_from_completion_value (ecma_completion_value_t completion_value) /**< completion value */
{
return ecma_get_number_from_value (ecma_get_completion_value_value (completion_value));
} /* ecma_get_number_from_completion_value */
/**
* Get pointer to ecma-string from completion value
*
* @return pointer
*/
ecma_string_t* __attribute_const__
ecma_get_string_from_completion_value (ecma_completion_value_t completion_value) /**< completion value */
{
return ecma_get_string_from_value (ecma_get_completion_value_value (completion_value));
} /* ecma_get_string_from_completion_value */
/**
* Get pointer to ecma-object from completion value
*
* @return pointer
*/
ecma_object_t* __attribute_const__
ecma_get_object_from_completion_value (ecma_completion_value_t completion_value) /**< completion value */
{
return ecma_get_object_from_value (ecma_get_completion_value_value (completion_value));
} /* ecma_get_object_from_completion_value */
/**
* Copy ecma-completion value.
*

10
src/libecmaobjects/ecma-helpers.h
View File

@ -77,6 +77,9 @@ extern ecma_value_t ecma_make_simple_value (ecma_simple_value_t value);
extern ecma_value_t ecma_make_number_value (ecma_number_t* num_p);
extern ecma_value_t ecma_make_string_value (ecma_string_t* ecma_string_p);
extern ecma_value_t ecma_make_object_value (ecma_object_t* object_p);
extern ecma_number_t* __attribute_const__ ecma_get_number_from_value (ecma_value_t value);
extern ecma_string_t* __attribute_const__ ecma_get_string_from_value (ecma_value_t value);
extern ecma_object_t* __attribute_const__ ecma_get_object_from_value (ecma_value_t value);
extern ecma_value_t ecma_copy_value (const ecma_value_t value, bool do_ref_if_object);
extern void ecma_free_value (const ecma_value_t value, bool do_deref_if_object);
@ -93,6 +96,13 @@ extern ecma_completion_value_t ecma_make_empty_completion_value (void);
extern ecma_completion_value_t ecma_make_return_completion_value (ecma_value_t value);
extern ecma_completion_value_t ecma_make_exit_completion_value (bool is_successful);
extern ecma_completion_value_t ecma_make_meta_completion_value (void);
extern ecma_value_t ecma_get_completion_value_value (ecma_completion_value_t completion_value);
extern ecma_number_t* __attribute_const__
ecma_get_number_from_completion_value (ecma_completion_value_t completion_value);
extern ecma_string_t* __attribute_const__
ecma_get_string_from_completion_value (ecma_completion_value_t completion_value);
extern ecma_object_t* __attribute_const__
ecma_get_object_from_completion_value (ecma_completion_value_t completion_value);
extern ecma_completion_value_t ecma_copy_completion_value (ecma_completion_value_t value);
extern void ecma_free_completion_value (ecma_completion_value_t completion_value);

4
src/libecmaoperations/ecma-array-object.c
View File

@ -215,9 +215,9 @@ ecma_op_array_object_define_own_property (ecma_object_t *obj_p, /**< the array o
}
JERRY_ASSERT (ecma_is_completion_value_normal (completion)
&& ecma_is_value_number (completion.u.value));
&& ecma_is_value_number (ecma_get_completion_value_value (completion)));
new_len_num = *(ecma_number_t*) ECMA_GET_NON_NULL_POINTER (completion.u.value.value);
new_len_num = *ecma_get_number_from_completion_value (completion);
ecma_free_completion_value (completion);

2
src/libecmaoperations/ecma-boolean-object.c
View File

@ -48,7 +48,7 @@ ecma_op_create_boolean_object (ecma_value_t arg) /**< argument passed to the Boo
return conv_to_boolean_completion;
}
ecma_simple_value_t bool_value = conv_to_boolean_completion.u.value.value;
ecma_simple_value_t bool_value = ecma_get_completion_value_value (conv_to_boolean_completion).value;
JERRY_ASSERT (bool_value == ECMA_SIMPLE_VALUE_TRUE || bool_value == ECMA_SIMPLE_VALUE_FALSE);

28
src/libecmaoperations/ecma-comparison.c
View File

@ -133,7 +133,7 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
ret_value);
ret_value = ecma_op_abstract_equality_compare (x,
y_num_value.u.value);
ecma_get_completion_value_value (y_num_value));
ECMA_FINALIZE (y_num_value);
}
@ -144,7 +144,7 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
ecma_op_to_number (x),
ret_value);
ret_value = ecma_op_abstract_equality_compare (x_num_value.u.value,
ret_value = ecma_op_abstract_equality_compare (ecma_get_completion_value_value (x_num_value),
y);
ECMA_FINALIZE (x_num_value);
@ -156,7 +156,7 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
ecma_op_to_number (x),
ret_value);
ret_value = ecma_op_abstract_equality_compare (x_num_value.u.value,
ret_value = ecma_op_abstract_equality_compare (ecma_get_completion_value_value (x_num_value),
y);
ECMA_FINALIZE (x_num_value);
@ -169,7 +169,7 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
ret_value);
ret_value = ecma_op_abstract_equality_compare (x,
y_num_value.u.value);
ecma_get_completion_value_value (y_num_value));
ECMA_FINALIZE (y_num_value);
}
@ -182,7 +182,7 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
ret_value);
ret_value = ecma_op_abstract_equality_compare (x,
y_prim_value.u.value);
ecma_get_completion_value_value (y_prim_value));
ECMA_FINALIZE (y_prim_value);
}
@ -194,7 +194,7 @@ ecma_op_abstract_equality_compare (ecma_value_t x, /**< first operand */
ecma_op_to_primitive (x, ECMA_PREFERRED_TYPE_NO),
ret_value);
ret_value = ecma_op_abstract_equality_compare (x_prim_value.u.value,
ret_value = ecma_op_abstract_equality_compare (ecma_get_completion_value_value (x_prim_value),
y);
ECMA_FINALIZE (x_prim_value);
@ -338,21 +338,21 @@ ecma_op_abstract_relational_compare (ecma_value_t x, /**< first operand */
px = left_first ? prim_first_converted_value : prim_second_converted_value;
py = left_first ? prim_second_converted_value : prim_first_converted_value;
const bool is_px_string = ecma_is_value_string (px.u.value);
const bool is_py_string = ecma_is_value_string (py.u.value);
const bool is_px_string = ecma_is_value_string (ecma_get_completion_value_value (px));
const bool is_py_string = ecma_is_value_string (ecma_get_completion_value_value (py));
if (!(is_px_string && is_py_string))
{
// 3.
// a.
ECMA_TRY_CATCH(nx, ecma_op_to_number (px.u.value), ret_value);
ECMA_TRY_CATCH(nx, ecma_op_to_number (ecma_get_completion_value_value (px)), ret_value);
// b.
ECMA_TRY_CATCH(ny, ecma_op_to_number (py.u.value), ret_value);
ECMA_TRY_CATCH(ny, ecma_op_to_number (ecma_get_completion_value_value (py)), ret_value);
ecma_number_t* num_x_p = (ecma_number_t*)ECMA_GET_NON_NULL_POINTER(nx.u.value.value);
ecma_number_t* num_y_p = (ecma_number_t*)ECMA_GET_NON_NULL_POINTER(ny.u.value.value);
ecma_number_t* num_x_p = ecma_get_number_from_completion_value (nx);
ecma_number_t* num_y_p = ecma_get_number_from_completion_value (ny);
if (ecma_number_is_nan (*num_x_p)
|| ecma_number_is_nan (*num_y_p))
@ -418,8 +418,8 @@ ecma_op_abstract_relational_compare (ecma_value_t x, /**< first operand */
{ // 4.
JERRY_ASSERT (is_px_string && is_py_string);
ecma_string_t *str_x_p = ECMA_GET_NON_NULL_POINTER (px.u.value.value);
ecma_string_t *str_y_p = ECMA_GET_NON_NULL_POINTER (py.u.value.value);
ecma_string_t *str_x_p = ecma_get_string_from_completion_value (px);
ecma_string_t *str_y_p = ecma_get_string_from_completion_value (py);
bool is_px_less = ecma_compare_ecma_strings_relational (str_x_p, str_y_p);

32
src/libecmaoperations/ecma-conversion.c
View File

@ -272,7 +272,7 @@ ecma_op_to_number (ecma_value_t value) /**< ecma-value */
ecma_op_to_primitive (value, ECMA_PREFERRED_TYPE_NUMBER),
ret_value);
ret_value = ecma_op_to_number (completion_to_primitive.u.value);
ret_value = ecma_op_to_number (ecma_get_completion_value_value (completion_to_primitive));
ECMA_FINALIZE (completion_to_primitive);
@ -330,7 +330,7 @@ ecma_op_to_string (ecma_value_t value) /**< ecma-value */
ecma_op_to_primitive (value, ECMA_PREFERRED_TYPE_STRING),
ret_value);
ret_value = ecma_op_to_string (prim_value.u.value);
ret_value = ecma_op_to_string (ecma_get_completion_value_value (prim_value));
ECMA_FINALIZE (prim_value);
@ -584,7 +584,7 @@ ecma_op_to_property_descriptor (ecma_value_t obj_value, /**< object 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.u.value),
ecma_op_to_boolean (ecma_get_completion_value_value (enumerable_prop_value)),
ret_value);
prop_desc.is_enumerable_defined = true;
@ -618,7 +618,7 @@ ecma_op_to_property_descriptor (ecma_value_t obj_value, /**< object 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.u.value),
ecma_op_to_boolean (ecma_get_completion_value_value (configurable_prop_value)),
ret_value);
prop_desc.is_configurable_defined = true;
@ -654,7 +654,7 @@ ecma_op_to_property_descriptor (ecma_value_t obj_value, /**< object value */
ret_value);
prop_desc.is_value_defined = true;
prop_desc.value = ecma_copy_value (value_prop_value.u.value, true);
prop_desc.value = ecma_copy_value (ecma_get_completion_value_value (value_prop_value), true);
ECMA_FINALIZE (value_prop_value);
}
@ -675,7 +675,7 @@ ecma_op_to_property_descriptor (ecma_value_t obj_value, /**< object 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.u.value),
ecma_op_to_boolean (ecma_get_completion_value_value (writable_prop_value)),
ret_value);
prop_desc.is_writable_defined = true;
@ -710,8 +710,8 @@ ecma_op_to_property_descriptor (ecma_value_t obj_value, /**< object value */
ecma_op_object_get (obj_p, get_magic_string_p),
ret_value);
if (!ecma_op_is_callable (get_prop_value.u.value)
&& !ecma_is_value_undefined (get_prop_value.u.value))
if (!ecma_op_is_callable (ecma_get_completion_value_value (get_prop_value))
&& !ecma_is_value_undefined (ecma_get_completion_value_value (get_prop_value)))
{
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
@ -719,15 +719,15 @@ ecma_op_to_property_descriptor (ecma_value_t obj_value, /**< object value */
{
prop_desc.is_get_defined = true;
if (ecma_is_value_undefined (get_prop_value.u.value))
if (ecma_is_value_undefined (ecma_get_completion_value_value (get_prop_value)))
{
prop_desc.get_p = NULL;
}
else
{
JERRY_ASSERT (ecma_is_value_object (get_prop_value.u.value));
JERRY_ASSERT (ecma_is_value_object (ecma_get_completion_value_value (get_prop_value)));
ecma_object_t *get_p = ECMA_GET_NON_NULL_POINTER (get_prop_value.u.value.value);
ecma_object_t *get_p = ecma_get_object_from_completion_value (get_prop_value);
ecma_ref_object (get_p);
prop_desc.get_p = get_p;
@ -754,8 +754,8 @@ ecma_op_to_property_descriptor (ecma_value_t obj_value, /**< object value */
ecma_op_object_get (obj_p, set_magic_string_p),
ret_value);
if (!ecma_op_is_callable (set_prop_value.u.value)
&& !ecma_is_value_undefined (set_prop_value.u.value))
if (!ecma_op_is_callable (ecma_get_completion_value_value (set_prop_value))
&& !ecma_is_value_undefined (ecma_get_completion_value_value (set_prop_value)))
{
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
@ -763,15 +763,15 @@ ecma_op_to_property_descriptor (ecma_value_t obj_value, /**< object value */
{
prop_desc.is_set_defined = true;
if (ecma_is_value_undefined (set_prop_value.u.value))
if (ecma_is_value_undefined (ecma_get_completion_value_value (set_prop_value)))
{
prop_desc.set_p = NULL;
}
else
{
JERRY_ASSERT (ecma_is_value_object (set_prop_value.u.value));
JERRY_ASSERT (ecma_is_value_object (ecma_get_completion_value_value (set_prop_value)));
ecma_object_t *set_p = ECMA_GET_NON_NULL_POINTER (set_prop_value.u.value.value);
ecma_object_t *set_p = ecma_get_object_from_completion_value (set_prop_value);
ecma_ref_object (set_p);
prop_desc.set_p = set_p;

16
src/libecmaoperations/ecma-function-object.c
View File

@ -406,13 +406,13 @@ ecma_op_function_has_instance (ecma_object_t *func_obj_p, /**< Function object *
ecma_op_object_get (func_obj_p, prototype_magic_string_p),
ret_value);
if (!ecma_is_value_object (prototype_obj_value.u.value))
if (!ecma_is_value_object (ecma_get_completion_value_value (prototype_obj_value)))
{
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
ecma_object_t *prototype_obj_p = ECMA_GET_NON_NULL_POINTER (prototype_obj_value.u.value.value);
ecma_object_t *prototype_obj_p = ecma_get_object_from_completion_value (prototype_obj_value);
JERRY_ASSERT (prototype_obj_p != NULL);
do
@ -512,7 +512,7 @@ ecma_op_function_call (ecma_object_t *func_obj_p, /**< Function object */
ecma_completion_value_t completion = ecma_op_to_object (this_arg_value);
JERRY_ASSERT (ecma_is_completion_value_normal (completion));
this_binding = completion.u.value;
this_binding = ecma_get_completion_value_value (completion);
}
// 5.
@ -534,7 +534,7 @@ ecma_op_function_call (ecma_object_t *func_obj_p, /**< Function object */
false);
if (ecma_is_completion_value_return (completion))
{
ret_value = ecma_make_normal_completion_value (completion.u.value);
ret_value = ecma_make_normal_completion_value (ecma_get_completion_value_value (completion));
}
else
{
@ -597,9 +597,9 @@ ecma_op_function_construct (ecma_object_t *func_obj_p, /**< Function object */
// 6.
ecma_object_t *prototype_p;
if (ecma_is_value_object (func_obj_prototype_prop_value.u.value))
if (ecma_is_value_object (ecma_get_completion_value_value (func_obj_prototype_prop_value)))
{
prototype_p = ECMA_GET_NON_NULL_POINTER (func_obj_prototype_prop_value.u.value.value);
prototype_p = ecma_get_object_from_completion_value (func_obj_prototype_prop_value);
ecma_ref_object (prototype_p);
}
else
@ -628,11 +628,11 @@ ecma_op_function_construct (ecma_object_t *func_obj_p, /**< Function object */
ecma_value_t obj_value;
// 9.
if (ecma_is_value_object (call_completion.u.value))
if (ecma_is_value_object (ecma_get_completion_value_value (call_completion)))
{
ecma_deref_object (obj_p);
obj_value = ecma_copy_value (call_completion.u.value, true);
obj_value = ecma_copy_value (ecma_get_completion_value_value (call_completion), true);
}
else
{

4
src/libecmaoperations/ecma-get-put-value.c
View File

@ -107,7 +107,7 @@ ecma_op_get_value_object_base (ecma_reference_t ref) /**< ECMA-reference */
ECMA_TRY_CATCH (obj_base, ecma_op_to_object (base), ret_value);
ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (obj_base.u.value.value);
ecma_object_t *obj_p = ecma_get_object_from_completion_value (obj_base);
JERRY_ASSERT (obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
@ -248,7 +248,7 @@ ecma_op_put_value_object_base (ecma_reference_t ref, /**< ECMA-reference */
// sub_1.
ECMA_TRY_CATCH (obj_base, ecma_op_to_object (base), ret_value);
ecma_object_t *obj_p = ECMA_GET_NON_NULL_POINTER (obj_base.u.value.value);
ecma_object_t *obj_p = ecma_get_object_from_completion_value (obj_base);
JERRY_ASSERT (obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));

2
src/libecmaoperations/ecma-number-object.c
View File

@ -48,7 +48,7 @@ ecma_op_create_number_object (ecma_value_t arg) /**< argument passed to the Numb
return conv_to_num_completion;
}
ecma_number_t *prim_value_p = ECMA_GET_NON_NULL_POINTER (conv_to_num_completion.u.value.value);
ecma_number_t *prim_value_p = ecma_get_number_from_completion_value (conv_to_num_completion);
#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_NUMBER_BUILTIN
ecma_object_t *prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_NUMBER_PROTOTYPE);

2
src/libecmaoperations/ecma-objects-arguments.c
View File

@ -369,7 +369,7 @@ ecma_op_arguments_object_get_own_property (ecma_object_t *obj_p, /**< the object
ecma_completion_value_t completion = ecma_arguments_get_mapped_arg_value (map_p, mapped_prop_p);
ecma_free_value (desc_p->u.named_data_property.value, false);
desc_p->u.named_data_property.value = ecma_copy_value (completion.u.value, false);
desc_p->u.named_data_property.value = ecma_copy_value (ecma_get_completion_value_value (completion), false);
ecma_gc_update_may_ref_younger_object_flag_by_value (obj_p, desc_p->u.named_data_property.value);
ecma_free_completion_value (completion);

24
src/libecmaoperations/ecma-objects-general.c
View File

@ -148,20 +148,10 @@ ecma_op_general_object_get (ecma_object_t *obj_p, /**< the object */
}
else
{
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (call_completion,
ecma_op_function_call (getter_p,
ecma_make_object_value (obj_p),
NULL,
0),
ret_value);
ret_value = ecma_make_normal_completion_value (ecma_copy_value (call_completion.u.value, true));
ECMA_FINALIZE (call_completion);
return ret_value;
return ecma_op_function_call (getter_p,
ecma_make_object_value (obj_p),
NULL,
0);
}
}
@ -592,9 +582,9 @@ ecma_op_general_object_default_value (ecma_object_t *obj_p, /**< the object */
ecma_completion_value_t call_completion = ecma_make_empty_completion_value ();
if (ecma_op_is_callable (function_value_get_completion.u.value))
if (ecma_op_is_callable (ecma_get_completion_value_value (function_value_get_completion)))
{
ecma_object_t *func_obj_p = ECMA_GET_NON_NULL_POINTER (function_value_get_completion.u.value.value);
ecma_object_t *func_obj_p = ecma_get_object_from_completion_value (function_value_get_completion);
call_completion = ecma_op_function_call (func_obj_p,
ecma_make_object_value (obj_p),
@ -609,7 +599,7 @@ ecma_op_general_object_default_value (ecma_object_t *obj_p, /**< the object */
}
if (!ecma_is_completion_value_empty (call_completion)
&& !ecma_is_value_object (call_completion.u.value))
&& !ecma_is_value_object (ecma_get_completion_value_value (call_completion)))
{
return call_completion;
}

4
src/libecmaoperations/ecma-string-object.c
View File

@ -67,8 +67,8 @@ ecma_op_create_string_object (ecma_value_t *arguments_list_p, /**< list of argum
{
JERRY_ASSERT (ecma_is_completion_value_normal (to_str_arg_value));
JERRY_ASSERT (ecma_is_value_string (to_str_arg_value.u.value));
prim_prop_str_value_p = ECMA_GET_NON_NULL_POINTER (to_str_arg_value.u.value.value);
JERRY_ASSERT (ecma_is_value_string (ecma_get_completion_value_value (to_str_arg_value)));
prim_prop_str_value_p = ecma_get_string_from_completion_value (to_str_arg_value);
int32_t string_len = ecma_string_get_length (prim_prop_str_value_p);
JERRY_ASSERT (string_len >= 0);