YourWishes/jerryscript
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Reverting changes related to on-stack GC-root introduction (except of passing ecma_value_t by const reference).

Browse Source 
This reverts commits:
     31e1405f39d72f8b885e92256b0dc29ecab1a99,
     7cb43840b59c539d9b043990ed658ae15a9defc3,
     1ab57a4493689806035a9853b0030cc6fea65590,
     c24b511ca60587e0db12d46a7e7567c86c3649bc,
     b2caf3e8b31b4b6b16499108ee3aabdcb94f0717,
     44f9c307fb6204bfd2181b19a9d94cabddf04de9.
This commit is contained in:
Ruben Ayrapetyan
2015-02-09 17:06:34 +03:00
parent 35aa8238c2
commit ba348831ca
114 changed files with 4226 additions and 4916 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libecmaoperations/ecma-array-object.c
+66 -103
View File
@@ -37,19 +37,16 @@
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
static void
ecma_reject (ecma_completion_value_t &ret_value, /**< out: completion value */
bool is_throw) /**< Throw flag */
static ecma_completion_value_t
ecma_reject (bool is_throw) /**< Throw flag */
{
if (is_throw)
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_TYPE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_FALSE);
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE);
}
} /* ecma_reject */
@@ -62,9 +59,8 @@ ecma_reject (ecma_completion_value_t &ret_value, /**< out: completion value */
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_create_array_object (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_value_t *arguments_list_p, /**< list of arguments that
ecma_completion_value_t
ecma_op_create_array_object (const ecma_value_t *arguments_list_p, /**< list of arguments that
are passed to Array constructor */
ecma_length_t arguments_list_len, /**< length of the arguments' list */
bool is_treat_single_arg_as_length) /**< if the value is true,
@@ -89,10 +85,7 @@ ecma_op_create_array_object (ecma_completion_value_t &ret_value, /**< out: compl
uint32_t num_uint32 = ecma_number_to_uint32 (*num_p);
if (*num_p != ecma_uint32_to_number (num_uint32))
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_RANGE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
return;
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_RANGE));
}
else
{
@@ -109,15 +102,12 @@ ecma_op_create_array_object (ecma_completion_value_t &ret_value, /**< out: compl
}
#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ARRAY_BUILTIN
ecma_object_ptr_t array_prototype_obj_p;
ecma_builtin_get (array_prototype_obj_p, ECMA_BUILTIN_ID_ARRAY_PROTOTYPE);
ecma_object_t *array_prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_ARRAY_PROTOTYPE);
#else /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ARRAY_BUILTIN */
ecma_object_ptr_t array_prototype_obj_p;
ecma_builtin_get (array_prototype_obj_p, ECMA_BUILTIN_ID_OBJECT_PROTOTYPE);
ecma_object_t *array_prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_OBJECT_PROTOTYPE);
#endif /* CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ARRAY_BUILTIN */
ecma_object_ptr_t obj_p;
ecma_create_object (obj_p, array_prototype_obj_p, true, ECMA_OBJECT_TYPE_ARRAY);
ecma_object_t *obj_p = ecma_create_object (array_prototype_obj_p, true, ECMA_OBJECT_TYPE_ARRAY);
ecma_deref_object (array_prototype_obj_p);
ecma_property_t *class_prop_p = ecma_create_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_CLASS);
@@ -130,7 +120,7 @@ ecma_op_create_array_object (ecma_completion_value_t &ret_value, /**< out: compl
ecma_property_t *length_prop_p = ecma_create_named_data_property (obj_p,
length_magic_string_p,
true, false, false);
ecma_set_named_data_property_value (length_prop_p, ecma_value_t (length_num_p));
ecma_set_named_data_property_value (length_prop_p, ecma_make_number_value (length_num_p));
ecma_deref_ecma_string (length_magic_string_p);
@@ -143,7 +133,7 @@ ecma_op_create_array_object (ecma_completion_value_t &ret_value, /**< out: compl
ecma_property_descriptor_t item_prop_desc = ecma_make_empty_property_descriptor ();
{
item_prop_desc.is_value_defined = true;
item_prop_desc.value = (ecma_value_packed_t) array_items_p [index];
item_prop_desc.value = array_items_p [index];
item_prop_desc.is_writable_defined = true;
item_prop_desc.is_writable = true;
@@ -155,18 +145,15 @@ ecma_op_create_array_object (ecma_completion_value_t &ret_value, /**< out: compl
item_prop_desc.is_configurable = true;
}
ecma_op_object_define_own_property (ret_value,
obj_p,
ecma_op_object_define_own_property (obj_p,
item_name_string_p,
&item_prop_desc,
false);
JERRY_ASSERT (ecma_is_completion_value_normal_true (ret_value)
|| ecma_is_completion_value_normal_false (ret_value));
ecma_deref_ecma_string (item_name_string_p);
}
ecma_make_normal_completion_value (ret_value, ecma_value_t (obj_p));
return ecma_make_normal_completion_value (ecma_make_object_value (obj_p));
} /* ecma_op_create_array_object */
/**
@@ -179,9 +166,8 @@ ecma_op_create_array_object (ecma_completion_value_t &ret_value, /**< out: compl
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_array_object_define_own_property (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& obj_p, /**< the array object */
ecma_completion_value_t
ecma_op_array_object_define_own_property (ecma_object_t *obj_p, /**< the array object */
ecma_string_t *property_name_p, /**< property name */
const ecma_property_descriptor_t* property_desc_p, /**< property descriptor */
bool is_throw) /**< flag that controls failure handling */
@@ -195,8 +181,7 @@ ecma_op_array_object_define_own_property (ecma_completion_value_t &ret_value, /*
JERRY_ASSERT (len_prop_p != NULL && len_prop_p->type == ECMA_PROPERTY_NAMEDDATA);
// 2.
ecma_value_t old_len_value;
ecma_get_named_data_property_value (old_len_value, len_prop_p);
ecma_value_t old_len_value = ecma_get_named_data_property_value (len_prop_p);
ecma_number_t *num_p = ecma_get_number_from_value (old_len_value);
uint32_t old_len_uint32 = ecma_number_to_uint32 (*num_p);
@@ -213,39 +198,31 @@ ecma_op_array_object_define_own_property (ecma_completion_value_t &ret_value, /*
if (!property_desc_p->is_value_defined)
{
// i.
ecma_op_general_object_define_own_property (ret_value, obj_p, property_name_p, property_desc_p, is_throw);
return;
return ecma_op_general_object_define_own_property (obj_p, property_name_p, property_desc_p, is_throw);
}
ecma_number_t new_len_num;
// c.
ecma_completion_value_t prop_val_to_num_completion;
ecma_op_to_number (prop_val_to_num_completion, ecma_value_t (property_desc_p->value));
if (ecma_is_completion_value_throw (prop_val_to_num_completion))
ecma_completion_value_t completion = ecma_op_to_number (property_desc_p->value);
if (ecma_is_completion_value_throw (completion))
{
ret_value = prop_val_to_num_completion;
return;
return completion;
}
JERRY_ASSERT (ecma_is_completion_value_normal (prop_val_to_num_completion));
JERRY_ASSERT (ecma_is_completion_value_normal (completion)
&& ecma_is_value_number (ecma_get_completion_value_value (completion)));
ecma_value_t new_len_value;
ecma_get_completion_value_value (new_len_value, prop_val_to_num_completion);
new_len_num = *ecma_get_number_from_completion_value (completion);
new_len_num = *ecma_get_number_from_value (new_len_value);
ecma_free_completion_value (prop_val_to_num_completion);
ecma_free_completion_value (completion);
uint32_t new_len_uint32 = ecma_number_to_uint32 (new_len_num);
// d.
if (ecma_uint32_to_number (new_len_uint32) != new_len_num)
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_RANGE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
return;
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_RANGE));
}
else
{
@@ -254,18 +231,19 @@ ecma_op_array_object_define_own_property (ecma_completion_value_t &ret_value, /*
*new_len_num_p = new_len_num;
ecma_property_descriptor_t new_len_property_desc = *property_desc_p;
new_len_property_desc.value = (ecma_value_packed_t) ecma_value_t (new_len_num_p);
new_len_property_desc.value = ecma_make_number_value (new_len_num_p);
ecma_completion_value_t ret_value;
// f.
if (new_len_uint32 >= old_len_uint32)
{
// i.
magic_string_length_p = ecma_get_magic_string (ECMA_MAGIC_STRING_LENGTH);
ecma_op_general_object_define_own_property (ret_value,
obj_p,
magic_string_length_p,
&new_len_property_desc,
is_throw);
ret_value = ecma_op_general_object_define_own_property (obj_p,
magic_string_length_p,
&new_len_property_desc,
is_throw);
ecma_deref_ecma_string (magic_string_length_p);
}
else
@@ -273,7 +251,7 @@ ecma_op_array_object_define_own_property (ecma_completion_value_t &ret_value, /*
// g.
if (!ecma_is_property_writable (len_prop_p))
{
ecma_reject (ret_value, is_throw);
ret_value = ecma_reject (is_throw);
}
else
{
@@ -296,12 +274,10 @@ ecma_op_array_object_define_own_property (ecma_completion_value_t &ret_value, /*
// j.
magic_string_length_p = ecma_get_magic_string (ECMA_MAGIC_STRING_LENGTH);
ecma_completion_value_t succeeded;
ecma_op_general_object_define_own_property (succeeded,
obj_p,
magic_string_length_p,
&new_len_property_desc,
is_throw);
ecma_completion_value_t succeeded = ecma_op_general_object_define_own_property (obj_p,
magic_string_length_p,
&new_len_property_desc,
is_throw);
ecma_deref_ecma_string (magic_string_length_p);
/* Handling normal false and throw values */
@@ -327,20 +303,17 @@ ecma_op_array_object_define_own_property (ecma_completion_value_t &ret_value, /*
// ii
ecma_string_t *old_length_string_p = ecma_new_ecma_string_from_uint32 (old_len_uint32);
ecma_completion_value_t delete_succeeded;
ecma_op_object_delete (delete_succeeded,
obj_p,
old_length_string_p,
false);
ecma_completion_value_t delete_succeeded = ecma_op_object_delete (obj_p,
old_length_string_p,
false);
ecma_deref_ecma_string (old_length_string_p);
// iii
if (ecma_is_completion_value_normal_false (delete_succeeded))
{
ecma_value_t new_len_value (new_len_property_desc.value);
JERRY_ASSERT (ecma_is_value_number (new_len_value));
JERRY_ASSERT (ecma_is_value_number (new_len_property_desc.value));
ecma_number_t *new_len_num_p = ecma_get_number_from_value (new_len_value);
ecma_number_t *new_len_num_p = ecma_get_number_from_value (new_len_property_desc.value);
// 1.
*new_len_num_p = ecma_uint32_to_number (old_len_uint32 + 1);
@@ -354,12 +327,10 @@ ecma_op_array_object_define_own_property (ecma_completion_value_t &ret_value, /*
// 3.
ecma_string_t *magic_string_length_p = ecma_get_magic_string (ECMA_MAGIC_STRING_LENGTH);
ecma_completion_value_t completion;
ecma_op_general_object_define_own_property (completion,
obj_p,
magic_string_length_p,
&new_len_property_desc,
false);
ecma_completion_value_t completion = ecma_op_general_object_define_own_property (obj_p,
magic_string_length_p,
&new_len_property_desc,
false);
ecma_deref_ecma_string (magic_string_length_p);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion)
@@ -373,7 +344,7 @@ ecma_op_array_object_define_own_property (ecma_completion_value_t &ret_value, /*
if (!reduce_succeeded)
{
ecma_reject (ret_value, is_throw);
ret_value = ecma_reject (is_throw);
}
else
{
@@ -387,16 +358,15 @@ ecma_op_array_object_define_own_property (ecma_completion_value_t &ret_value, /*
ecma_completion_value_t completion_set_not_writable;
magic_string_length_p = ecma_get_magic_string (ECMA_MAGIC_STRING_LENGTH);
ecma_op_general_object_define_own_property (completion_set_not_writable,
obj_p,
magic_string_length_p,
&prop_desc_not_writable,
false);
completion_set_not_writable = ecma_op_general_object_define_own_property (obj_p,
magic_string_length_p,
&prop_desc_not_writable,
false);
ecma_deref_ecma_string (magic_string_length_p);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion_set_not_writable));
}
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_TRUE);
ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
}
}
@@ -404,7 +374,7 @@ ecma_op_array_object_define_own_property (ecma_completion_value_t &ret_value, /*
ecma_dealloc_number (new_len_num_p);
return;
return ret_value;
}
JERRY_UNREACHABLE();
@@ -438,12 +408,10 @@ ecma_op_array_object_define_own_property (ecma_completion_value_t &ret_value, /*
if (!is_index)
{
// 5.
ecma_op_general_object_define_own_property (ret_value,
obj_p,
property_name_p,
property_desc_p,
false);
return;
return ecma_op_general_object_define_own_property (obj_p,
property_name_p,
property_desc_p,
false);
}
// 4.
@@ -452,25 +420,21 @@ ecma_op_array_object_define_own_property (ecma_completion_value_t &ret_value, /*
if (index >= old_len_uint32
&& !ecma_is_property_writable (len_prop_p))
{
ecma_reject (ret_value, is_throw);
return;
return ecma_reject (is_throw);
}
// c.
ecma_completion_value_t succeeded;
ecma_op_general_object_define_own_property (succeeded,
obj_p,
property_name_p,
property_desc_p,
false);
ecma_completion_value_t succeeded = ecma_op_general_object_define_own_property (obj_p,
property_name_p,
property_desc_p,
false);
// d.
JERRY_ASSERT (ecma_is_completion_value_normal_true (succeeded)
|| ecma_is_completion_value_normal_false (succeeded));
if (ecma_is_completion_value_normal_false (succeeded))
{
ecma_reject (ret_value, is_throw);
return;
return ecma_reject (is_throw);
}
// e.
@@ -480,14 +444,13 @@ ecma_op_array_object_define_own_property (ecma_completion_value_t &ret_value, /*
ecma_number_t *num_p = ecma_alloc_number ();
*num_p = ecma_number_add (ecma_uint32_to_number (index), ECMA_NUMBER_ONE);
ecma_named_data_property_assign_value (obj_p, len_prop_p, ecma_value_t (num_p));
ecma_named_data_property_assign_value (obj_p, len_prop_p, ecma_make_number_value (num_p));
ecma_dealloc_number (num_p);
}
// f.
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_TRUE);
return;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
JERRY_UNREACHABLE();
src/libecmaoperations/ecma-array-object.h
+4 -7
View File
@@ -17,7 +17,6 @@
#define ECMA_ARRAY_OBJECT_H
#include "ecma-globals.h"
#include "ecma-value.h"
/** \addtogroup ecma ECMA
* @{
@@ -26,15 +25,13 @@
* @{
*/
extern void
ecma_op_create_array_object (ecma_completion_value_t &ret_value,
const ecma_value_t *arguments_list_p,
extern ecma_completion_value_t
ecma_op_create_array_object (const ecma_value_t *arguments_list_p,
ecma_length_t arguments_list_len,
bool is_treat_single_arg_as_length);
extern void
ecma_op_array_object_define_own_property (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& obj_p,
extern ecma_completion_value_t
ecma_op_array_object_define_own_property (ecma_object_t *obj_p,
ecma_string_t *property_name_p,
const ecma_property_descriptor_t* property_desc_p,
bool is_throw);
src/libecmaoperations/ecma-boolean-object.c
+11 -15
View File
@@ -38,32 +38,28 @@
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_create_boolean_object (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_value_t& arg) /**< argument passed to the Boolean constructor */
ecma_completion_value_t
ecma_op_create_boolean_object (const ecma_value_t& arg) /**< argument passed to the Boolean constructor */
{
ecma_completion_value_t conv_to_boolean_completion;
ecma_op_to_boolean (conv_to_boolean_completion, arg);
ecma_completion_value_t conv_to_boolean_completion = ecma_op_to_boolean (arg);
if (!ecma_is_completion_value_normal (conv_to_boolean_completion))
{
ret_value = conv_to_boolean_completion;
return;
return conv_to_boolean_completion;
}
ecma_simple_value_t bool_value = (ecma_is_completion_value_normal_true (conv_to_boolean_completion) ?
ecma_simple_value_t bool_value = (ecma_is_value_true (ecma_get_completion_value_value (conv_to_boolean_completion)) ?
ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_BOOLEAN_BUILTIN
ecma_object_ptr_t prototype_obj_p;
ecma_builtin_get (prototype_obj_p, ECMA_BUILTIN_ID_BOOLEAN_PROTOTYPE);
ecma_object_t *prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_BOOLEAN_PROTOTYPE);
#else /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_BOOLEAN_BUILTIN */
ecma_object_ptr_t prototype_obj_p;
ecma_builtin_get (prototype_obj_p, ECMA_BUILTIN_ID_OBJECT_PROTOTYPE);
ecma_object_t *prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_OBJECT_PROTOTYPE);
#endif /* CONFIG_ECMA_COMPACT_PROFILE_DISABLE_BOOLEAN_BUILTIN */
ecma_object_ptr_t obj_p;
ecma_create_object (obj_p, prototype_obj_p, true, ECMA_OBJECT_TYPE_GENERAL);
ecma_object_t *obj_p = ecma_create_object (prototype_obj_p,
true,
ECMA_OBJECT_TYPE_GENERAL);
ecma_deref_object (prototype_obj_p);
ecma_property_t *class_prop_p = ecma_create_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_CLASS);
@@ -73,5 +69,5 @@ ecma_op_create_boolean_object (ecma_completion_value_t &ret_value, /**< out: com
ECMA_INTERNAL_PROPERTY_PRIMITIVE_BOOLEAN_VALUE);
prim_value_prop_p->u.internal_property.value = bool_value;
ecma_make_normal_completion_value (ret_value, ecma_value_t (obj_p));
return ecma_make_normal_completion_value (ecma_make_object_value (obj_p));
} /* ecma_op_create_boolean_object */
src/libecmaoperations/ecma-boolean-object.h
+1 -4
View File
@@ -17,7 +17,6 @@
#define ECMA_BOOLEAN_OBJECT_H
#include "ecma-globals.h"
#include "ecma-value.h"
/** \addtogroup ecma ECMA
* @{
@@ -26,9 +25,7 @@
* @{
*/
extern void
ecma_op_create_boolean_object (ecma_completion_value_t &ret_value,
const ecma_value_t& arg);
extern ecma_completion_value_t ecma_op_create_boolean_object (const ecma_value_t& arg);
/**
* @}
src/libecmaoperations/ecma-comparison.c
+57 -45
View File
@@ -34,9 +34,8 @@
* @return true - if values are equal,
* false - otherwise.
*/
void
ecma_op_abstract_equality_compare (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_value_t& x, /**< first operand */
ecma_completion_value_t
ecma_op_abstract_equality_compare (const ecma_value_t& x, /**< first operand */
const ecma_value_t& y) /**< second operand */
{
const bool is_x_undefined = ecma_is_value_undefined (x);
@@ -60,6 +59,8 @@ ecma_op_abstract_equality_compare (ecma_completion_value_t &ret_value, /**< out:
|| (is_x_string && is_y_string)
|| (is_x_object && is_y_object));
ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
if (is_types_equal)
{
// 1.
@@ -68,7 +69,7 @@ ecma_op_abstract_equality_compare (ecma_completion_value_t &ret_value, /**< out:
|| is_x_null)
{
// a., b.
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_TRUE);
ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
else if (is_x_number)
{ // c.
@@ -99,8 +100,8 @@ ecma_op_abstract_equality_compare (ecma_completion_value_t &ret_value, /**< out:
JERRY_ASSERT (is_x_equal_to_y == is_x_equal_to_y_check);
#endif /* !JERRY_NDEBUG */
ecma_make_simple_completion_value (ret_value,
is_x_equal_to_y ? ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
ret_value = ecma_make_simple_completion_value (is_x_equal_to_y ?
ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
}
else if (is_x_string)
{ // d.
@@ -109,65 +110,69 @@ ecma_op_abstract_equality_compare (ecma_completion_value_t &ret_value, /**< out:
bool is_equal = ecma_compare_ecma_strings (x_str_p, y_str_p);
ecma_make_simple_completion_value (ret_value, is_equal ? ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
ret_value = ecma_make_simple_completion_value (is_equal ? ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
}
else if (is_x_boolean)
{ // e.
bool is_equal = (ecma_is_value_true (x) == ecma_is_value_true (y));
ecma_make_simple_completion_value (ret_value, is_equal ? ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
ret_value = ecma_make_simple_completion_value (is_equal ? ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
}
else
{ // f.
JERRY_ASSERT(is_x_object);
ecma_object_ptr_t x_obj_p, y_obj_p;
ecma_get_object_from_value (x_obj_p, x);
ecma_get_object_from_value (y_obj_p, y);
bool is_equal = (ecma_get_object_from_value (x) == ecma_get_object_from_value (y));
bool is_equal = (x_obj_p == y_obj_p);
ecma_make_simple_completion_value (ret_value, is_equal ? ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
ret_value = ecma_make_simple_completion_value (is_equal ? ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
}
}
else if ((is_x_null && is_y_undefined)
|| (is_x_undefined && is_y_null))
{ // 2., 3.
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_TRUE);
ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
else if (is_x_number && is_y_string)
{
// 4.
ECMA_TRY_CATCH (ret_value, ecma_op_to_number, y_num_value, y);
ECMA_TRY_CATCH (y_num_value,
ecma_op_to_number (y),
ret_value);
ecma_op_abstract_equality_compare (ret_value, x, y_num_value);
ret_value = ecma_op_abstract_equality_compare (x, y_num_value);
ECMA_FINALIZE (y_num_value);
}
else if (is_x_string && is_y_number)
{
// 5.
ECMA_TRY_CATCH (ret_value, ecma_op_to_number, x_num_value, x);
ECMA_TRY_CATCH (x_num_value,
ecma_op_to_number (x),
ret_value);
ecma_op_abstract_equality_compare (ret_value, x_num_value, y);
ret_value = ecma_op_abstract_equality_compare (x_num_value, y);
ECMA_FINALIZE (x_num_value);
}
else if (is_x_boolean)
{
// 6.
ECMA_TRY_CATCH (ret_value, ecma_op_to_number, x_num_value, x);
ECMA_TRY_CATCH (x_num_value,
ecma_op_to_number (x),
ret_value);
ecma_op_abstract_equality_compare (ret_value, x_num_value, y);
ret_value = ecma_op_abstract_equality_compare (x_num_value, y);
ECMA_FINALIZE (x_num_value);
}
else if (is_y_boolean)
{
// 7.
ECMA_TRY_CATCH (ret_value, ecma_op_to_number, y_num_value, y);
ECMA_TRY_CATCH (y_num_value,
ecma_op_to_number (y),
ret_value);
ecma_op_abstract_equality_compare (ret_value, x, y_num_value);
ret_value = ecma_op_abstract_equality_compare (x, y_num_value);
ECMA_FINALIZE (y_num_value);
}
@@ -175,9 +180,11 @@ ecma_op_abstract_equality_compare (ecma_completion_value_t &ret_value, /**< out:
&& (is_x_number || is_x_string))
{
// 8.
ECMA_TRY_CATCH (ret_value, ecma_op_to_primitive, y_prim_value, y, ECMA_PREFERRED_TYPE_NO);
ECMA_TRY_CATCH (y_prim_value,
ecma_op_to_primitive (y, ECMA_PREFERRED_TYPE_NO),
ret_value);
ecma_op_abstract_equality_compare (ret_value, x, y_prim_value);
ret_value = ecma_op_abstract_equality_compare (x, y_prim_value);
ECMA_FINALIZE (y_prim_value);
}
@@ -185,16 +192,20 @@ ecma_op_abstract_equality_compare (ecma_completion_value_t &ret_value, /**< out:
&& (is_y_number || is_y_string))
{
// 9.
ECMA_TRY_CATCH (ret_value, ecma_op_to_primitive, x_prim_value, x, ECMA_PREFERRED_TYPE_NO);
ECMA_TRY_CATCH (x_prim_value,
ecma_op_to_primitive (x, ECMA_PREFERRED_TYPE_NO),
ret_value);
ecma_op_abstract_equality_compare (ret_value, x_prim_value, y);
ret_value = ecma_op_abstract_equality_compare (x_prim_value, y);
ECMA_FINALIZE (x_prim_value);
}
else
{
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_FALSE);
ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE);
}
return ret_value;
} /* ecma_op_abstract_equality_compare */
/**
@@ -306,11 +317,7 @@ ecma_op_strict_equality_compare (const ecma_value_t& x, /**< first operand */
// 7. Return true if x and y refer to the same object. Otherwise, return false.
JERRY_ASSERT (is_x_object);
ecma_object_ptr_t x_obj_p, y_obj_p;
ecma_get_object_from_value (x_obj_p, x);
ecma_get_object_from_value (y_obj_p, y);
return (x_obj_p == y_obj_p);
return (ecma_get_object_from_value (x) == ecma_get_object_from_value (y));
} /* ecma_op_strict_equality_compare */
/**
@@ -321,20 +328,23 @@ ecma_op_strict_equality_compare (const ecma_value_t& x, /**< first operand */
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_abstract_relational_compare (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_value_t& x, /**< first operand */
ecma_completion_value_t
ecma_op_abstract_relational_compare (const ecma_value_t& x, /**< first operand */
const ecma_value_t& y, /**< second operand */
bool left_first) /**< 'LeftFirst' flag */
{
ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
const ecma_value_t& first_converted_value = left_first ? x : y;
const ecma_value_t& second_converted_value = left_first ? y : x;
// 1., 2.
ECMA_TRY_CATCH(ret_value,
ecma_op_to_primitive, prim_first_converted_value, first_converted_value, ECMA_PREFERRED_TYPE_NUMBER);
ECMA_TRY_CATCH(ret_value,
ecma_op_to_primitive, prim_second_converted_value, second_converted_value, ECMA_PREFERRED_TYPE_NUMBER);
ECMA_TRY_CATCH(prim_first_converted_value,
ecma_op_to_primitive (first_converted_value, ECMA_PREFERRED_TYPE_NUMBER),
ret_value);
ECMA_TRY_CATCH(prim_second_converted_value,
ecma_op_to_primitive (second_converted_value, ECMA_PREFERRED_TYPE_NUMBER),
ret_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;
@@ -355,7 +365,7 @@ ecma_op_abstract_relational_compare (ecma_completion_value_t &ret_value, /**< ou
|| ecma_number_is_nan (ny))
{
// c., d.
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_UNDEFINED);
ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_UNDEFINED);
}
else
{
@@ -418,8 +428,8 @@ ecma_op_abstract_relational_compare (ecma_completion_value_t &ret_value, /**< ou
JERRY_ASSERT (is_x_less_than_y_check == is_x_less_than_y);
#endif /* !JERRY_NDEBUG */
ecma_make_simple_completion_value (ret_value,
is_x_less_than_y ? ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
ret_value = ecma_make_simple_completion_value (is_x_less_than_y ?
ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
}
ECMA_OP_TO_NUMBER_FINALIZE (ny);
@@ -434,12 +444,14 @@ ecma_op_abstract_relational_compare (ecma_completion_value_t &ret_value, /**< ou
bool is_px_less = ecma_compare_ecma_strings_relational (str_x_p, str_y_p);
ecma_make_simple_completion_value (ret_value,
is_px_less ? ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
ret_value = ecma_make_simple_completion_value (is_px_less ? ECMA_SIMPLE_VALUE_TRUE
: ECMA_SIMPLE_VALUE_FALSE);
}
ECMA_FINALIZE(prim_second_converted_value);
ECMA_FINALIZE(prim_first_converted_value);
return ret_value;
} /* ecma_op_abstract_relational_compare */
/**
src/libecmaoperations/ecma-comparison.h
+7 -13
View File
@@ -18,7 +18,6 @@
#include "ecma-globals.h"
#include "ecma-helpers.h"
#include "ecma-value.h"
/** \addtogroup ecma ECMA
* @{
@@ -27,18 +26,13 @@
* @{
*/
extern void
ecma_op_abstract_equality_compare (ecma_completion_value_t &ret_value,
const ecma_value_t& x,
const ecma_value_t& y);
extern bool
ecma_op_strict_equality_compare (const ecma_value_t& x,
const ecma_value_t& y);
extern void
ecma_op_abstract_relational_compare (ecma_completion_value_t &ret_value,
const ecma_value_t& x,
const ecma_value_t& y,
bool left_first);
extern ecma_completion_value_t ecma_op_abstract_equality_compare (const ecma_value_t& x,
const ecma_value_t& y);
extern bool ecma_op_strict_equality_compare (const ecma_value_t& x,
const ecma_value_t& y);
extern ecma_completion_value_t ecma_op_abstract_relational_compare (const ecma_value_t& x,
const ecma_value_t& y,
bool left_first);
/**
* @}
src/libecmaoperations/ecma-conversion.c
+131 -145
View File
@@ -48,22 +48,19 @@
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_check_object_coercible (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_value_t& value) /**< ecma-value */
ecma_completion_value_t
ecma_op_check_object_coercible (const ecma_value_t& value) /**< ecma-value */
{
ecma_check_value_type_is_spec_defined (value);
if (ecma_is_value_undefined (value)
|| ecma_is_value_null (value))
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_TYPE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
ecma_make_empty_completion_value (ret_value);
return ecma_make_empty_completion_value ();
}
} /* ecma_op_check_object_coercible */
@@ -147,11 +144,7 @@ ecma_op_same_value (const ecma_value_t& x, /**< ecma-value */
JERRY_ASSERT(is_x_object);
ecma_object_ptr_t x_obj_p, y_obj_p;
ecma_get_object_from_value (x_obj_p, x);
ecma_get_object_from_value (y_obj_p, y);
return (x_obj_p == y_obj_p);
return (ecma_get_object_from_value (x) == ecma_get_object_from_value (y));
} /* ecma_op_same_value */
/**
@@ -163,26 +156,21 @@ ecma_op_same_value (const ecma_value_t& x, /**< ecma-value */
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_to_primitive (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_value_t& value, /**< ecma-value */
ecma_completion_value_t
ecma_op_to_primitive (const ecma_value_t& value, /**< ecma-value */
ecma_preferred_type_hint_t preferred_type) /**< preferred type hint */
{
ecma_check_value_type_is_spec_defined (value);
if (ecma_is_value_object (value))
{
ecma_object_ptr_t obj_p;
ecma_get_object_from_value (obj_p, value);
ecma_object_t *obj_p = ecma_get_object_from_value (value);
ecma_op_object_default_value (ret_value, obj_p, preferred_type);
return ecma_op_object_default_value (obj_p, preferred_type);
}
else
{
ecma_value_t value_copy;
ecma_copy_value (value_copy, value, true);
ecma_make_normal_completion_value (ret_value, value_copy);
return ecma_make_normal_completion_value (ecma_copy_value (value, true));
}
} /* ecma_op_to_primitive */
@@ -196,23 +184,22 @@ ecma_op_to_primitive (ecma_completion_value_t &ret_value, /**< out: completion v
* Returned value is simple and so need not be freed.
* However, ecma_free_completion_value may be called for it, but it is a no-op.
*/
void
ecma_op_to_boolean (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_value_t& value) /**< ecma-value */
ecma_completion_value_t
ecma_op_to_boolean (const ecma_value_t& value) /**< ecma-value */
{
ecma_check_value_type_is_spec_defined (value);
ecma_simple_value_t boolean;
ecma_simple_value_t ret_value;
if (ecma_is_value_boolean (value))
{
boolean = (ecma_is_value_true (value) ?
ret_value = (ecma_is_value_true (value) ?
ECMA_SIMPLE_VALUE_TRUE : ECMA_SIMPLE_VALUE_FALSE);
}
else if (ecma_is_value_undefined (value)
|| ecma_is_value_null (value))
{
boolean = ECMA_SIMPLE_VALUE_FALSE;
ret_value = ECMA_SIMPLE_VALUE_FALSE;
}
else if (ecma_is_value_number (value))
{
@@ -221,11 +208,11 @@ ecma_op_to_boolean (ecma_completion_value_t &ret_value, /**< out: completion val
if (ecma_number_is_nan (*num_p)
|| ecma_number_is_zero (*num_p))
{
boolean = ECMA_SIMPLE_VALUE_FALSE;
ret_value = ECMA_SIMPLE_VALUE_FALSE;
}
else
{
boolean = ECMA_SIMPLE_VALUE_TRUE;
ret_value = ECMA_SIMPLE_VALUE_TRUE;
}
}
else if (ecma_is_value_string (value))
@@ -234,21 +221,21 @@ ecma_op_to_boolean (ecma_completion_value_t &ret_value, /**< out: completion val
if (ecma_string_get_length (str_p) == 0)
{
boolean = ECMA_SIMPLE_VALUE_FALSE;
ret_value = ECMA_SIMPLE_VALUE_FALSE;
}
else
{
boolean = ECMA_SIMPLE_VALUE_TRUE;
ret_value = ECMA_SIMPLE_VALUE_TRUE;
}
}
else
{
JERRY_ASSERT (ecma_is_value_object (value));
boolean = ECMA_SIMPLE_VALUE_TRUE;
ret_value = ECMA_SIMPLE_VALUE_TRUE;
}
ecma_make_simple_completion_value (ret_value, boolean);
return ecma_make_simple_completion_value (ret_value);
} /* ecma_op_to_boolean */
/**
@@ -260,18 +247,14 @@ ecma_op_to_boolean (ecma_completion_value_t &ret_value, /**< out: completion val
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_to_number (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_value_t& value) /**< ecma-value */
ecma_completion_value_t
ecma_op_to_number (const ecma_value_t& value) /**< ecma-value */
{
ecma_check_value_type_is_spec_defined (value);
if (ecma_is_value_number (value))
{
ecma_value_t value_copy;
ecma_copy_value (value_copy, value, true);
ecma_make_normal_completion_value (ret_value, value_copy);
return ecma_make_normal_completion_value (ecma_copy_value (value, true));
}
else if (ecma_is_value_string (value))
{
@@ -280,15 +263,21 @@ ecma_op_to_number (ecma_completion_value_t &ret_value, /**< out: completion valu
ecma_number_t *num_p = ecma_alloc_number ();
*num_p = ecma_string_to_number (str_p);
ecma_make_normal_completion_value (ret_value, ecma_value_t (num_p));
return ecma_make_normal_completion_value (ecma_make_number_value (num_p));
}
else if (ecma_is_value_object (value))
{
ECMA_TRY_CATCH (ret_value, ecma_op_to_primitive, primitive_value, value, ECMA_PREFERRED_TYPE_NUMBER);
ecma_completion_value_t ret_value;
ecma_op_to_number (ret_value, primitive_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
{
@@ -316,7 +305,7 @@ ecma_op_to_number (ecma_completion_value_t &ret_value, /**< out: completion valu
}
}
ecma_make_normal_completion_value (ret_value, ecma_value_t (num_p));
return ecma_make_normal_completion_value (ecma_make_number_value (num_p));
}
} /* ecma_op_to_number */
@@ -329,21 +318,24 @@ ecma_op_to_number (ecma_completion_value_t &ret_value, /**< out: completion valu
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_to_string (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_value_t& value) /**< ecma-value */
ecma_completion_value_t
ecma_op_to_string (const ecma_value_t& value) /**< ecma-value */
{
ecma_check_value_type_is_spec_defined (value);
if (unlikely (ecma_is_value_object (value)))
{
ECMA_TRY_CATCH (ret_value, ecma_op_to_primitive, prim_value, value, ECMA_PREFERRED_TYPE_STRING);
ecma_completion_value_t ret_value;
ecma_op_to_string (ret_value, prim_value);
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;
return ret_value;
}
else
{
@@ -381,7 +373,7 @@ ecma_op_to_string (ecma_completion_value_t &ret_value, /**< out: completion valu
}
}
ecma_make_normal_completion_value (ret_value, ecma_value_t (res_p));
return ecma_make_normal_completion_value (ecma_make_string_value (res_p));
}
} /* ecma_op_to_string */
@@ -394,41 +386,35 @@ ecma_op_to_string (ecma_completion_value_t &ret_value, /**< out: completion valu
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_to_object (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_value_t& value) /**< ecma-value */
ecma_completion_value_t
ecma_op_to_object (const ecma_value_t& value) /**< ecma-value */
{
ecma_check_value_type_is_spec_defined (value);
if (ecma_is_value_number (value))
{
ecma_op_create_number_object (ret_value, value);
return ecma_op_create_number_object (value);
}
else if (ecma_is_value_string (value))
{
ecma_op_create_string_object (ret_value, &value, 1);
return ecma_op_create_string_object (&value, 1);
}
else if (ecma_is_value_object (value))
{
ecma_value_t value_copy;
ecma_copy_value (value_copy, value, true);
ecma_make_normal_completion_value (ret_value, value_copy);
return ecma_make_normal_completion_value (ecma_copy_value (value, true));
}
else
{
if (ecma_is_value_undefined (value)
|| ecma_is_value_null (value))
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_TYPE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
JERRY_ASSERT (ecma_is_value_boolean (value));
ecma_op_create_boolean_object (ret_value, value);
return ecma_op_create_boolean_object (value);
}
}
} /* ecma_op_to_object */
@@ -441,12 +427,11 @@ ecma_op_to_object (ecma_completion_value_t &ret_value, /**< out: completion valu
*
* @return constructed object
*/
void
ecma_op_from_property_descriptor (ecma_object_ptr_t &obj_p, /**< out: object pointer */
const ecma_property_descriptor_t* src_prop_desc_p) /**< property descriptor */
ecma_object_t*
ecma_op_from_property_descriptor (const ecma_property_descriptor_t* src_prop_desc_p) /**< property descriptor */
{
// 2.
ecma_op_create_object_object_noarg (obj_p);
ecma_object_t *obj_p = ecma_op_create_object_object_noarg ();
ecma_completion_value_t completion;
ecma_property_descriptor_t prop_desc = ecma_make_empty_property_descriptor ();
@@ -473,25 +458,23 @@ ecma_op_from_property_descriptor (ecma_object_ptr_t &obj_p, /**< out: object poi
prop_desc.value = src_prop_desc_p->value;
ecma_string_t *value_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING_VALUE);
ecma_op_object_define_own_property (completion,
obj_p,
value_magic_string_p,
&prop_desc,
false);
completion = ecma_op_object_define_own_property (obj_p,
value_magic_string_p,
&prop_desc,
false);
ecma_deref_ecma_string (value_magic_string_p);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion));
// b.
const bool is_writable = (src_prop_desc_p->is_writable);
prop_desc.value = (ecma_value_packed_t) ecma_value_t (is_writable ? ECMA_SIMPLE_VALUE_TRUE
prop_desc.value = ecma_make_simple_value (is_writable ? ECMA_SIMPLE_VALUE_TRUE
: ECMA_SIMPLE_VALUE_FALSE);
ecma_string_t *writable_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING_WRITABLE);
ecma_op_object_define_own_property (completion,
obj_p,
writable_magic_string_p,
&prop_desc,
false);
completion = ecma_op_object_define_own_property (obj_p,
writable_magic_string_p,
&prop_desc,
false);
ecma_deref_ecma_string (writable_magic_string_p);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion));
}
@@ -503,67 +486,65 @@ ecma_op_from_property_descriptor (ecma_object_ptr_t &obj_p, /**< out: object poi
// a.
if (src_prop_desc_p->get_p == NULL)
{
prop_desc.value = (ecma_value_packed_t) ecma_value_t (ECMA_SIMPLE_VALUE_UNDEFINED);
prop_desc.value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
}
else
{
prop_desc.value = (ecma_value_packed_t) ecma_value_t (src_prop_desc_p->get_p);
prop_desc.value = ecma_make_object_value (src_prop_desc_p->get_p);
}
ecma_string_t *get_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING_GET);
ecma_op_object_define_own_property (completion,
obj_p,
get_magic_string_p,
&prop_desc,
false);
completion = ecma_op_object_define_own_property (obj_p,
get_magic_string_p,
&prop_desc,
false);
ecma_deref_ecma_string (get_magic_string_p);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion));
// b.
if (src_prop_desc_p->set_p == NULL)
{
prop_desc.value = (ecma_value_packed_t) ecma_value_t (ECMA_SIMPLE_VALUE_UNDEFINED);
prop_desc.value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
}
else
{
prop_desc.value = (ecma_value_packed_t) ecma_value_t (src_prop_desc_p->set_p);
prop_desc.value = ecma_make_object_value (src_prop_desc_p->set_p);
}
ecma_string_t *set_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING_SET);
ecma_op_object_define_own_property (completion,
obj_p,
set_magic_string_p,
&prop_desc,
false);
completion = ecma_op_object_define_own_property (obj_p,
set_magic_string_p,
&prop_desc,
false);
ecma_deref_ecma_string (set_magic_string_p);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion));
}
const bool is_enumerable = src_prop_desc_p->is_enumerable;
prop_desc.value = (ecma_value_packed_t) ecma_value_t (is_enumerable ? ECMA_SIMPLE_VALUE_TRUE
: ECMA_SIMPLE_VALUE_FALSE);
prop_desc.value = ecma_make_simple_value (is_enumerable ? ECMA_SIMPLE_VALUE_TRUE
: ECMA_SIMPLE_VALUE_FALSE);
ecma_string_t *enumerable_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING_ENUMERABLE);
ecma_op_object_define_own_property (completion,
obj_p,
enumerable_magic_string_p,
&prop_desc,
false);
completion = ecma_op_object_define_own_property (obj_p,
enumerable_magic_string_p,
&prop_desc,
false);
ecma_deref_ecma_string (enumerable_magic_string_p);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion));
const bool is_configurable = src_prop_desc_p->is_configurable;
prop_desc.value = (ecma_value_packed_t) ecma_value_t (is_configurable ? ECMA_SIMPLE_VALUE_TRUE
: ECMA_SIMPLE_VALUE_FALSE);
prop_desc.value = ecma_make_simple_value (is_configurable ? ECMA_SIMPLE_VALUE_TRUE
: ECMA_SIMPLE_VALUE_FALSE);
ecma_string_t *configurable_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING_CONFIGURABLE);
ecma_op_object_define_own_property (completion,
obj_p,
configurable_magic_string_p,
&prop_desc,
false);
completion = ecma_op_object_define_own_property (obj_p,
configurable_magic_string_p,
&prop_desc,
false);
ecma_deref_ecma_string (configurable_magic_string_p);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion));
return obj_p;
} /* ecma_op_from_property_descriptor */
/**
@@ -575,26 +556,22 @@ ecma_op_from_property_descriptor (ecma_object_ptr_t &obj_p, /**< out: object poi
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_to_property_descriptor (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_value_t& obj_value, /**< object value */
ecma_completion_value_t
ecma_op_to_property_descriptor (const ecma_value_t& obj_value, /**< object value */
ecma_property_descriptor_t *out_prop_desc_p) /**< out: filled property descriptor
if return value is normal
empty completion value */
{
ecma_make_empty_completion_value (ret_value);
ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
// 1.
if (!ecma_is_value_object (obj_value))
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_TYPE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
ecma_object_ptr_t obj_p;
ecma_get_object_from_value (obj_p, obj_value);
ecma_object_t *obj_p = ecma_get_object_from_value (obj_value);
// 2.
ecma_property_descriptor_t prop_desc = ecma_make_empty_property_descriptor ();
@@ -604,8 +581,12 @@ ecma_op_to_property_descriptor (ecma_completion_value_t &ret_value, /**< out: co
if (ecma_op_object_get_property (obj_p, enumerable_magic_string_p) != NULL)
{
ECMA_TRY_CATCH (ret_value, ecma_op_object_get, enumerable_prop_value, obj_p, enumerable_magic_string_p);
ECMA_TRY_CATCH (ret_value, ecma_op_to_boolean, boolean_enumerable_prop_value, enumerable_prop_value);
ECMA_TRY_CATCH (enumerable_prop_value,
ecma_op_object_get (obj_p, enumerable_magic_string_p),
ret_value);
ECMA_TRY_CATCH (boolean_enumerable_prop_value,
ecma_op_to_boolean (enumerable_prop_value),
ret_value);
prop_desc.is_enumerable_defined = true;
if (ecma_is_value_true (boolean_enumerable_prop_value))
@@ -634,8 +615,12 @@ ecma_op_to_property_descriptor (ecma_completion_value_t &ret_value, /**< out: co
if (ecma_op_object_get_property (obj_p, configurable_magic_string_p) != NULL)
{
ECMA_TRY_CATCH (ret_value, ecma_op_object_get, configurable_prop_value, obj_p, configurable_magic_string_p);
ECMA_TRY_CATCH (ret_value, ecma_op_to_boolean, boolean_configurable_prop_value, configurable_prop_value);
ECMA_TRY_CATCH (configurable_prop_value,
ecma_op_object_get (obj_p, configurable_magic_string_p),
ret_value);
ECMA_TRY_CATCH (boolean_configurable_prop_value,
ecma_op_to_boolean (configurable_prop_value),
ret_value);
prop_desc.is_configurable_defined = true;
if (ecma_is_value_true (boolean_configurable_prop_value))
@@ -665,13 +650,12 @@ ecma_op_to_property_descriptor (ecma_completion_value_t &ret_value, /**< out: co
if (ecma_op_object_get_property (obj_p, value_magic_string_p) != NULL)
{
ECMA_TRY_CATCH (ret_value, ecma_op_object_get, value_prop_value, obj_p, value_magic_string_p);
ecma_value_t value_copy;
ecma_copy_value (value_copy, value_prop_value, true);
ECMA_TRY_CATCH (value_prop_value,
ecma_op_object_get (obj_p, value_magic_string_p),
ret_value);
prop_desc.is_value_defined = true;
prop_desc.value = (ecma_value_packed_t) value_copy;
prop_desc.value = ecma_copy_value (value_prop_value, true);
ECMA_FINALIZE (value_prop_value);
}
@@ -688,8 +672,12 @@ ecma_op_to_property_descriptor (ecma_completion_value_t &ret_value, /**< out: co
if (ecma_op_object_get_property (obj_p, writable_magic_string_p) != NULL)
{
ECMA_TRY_CATCH (ret_value, ecma_op_object_get, writable_prop_value, obj_p, writable_magic_string_p);
ECMA_TRY_CATCH (ret_value, ecma_op_to_boolean, boolean_writable_prop_value, writable_prop_value);
ECMA_TRY_CATCH (writable_prop_value,
ecma_op_object_get (obj_p, writable_magic_string_p),
ret_value);
ECMA_TRY_CATCH (boolean_writable_prop_value,
ecma_op_to_boolean (writable_prop_value),
ret_value);
prop_desc.is_writable_defined = true;
if (ecma_is_value_true (boolean_writable_prop_value))
@@ -719,14 +707,14 @@ ecma_op_to_property_descriptor (ecma_completion_value_t &ret_value, /**< out: co
if (ecma_op_object_get_property (obj_p, get_magic_string_p) != NULL)
{
ECMA_TRY_CATCH (ret_value, ecma_op_object_get, get_prop_value, obj_p, get_magic_string_p);
ECMA_TRY_CATCH (get_prop_value,
ecma_op_object_get (obj_p, get_magic_string_p),
ret_value);
if (!ecma_op_is_callable (get_prop_value)
&& !ecma_is_value_undefined (get_prop_value))
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_TYPE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
@@ -740,11 +728,10 @@ ecma_op_to_property_descriptor (ecma_completion_value_t &ret_value, /**< out: co
{
JERRY_ASSERT (ecma_is_value_object (get_prop_value));
ecma_object_ptr_t get_p;
ecma_get_object_from_value (get_p, get_prop_value);
ecma_object_t *get_p = ecma_get_object_from_value (get_prop_value);
ecma_ref_object (get_p);
prop_desc.get_p = (ecma_object_t*) get_p;
prop_desc.get_p = get_p;
}
}
@@ -764,14 +751,14 @@ ecma_op_to_property_descriptor (ecma_completion_value_t &ret_value, /**< out: co
if (ecma_op_object_get_property (obj_p, set_magic_string_p) != NULL)
{
ECMA_TRY_CATCH (ret_value, ecma_op_object_get, set_prop_value, obj_p, set_magic_string_p);
ECMA_TRY_CATCH (set_prop_value,
ecma_op_object_get (obj_p, set_magic_string_p),
ret_value);
if (!ecma_op_is_callable (set_prop_value)
&& !ecma_is_value_undefined (set_prop_value))
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_TYPE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
@@ -785,11 +772,10 @@ ecma_op_to_property_descriptor (ecma_completion_value_t &ret_value, /**< out: co
{
JERRY_ASSERT (ecma_is_value_object (set_prop_value));
ecma_object_ptr_t set_p;
ecma_get_object_from_value (set_p, set_prop_value);
ecma_object_t *set_p = ecma_get_object_from_value (set_prop_value);
ecma_ref_object (set_p);
prop_desc.set_p = (ecma_object_t*) set_p;
prop_desc.set_p = set_p;
}
}
@@ -810,9 +796,7 @@ ecma_op_to_property_descriptor (ecma_completion_value_t &ret_value, /**< out: co
if (prop_desc.is_value_defined
|| prop_desc.is_writable_defined)
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_TYPE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
}
}
@@ -828,6 +812,8 @@ ecma_op_to_property_descriptor (ecma_completion_value_t &ret_value, /**< out: co
*out_prop_desc_p = prop_desc;
}
return ret_value;
} /* ecma_op_to_property_descriptor */
/**
src/libecmaoperations/ecma-conversion.h
+10 -27
View File
@@ -18,7 +18,6 @@
#include "ecma-globals.h"
#include "ecma-helpers.h"
#include "ecma-value.h"
/** \addtogroup ecma ECMA
* @{
@@ -38,35 +37,19 @@ typedef enum
ECMA_PREFERRED_TYPE_STRING /**< String */
} ecma_preferred_type_hint_t;
extern void
ecma_op_check_object_coercible (ecma_completion_value_t &ret_value,
const ecma_value_t& value);
extern ecma_completion_value_t ecma_op_check_object_coercible (const ecma_value_t& value);
extern bool ecma_op_same_value (const ecma_value_t& x,
const ecma_value_t& y);
extern void
ecma_op_to_primitive (ecma_completion_value_t &ret_value,
const ecma_value_t& value,
ecma_preferred_type_hint_t preferred_type);
extern void
ecma_op_to_boolean (ecma_completion_value_t &ret_value,
const ecma_value_t& value);
extern void
ecma_op_to_number (ecma_completion_value_t &ret_value,
const ecma_value_t& value);
extern void
ecma_op_to_string (ecma_completion_value_t &ret_value,
const ecma_value_t& value);
extern void
ecma_op_to_object (ecma_completion_value_t &ret_value,
const ecma_value_t& value);
extern ecma_completion_value_t ecma_op_to_primitive (const ecma_value_t& value,
ecma_preferred_type_hint_t preferred_type);
extern ecma_completion_value_t ecma_op_to_boolean (const ecma_value_t& value);
extern ecma_completion_value_t ecma_op_to_number (const ecma_value_t& value);
extern ecma_completion_value_t ecma_op_to_string (const ecma_value_t& value);
extern ecma_completion_value_t ecma_op_to_object (const ecma_value_t& value);
extern void
ecma_op_from_property_descriptor (ecma_object_ptr_t &ret_val,
const ecma_property_descriptor_t* src_prop_desc_p);
extern void
ecma_op_to_property_descriptor (ecma_completion_value_t &ret_value,
const ecma_value_t& obj_value,
ecma_property_descriptor_t *out_prop_desc_p);
extern ecma_object_t* ecma_op_from_property_descriptor (const ecma_property_descriptor_t* src_prop_desc_p);
extern ecma_completion_value_t ecma_op_to_property_descriptor (const ecma_value_t& obj_value,
ecma_property_descriptor_t *out_prop_desc_p);
/**
* @}
src/libecmaoperations/ecma-exceptions.c
+15 -12
View File
@@ -35,9 +35,8 @@
* @return pointer to ecma-object representing specified error
* with reference counter set to one.
*/
void
ecma_new_standard_error (ecma_object_ptr_t &new_error_obj_p, /**< out: object pointer */
ecma_standard_error_t error_type) /**< native error type */
ecma_object_t*
ecma_new_standard_error (ecma_standard_error_t error_type) /**< native error type */
{
#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS
ecma_builtin_id_t prototype_id = ECMA_BUILTIN_ID__COUNT;
@@ -87,20 +86,23 @@ ecma_new_standard_error (ecma_object_ptr_t &new_error_obj_p, /**< out: object po
}
}
ecma_object_ptr_t prototype_obj_p;
ecma_builtin_get (prototype_obj_p, prototype_id);
ecma_object_t *prototype_obj_p = ecma_builtin_get (prototype_id);
ecma_create_object (new_error_obj_p, prototype_obj_p, true, ECMA_OBJECT_TYPE_GENERAL);
ecma_object_t *new_error_obj_p = ecma_create_object (prototype_obj_p,
true,
ECMA_OBJECT_TYPE_GENERAL);
ecma_deref_object (prototype_obj_p);
ecma_property_t *class_prop_p = ecma_create_internal_property (new_error_obj_p,
ECMA_INTERNAL_PROPERTY_CLASS);
class_prop_p->u.internal_property.value = ECMA_MAGIC_STRING_ERROR_UL;
return new_error_obj_p;
#else /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS */
(void) error_type;
ecma_builtin_get (new_error_obj_p, ECMA_BUILTIN_ID_COMPACT_PROFILE_ERROR);
return ecma_builtin_get (ECMA_BUILTIN_ID_COMPACT_PROFILE_ERROR);
#endif /* CONFIG_ECMA_COMPACT_PROFILE_DISABLE_ERROR_BUILTINS */
} /* ecma_new_standard_error */
@@ -110,12 +112,11 @@ ecma_new_standard_error (ecma_object_ptr_t &new_error_obj_p, /**< out: object po
* @return pointer to ecma-object representing specified error
* with reference counter set to one.
*/
void
ecma_new_standard_error_with_message (ecma_object_ptr_t &new_error_obj_p, /**< out: object pointer */
ecma_standard_error_t error_type, /**< native error type */
ecma_object_t*
ecma_new_standard_error_with_message (ecma_standard_error_t error_type, /**< native error type */
ecma_string_t* message_string_p) /**< message string */
{
ecma_new_standard_error (new_error_obj_p, error_type);
ecma_object_t *new_error_obj_p = ecma_new_standard_error (error_type);
ecma_string_t *message_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING_MESSAGE);
ecma_property_t *prop_p = ecma_create_named_data_property (new_error_obj_p,
@@ -123,8 +124,10 @@ ecma_new_standard_error_with_message (ecma_object_ptr_t &new_error_obj_p, /**< o
true, false, true);
ecma_set_named_data_property_value (prop_p,
ecma_value_t (ecma_copy_or_ref_ecma_string (message_string_p)));
ecma_make_string_value (ecma_copy_or_ref_ecma_string (message_string_p)));
ecma_deref_ecma_string (message_magic_string_p);
return new_error_obj_p;
} /* ecma_new_standard_error_with_message */
/**
src/libecmaoperations/ecma-exceptions.h
+3 -7
View File
@@ -44,13 +44,9 @@ typedef enum
ECMA_ERROR_URI /**< URIError */
} ecma_standard_error_t;
extern void
ecma_new_standard_error (ecma_object_ptr_t &ret_val,
ecma_standard_error_t error_type);
extern void
ecma_new_standard_error_with_message (ecma_object_ptr_t &ret_val,
ecma_standard_error_t error_type,
ecma_string_t *message_string_p);
extern ecma_object_t *ecma_new_standard_error (ecma_standard_error_t error_type);
extern ecma_object_t* ecma_new_standard_error_with_message (ecma_standard_error_t error_type,
ecma_string_t *message_string_p);
/**
* @}
src/libecmaoperations/ecma-function-object.c
+160 -194
View File
@@ -94,10 +94,9 @@ ecma_op_is_callable (const ecma_value_t& value) /**< ecma-value */
return false;
}
ecma_object_ptr_t obj_p;
ecma_get_object_from_value (obj_p, value);
ecma_object_t *obj_p = ecma_get_object_from_value (value);
JERRY_ASSERT(obj_p.is_not_null ());
JERRY_ASSERT(obj_p != NULL);
JERRY_ASSERT(!ecma_is_lexical_environment (obj_p));
return (ecma_get_object_type (obj_p) == ECMA_OBJECT_TYPE_FUNCTION
@@ -119,10 +118,9 @@ ecma_is_constructor (const ecma_value_t& value) /**< ecma-value */
return false;
}
ecma_object_ptr_t obj_p;
ecma_get_object_from_value (obj_p, value);
ecma_object_t *obj_p = ecma_get_object_from_value (value);
JERRY_ASSERT(obj_p.is_not_null ());
JERRY_ASSERT(obj_p != NULL);
JERRY_ASSERT(!ecma_is_lexical_environment (obj_p));
return (ecma_get_object_type (obj_p) == ECMA_OBJECT_TYPE_FUNCTION
@@ -136,19 +134,17 @@ ecma_is_constructor (const ecma_value_t& value) /**< ecma-value */
*
* @return pointer to newly created Function object
*/
void
ecma_op_create_function_object (ecma_object_ptr_t &function_obj_p, /**< out: object pointer */
ecma_string_t* formal_parameter_list_p[], /**< formal parameters list */
ecma_object_t*
ecma_op_create_function_object (ecma_string_t* formal_parameter_list_p[], /**< formal parameters list */
ecma_length_t formal_parameters_number, /**< formal parameters list's length */
const ecma_object_ptr_t& scope_p, /**< function's scope */
ecma_object_t *scope_p, /**< function's scope */
bool is_strict, /**< 'strict' flag */
opcode_counter_t first_opcode_idx) /**< index of first opcode of function's body */
{
// 1., 4., 13.
ecma_object_ptr_t prototype_obj_p;
ecma_builtin_get (prototype_obj_p, ECMA_BUILTIN_ID_FUNCTION_PROTOTYPE);
ecma_object_t *prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_FUNCTION_PROTOTYPE);
ecma_create_object (function_obj_p, prototype_obj_p, true, ECMA_OBJECT_TYPE_FUNCTION);
ecma_object_t *f = ecma_create_object (prototype_obj_p, true, ECMA_OBJECT_TYPE_FUNCTION);
ecma_deref_object (prototype_obj_p);
@@ -160,19 +156,16 @@ ecma_op_create_function_object (ecma_object_ptr_t &function_obj_p, /**< out: obj
*/
// 3.
ecma_property_t *class_prop_p = ecma_create_internal_property (function_obj_p, ECMA_INTERNAL_PROPERTY_CLASS);
ecma_property_t *class_prop_p = ecma_create_internal_property (f, ECMA_INTERNAL_PROPERTY_CLASS);
class_prop_p->u.internal_property.value = ECMA_MAGIC_STRING_FUNCTION_UL;
// 9.
ecma_property_t *scope_prop_p = ecma_create_internal_property (function_obj_p, ECMA_INTERNAL_PROPERTY_SCOPE);
{
ecma_object_t *scope_tmp_p = (ecma_object_t*) scope_p;
ECMA_SET_POINTER(scope_prop_p->u.internal_property.value, scope_tmp_p);
}
ecma_gc_update_may_ref_younger_object_flag_by_object (function_obj_p, scope_p);
ecma_property_t *scope_prop_p = ecma_create_internal_property (f, ECMA_INTERNAL_PROPERTY_SCOPE);
ECMA_SET_POINTER(scope_prop_p->u.internal_property.value, scope_p);
ecma_gc_update_may_ref_younger_object_flag_by_object (f, scope_p);
// 10., 11.
ecma_property_t *formal_parameters_prop_p = ecma_create_internal_property (function_obj_p,
ecma_property_t *formal_parameters_prop_p = ecma_create_internal_property (f,
ECMA_INTERNAL_PROPERTY_FORMAL_PARAMETERS);
if (formal_parameters_number != 0)
{
@@ -186,7 +179,7 @@ ecma_op_create_function_object (ecma_object_ptr_t &function_obj_p, /**< out: obj
}
// 12.
ecma_property_t *code_prop_p = ecma_create_internal_property (function_obj_p, ECMA_INTERNAL_PROPERTY_CODE);
ecma_property_t *code_prop_p = ecma_create_internal_property (f, ECMA_INTERNAL_PROPERTY_CODE);
code_prop_p->u.internal_property.value = ecma_pack_code_internal_property_value (is_strict,
first_opcode_idx);
@@ -197,15 +190,13 @@ ecma_op_create_function_object (ecma_object_ptr_t &function_obj_p, /**< out: obj
// 15.
ecma_property_descriptor_t length_prop_desc = ecma_make_empty_property_descriptor ();
length_prop_desc.is_value_defined = true;
length_prop_desc.value = (ecma_value_packed_t) ecma_value_t (len_p);
length_prop_desc.value = ecma_make_number_value (len_p);
ecma_string_t* magic_string_length_p = ecma_get_magic_string (ECMA_MAGIC_STRING_LENGTH);
ecma_completion_value_t completion;
ecma_op_object_define_own_property (completion,
function_obj_p,
magic_string_length_p,
&length_prop_desc,
false);
ecma_completion_value_t completion = ecma_op_object_define_own_property (f,
magic_string_length_p,
&length_prop_desc,
false);
ecma_deref_ecma_string (magic_string_length_p);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion)
@@ -215,14 +206,13 @@ ecma_op_create_function_object (ecma_object_ptr_t &function_obj_p, /**< out: obj
len_p = NULL;
// 16.
ecma_object_ptr_t proto_p;
ecma_op_create_object_object_noarg (proto_p);
ecma_object_t *proto_p = ecma_op_create_object_object_noarg ();
// 17.
ecma_property_descriptor_t prop_desc = ecma_make_empty_property_descriptor ();
{
prop_desc.is_value_defined = true;
prop_desc.value = (ecma_value_packed_t) ecma_value_t (function_obj_p);
prop_desc.value = ecma_make_object_value (f);
prop_desc.is_writable_defined = true;
prop_desc.is_writable = true;
@@ -235,28 +225,20 @@ ecma_op_create_function_object (ecma_object_ptr_t &function_obj_p, /**< out: obj
}
ecma_string_t *magic_string_constructor_p = ecma_get_magic_string (ECMA_MAGIC_STRING_CONSTRUCTOR);
ecma_op_object_define_own_property (completion,
proto_p,
ecma_op_object_define_own_property (proto_p,
magic_string_constructor_p,
&prop_desc,
false);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion)
|| ecma_is_completion_value_normal_false (completion));
ecma_deref_ecma_string (magic_string_constructor_p);
// 18.
prop_desc.value = (ecma_value_packed_t) ecma_value_t (proto_p);
prop_desc.value = ecma_make_object_value (proto_p);
prop_desc.is_configurable = false;
ecma_string_t *magic_string_prototype_p = ecma_get_magic_string (ECMA_MAGIC_STRING_PROTOTYPE);
ecma_op_object_define_own_property (completion,
function_obj_p,
ecma_op_object_define_own_property (f,
magic_string_prototype_p,
&prop_desc,
false);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion)
|| ecma_is_completion_value_normal_false (completion));
ecma_deref_ecma_string (magic_string_prototype_p);
ecma_deref_object (proto_p);
@@ -264,8 +246,7 @@ ecma_op_create_function_object (ecma_object_ptr_t &function_obj_p, /**< out: obj
// 19.
if (is_strict)
{
ecma_object_ptr_t thrower_p;
ecma_builtin_get (thrower_p, ECMA_BUILTIN_ID_TYPE_ERROR_THROWER);
ecma_object_t *thrower_p = ecma_builtin_get (ECMA_BUILTIN_ID_TYPE_ERROR_THROWER);
prop_desc = ecma_make_empty_property_descriptor ();
{
@@ -276,36 +257,30 @@ ecma_op_create_function_object (ecma_object_ptr_t &function_obj_p, /**< out: obj
prop_desc.is_configurable = false;
prop_desc.is_get_defined = true;
prop_desc.get_p = (ecma_object_t*) thrower_p;
prop_desc.get_p = thrower_p;
prop_desc.is_set_defined = true;
prop_desc.set_p = (ecma_object_t*) thrower_p;
prop_desc.set_p = thrower_p;
}
ecma_string_t *magic_string_caller_p = ecma_get_magic_string (ECMA_MAGIC_STRING_CALLER);
ecma_op_object_define_own_property (completion,
function_obj_p,
ecma_op_object_define_own_property (f,
magic_string_caller_p,
&prop_desc,
false);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion)
|| ecma_is_completion_value_normal_false (completion));
ecma_deref_ecma_string (magic_string_caller_p);
ecma_string_t *magic_string_arguments_p = ecma_get_magic_string (ECMA_MAGIC_STRING_ARGUMENTS);
ecma_op_object_define_own_property (completion,
function_obj_p,
ecma_op_object_define_own_property (f,
magic_string_arguments_p,
&prop_desc,
false);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion)
|| ecma_is_completion_value_normal_false (completion));
ecma_deref_ecma_string (magic_string_arguments_p);
ecma_deref_object (thrower_p);
}
return f;
} /* ecma_op_create_function_object */
/**
@@ -317,10 +292,9 @@ ecma_op_create_function_object (ecma_object_ptr_t &function_obj_p, /**< out: obj
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
static void
ecma_function_call_setup_args_variables (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& func_obj_p, /**< Function object */
const ecma_object_ptr_t& env_p, /**< lexical environment */
static ecma_completion_value_t
ecma_function_call_setup_args_variables (ecma_object_t *func_obj_p, /**< Function object */
ecma_object_t *env_p, /**< lexical environment */
const ecma_value_t *arguments_list_p, /**< arguments list */
ecma_length_t arguments_list_len, /**< length of argument list */
bool is_strict) /**< flag indicating strict mode */
@@ -333,8 +307,7 @@ ecma_function_call_setup_args_variables (ecma_completion_value_t &ret_value, /**
if (formal_parameters_p == NULL)
{
ecma_make_empty_completion_value (ret_value);
return;
return ecma_make_empty_completion_value ();
}
ecma_length_t formal_parameters_count = formal_parameters_p->unit_number;
@@ -346,8 +319,12 @@ ecma_function_call_setup_args_variables (ecma_completion_value_t &ret_value, /**
n < formal_parameters_count;
n++)
{
ecma_value_t v (ECMA_SIMPLE_VALUE_UNDEFINED);
if (n < arguments_list_len)
ecma_value_t v;
if (n >= arguments_list_len)
{
v = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
}
else
{
v = arguments_list_p[n];
}
@@ -355,43 +332,37 @@ ecma_function_call_setup_args_variables (ecma_completion_value_t &ret_value, /**
bool is_moved = ecma_collection_iterator_next (&formal_params_iterator);
JERRY_ASSERT (is_moved);
ecma_value_t formal_parameter_name_value (*formal_params_iterator.current_value_p);
ecma_value_t formal_parameter_name_value = *formal_params_iterator.current_value_p;
ecma_string_t *formal_parameter_name_string_p = ecma_get_string_from_value (formal_parameter_name_value);
bool arg_already_declared = ecma_op_has_binding (env_p, formal_parameter_name_string_p);
if (!arg_already_declared)
{
ecma_completion_value_t completion;
ecma_op_create_mutable_binding (completion,
env_p,
formal_parameter_name_string_p,
false);
ecma_completion_value_t completion = ecma_op_create_mutable_binding (env_p,
formal_parameter_name_string_p,
false);
if (ecma_is_completion_value_throw (completion))
{
ret_value = completion;
return;
return completion;
}
JERRY_ASSERT (ecma_is_completion_value_empty (completion));
ecma_op_set_mutable_binding (completion,
env_p,
formal_parameter_name_string_p,
v,
is_strict);
completion = ecma_op_set_mutable_binding (env_p,
formal_parameter_name_string_p,
v,
is_strict);
if (ecma_is_completion_value_throw (completion))
{
ret_value = completion;
return;
return completion;
}
JERRY_ASSERT (ecma_is_completion_value_empty (completion));
}
}
ecma_make_empty_completion_value (ret_value);
return;
return ecma_make_empty_completion_value ();
} /* ecma_function_call_setup_args_variables */
/**
@@ -404,55 +375,52 @@ ecma_function_call_setup_args_variables (ecma_completion_value_t &ret_value, /**
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_function_has_instance (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& func_obj_p, /**< Function object */
ecma_completion_value_t
ecma_op_function_has_instance (ecma_object_t *func_obj_p, /**< Function object */
const ecma_value_t& value) /**< argument 'V' */
{
JERRY_ASSERT(func_obj_p.is_not_null ()
JERRY_ASSERT(func_obj_p != NULL
&& !ecma_is_lexical_environment (func_obj_p));
if (ecma_get_object_type (func_obj_p) == ECMA_OBJECT_TYPE_FUNCTION)
{
if (!ecma_is_value_object (value))
{
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_FALSE);
return;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE);
}
ecma_object_ptr_t v_obj_p;
ecma_get_object_from_value (v_obj_p, value);
ecma_object_t* v_obj_p = ecma_get_object_from_value (value);
ecma_string_t *prototype_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING_PROTOTYPE);
ECMA_TRY_CATCH (ret_value, ecma_op_object_get, prototype_obj_value, func_obj_p, prototype_magic_string_p);
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (prototype_obj_value,
ecma_op_object_get (func_obj_p, prototype_magic_string_p),
ret_value);
if (!ecma_is_value_object (prototype_obj_value))
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_TYPE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
return;
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
ecma_object_ptr_t prototype_obj_p;
ecma_get_object_from_value (prototype_obj_p, prototype_obj_value);
JERRY_ASSERT (prototype_obj_p.is_not_null ());
ecma_object_t *prototype_obj_p = ecma_get_object_from_value (prototype_obj_value);
JERRY_ASSERT (prototype_obj_p != NULL);
do
{
ecma_get_object_prototype (v_obj_p, v_obj_p);
v_obj_p = ecma_get_object_prototype (v_obj_p);
if (v_obj_p.is_null ())
if (v_obj_p == NULL)
{
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_FALSE);
ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE);
break;
}
else if (v_obj_p == prototype_obj_p)
{
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_TRUE);
ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
break;
}
@@ -462,12 +430,12 @@ ecma_op_function_has_instance (ecma_completion_value_t &ret_value, /**< out: com
ECMA_FINALIZE (prototype_obj_value);
ecma_deref_ecma_string (prototype_magic_string_p);
return ret_value;
}
else if (ecma_get_object_type (func_obj_p) == ECMA_OBJECT_TYPE_BUILT_IN_FUNCTION)
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_TYPE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
@@ -487,33 +455,33 @@ ecma_op_function_has_instance (ecma_completion_value_t &ret_value, /**< out: com
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_function_call (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& func_obj_p, /**< Function object */
ecma_completion_value_t
ecma_op_function_call (ecma_object_t *func_obj_p, /**< Function object */
const ecma_value_t& this_arg_value, /**< 'this' argument's value */
const ecma_value_t* arguments_list_p, /**< arguments list */
ecma_length_t arguments_list_len) /**< length of arguments list */
{
JERRY_ASSERT(func_obj_p.is_not_null ()
JERRY_ASSERT(func_obj_p != NULL
&& !ecma_is_lexical_environment (func_obj_p));
JERRY_ASSERT(ecma_op_is_callable (ecma_value_t (func_obj_p)));
JERRY_ASSERT(ecma_op_is_callable (ecma_make_object_value (func_obj_p)));
JERRY_ASSERT(arguments_list_len == 0 || arguments_list_p != NULL);
if (ecma_get_object_type (func_obj_p) == ECMA_OBJECT_TYPE_FUNCTION)
{
if (unlikely (ecma_get_object_is_builtin (func_obj_p)))
{
ecma_builtin_dispatch_call (ret_value, func_obj_p, this_arg_value, arguments_list_p, arguments_list_len);
return;
return ecma_builtin_dispatch_call (func_obj_p, this_arg_value, arguments_list_p, arguments_list_len);
}
ecma_completion_value_t ret_value;
/* Entering Function Code (ECMA-262 v5, 10.4.3) */
ecma_property_t *scope_prop_p = ecma_get_internal_property (func_obj_p, ECMA_INTERNAL_PROPERTY_SCOPE);
ecma_property_t *code_prop_p = ecma_get_internal_property (func_obj_p, ECMA_INTERNAL_PROPERTY_CODE);
ecma_object_ptr_t scope_p;
scope_p.unpack_from (scope_prop_p->u.internal_property.value);
ecma_object_t *scope_p = ECMA_GET_NON_NULL_POINTER (ecma_object_t,
scope_prop_p->u.internal_property.value);
uint32_t code_prop_value = code_prop_p->u.internal_property.value;
bool is_strict;
@@ -524,61 +492,59 @@ ecma_op_function_call (ecma_completion_value_t &ret_value, /**< out: completion
// 1.
if (is_strict)
{
ecma_copy_value (this_binding, this_arg_value, true);
this_binding = ecma_copy_value (this_arg_value, true);
}
else if (ecma_is_value_undefined (this_arg_value)
|| ecma_is_value_null (this_arg_value))
{
// 2.
ecma_object_ptr_t global_obj_p;
ecma_builtin_get (global_obj_p, ECMA_BUILTIN_ID_GLOBAL);
this_binding = global_obj_p;
this_binding = ecma_make_object_value (ecma_builtin_get (ECMA_BUILTIN_ID_GLOBAL));
}
else
{
// 3., 4.
ecma_completion_value_t to_obj_completion;
ecma_op_to_object (to_obj_completion, this_arg_value);
JERRY_ASSERT (ecma_is_completion_value_normal (to_obj_completion));
ecma_completion_value_t completion = ecma_op_to_object (this_arg_value);
JERRY_ASSERT (ecma_is_completion_value_normal (completion));
ecma_get_completion_value_value (this_binding, to_obj_completion);
this_binding = ecma_get_completion_value_value (completion);
}
// 5.
ecma_object_ptr_t local_env_p;
ecma_create_decl_lex_env (local_env_p, scope_p);
ecma_object_t *local_env_p = ecma_create_decl_lex_env (scope_p);
// 9.
ECMA_TRY_CATCH (ret_value, ecma_function_call_setup_args_variables, args_var_declaration_ret,
func_obj_p, local_env_p, arguments_list_p, arguments_list_len, is_strict);
ECMA_TRY_CATCH (args_var_declaration_ret,
ecma_function_call_setup_args_variables (func_obj_p,
local_env_p,
arguments_list_p,
arguments_list_len,
is_strict),
ret_value);
ecma_completion_value_t run_completion;
run_int_from_pos (run_completion,
code_first_opcode_idx,
this_binding,
local_env_p,
is_strict,
false);
if (ecma_is_completion_value_return (run_completion))
ecma_completion_value_t completion = run_int_from_pos (code_first_opcode_idx,
this_binding,
local_env_p,
is_strict,
false);
if (ecma_is_completion_value_return (completion))
{
ecma_value_t value_to_ret;
ecma_get_completion_value_value (value_to_ret, run_completion);
ecma_make_normal_completion_value (ret_value, value_to_ret);
ret_value = ecma_make_normal_completion_value (ecma_get_completion_value_value (completion));
}
else
{
ret_value = run_completion;
ret_value = completion;
}
ECMA_FINALIZE (args_var_declaration_ret);
ecma_deref_object (local_env_p);
ecma_free_value (this_binding, true);
return ret_value;
}
else if (ecma_get_object_type (func_obj_p) == ECMA_OBJECT_TYPE_BUILT_IN_FUNCTION)
{
ecma_builtin_dispatch_call (ret_value, func_obj_p, this_arg_value, arguments_list_p, arguments_list_len);
return ecma_builtin_dispatch_call (func_obj_p, this_arg_value, arguments_list_p, arguments_list_len);
}
else
{
@@ -596,47 +562,48 @@ ecma_op_function_call (ecma_completion_value_t &ret_value, /**< out: completion
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_function_construct (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& func_obj_p, /**< Function object */
ecma_completion_value_t
ecma_op_function_construct (ecma_object_t *func_obj_p, /**< Function object */
const ecma_value_t* arguments_list_p, /**< arguments list */
ecma_length_t arguments_list_len) /**< length of arguments list */
{
JERRY_ASSERT(func_obj_p.is_not_null ()
JERRY_ASSERT(func_obj_p != NULL
&& !ecma_is_lexical_environment (func_obj_p));
JERRY_ASSERT(ecma_is_constructor (ecma_value_t (func_obj_p)));
JERRY_ASSERT(ecma_is_constructor (ecma_make_object_value (func_obj_p)));
JERRY_ASSERT(arguments_list_len == 0 || arguments_list_p != NULL);
if (ecma_get_object_type (func_obj_p) == ECMA_OBJECT_TYPE_FUNCTION)
{
if (unlikely (ecma_get_object_is_builtin (func_obj_p)))
{
ecma_builtin_dispatch_construct (ret_value, func_obj_p, arguments_list_p, arguments_list_len);
return;
return ecma_builtin_dispatch_construct (func_obj_p, arguments_list_p, arguments_list_len);
}
ecma_completion_value_t ret_value;
ecma_string_t *prototype_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING_PROTOTYPE);
// 5.
ECMA_TRY_CATCH (ret_value,
ecma_op_object_get, func_obj_prototype_prop_value, func_obj_p, prototype_magic_string_p);
ECMA_TRY_CATCH (func_obj_prototype_prop_value,
ecma_op_object_get (func_obj_p,
prototype_magic_string_p),
ret_value);
// 6.
ecma_object_ptr_t prototype_p;
ecma_object_t *prototype_p;
if (ecma_is_value_object (func_obj_prototype_prop_value))
{
ecma_get_object_from_value (prototype_p, func_obj_prototype_prop_value);
prototype_p = ecma_get_object_from_value (func_obj_prototype_prop_value);
ecma_ref_object (prototype_p);
}
else
{
// 7.
ecma_builtin_get (prototype_p, ECMA_BUILTIN_ID_OBJECT_PROTOTYPE);
prototype_p = ecma_builtin_get (ECMA_BUILTIN_ID_OBJECT_PROTOTYPE);
}
// 1., 2., 4.
ecma_object_ptr_t obj_p;
ecma_create_object (obj_p, prototype_p, true, ECMA_OBJECT_TYPE_GENERAL);
ecma_object_t *obj_p = ecma_create_object (prototype_p, true, ECMA_OBJECT_TYPE_GENERAL);
// 3.
ecma_property_t *class_prop_p = ecma_create_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_CLASS);
@@ -645,9 +612,12 @@ ecma_op_function_construct (ecma_completion_value_t &ret_value, /**< out: comple
ecma_deref_object (prototype_p);
// 8.
ECMA_TRY_CATCH (ret_value,
ecma_op_function_call, call_completion,
func_obj_p, ecma_value_t (obj_p), arguments_list_p, arguments_list_len);
ECMA_TRY_CATCH (call_completion,
ecma_op_function_call (func_obj_p,
ecma_make_object_value (obj_p),
arguments_list_p,
arguments_list_len),
ret_value);
ecma_value_t obj_value;
@@ -656,20 +626,22 @@ ecma_op_function_construct (ecma_completion_value_t &ret_value, /**< out: comple
{
ecma_deref_object (obj_p);
ecma_copy_value (obj_value, call_completion, true);
obj_value = ecma_copy_value (call_completion, true);
}
else
{
// 10.
obj_value = obj_p;
obj_value = ecma_make_object_value (obj_p);
}
ecma_make_normal_completion_value (ret_value, obj_value);
ret_value = ecma_make_normal_completion_value (obj_value);
ECMA_FINALIZE (call_completion);
ECMA_FINALIZE (func_obj_prototype_prop_value);
ecma_deref_ecma_string (prototype_magic_string_p);
return ret_value;
}
else
{
@@ -686,9 +658,8 @@ ecma_op_function_construct (ecma_completion_value_t &ret_value, /**< out: comple
* @return completion value
* returned value must be freed with ecma_free_completion_value.
*/
void
ecma_op_function_declaration (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& lex_env_p, /**< lexical environment */
ecma_completion_value_t
ecma_op_function_declaration (ecma_object_t *lex_env_p, /**< lexical environment */
ecma_string_t *function_name_p, /**< function name */
opcode_counter_t function_code_opcode_idx, /**< index of first opcode of function code */
ecma_string_t* formal_parameter_list_p[], /**< formal parameters list */
@@ -698,33 +669,30 @@ ecma_op_function_declaration (ecma_completion_value_t &ret_value, /**< out: comp
is declared in eval code */
{
// b.
ecma_object_ptr_t func_obj_p;
ecma_op_create_function_object (func_obj_p,
formal_parameter_list_p,
formal_parameter_list_length,
lex_env_p,
is_strict,
function_code_opcode_idx);
ecma_object_t *func_obj_p = ecma_op_create_function_object (formal_parameter_list_p,
formal_parameter_list_length,
lex_env_p,
is_strict,
function_code_opcode_idx);
// c.
bool func_already_declared = ecma_op_has_binding (lex_env_p, function_name_p);
// d.
ecma_completion_value_t completion;
ecma_completion_value_t completion = ecma_make_empty_completion_value ();
if (!func_already_declared)
{
ecma_op_create_mutable_binding (completion,
lex_env_p,
function_name_p,
is_configurable_bindings);
completion = ecma_op_create_mutable_binding (lex_env_p,
function_name_p,
is_configurable_bindings);
JERRY_ASSERT (ecma_is_completion_value_empty (completion));
}
else if (ecma_is_lexical_environment_global (lex_env_p))
{
// e.
ecma_object_ptr_t glob_obj_p;
ecma_builtin_get (glob_obj_p, ECMA_BUILTIN_ID_GLOBAL);
ecma_object_t *glob_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_GLOBAL);
ecma_property_t *existing_prop_p = ecma_op_object_get_property (glob_obj_p, function_name_p);
@@ -733,7 +701,7 @@ ecma_op_function_declaration (ecma_completion_value_t &ret_value, /**< out: comp
ecma_property_descriptor_t property_desc = ecma_make_empty_property_descriptor ();
{
property_desc.is_value_defined = true;
property_desc.value = (ecma_value_packed_t) ecma_value_t (ECMA_SIMPLE_VALUE_UNDEFINED);
property_desc.value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
property_desc.is_writable_defined = true;
property_desc.is_writable = true;
@@ -745,17 +713,14 @@ ecma_op_function_declaration (ecma_completion_value_t &ret_value, /**< out: comp
property_desc.is_configurable = is_configurable_bindings;
}
ecma_op_object_define_own_property (completion,
glob_obj_p,
function_name_p,
&property_desc,
true);
completion = ecma_op_object_define_own_property (glob_obj_p,
function_name_p,
&property_desc,
true);
}
else if (existing_prop_p->type == ECMA_PROPERTY_NAMEDACCESSOR)
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_TYPE);
ecma_make_throw_obj_completion_value (completion, exception_obj_p);
completion = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
@@ -764,15 +729,15 @@ ecma_op_function_declaration (ecma_completion_value_t &ret_value, /**< out: comp
if (!ecma_is_property_writable (existing_prop_p)
|| !ecma_is_property_enumerable (existing_prop_p))
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_TYPE);
ecma_make_throw_obj_completion_value (completion, exception_obj_p);
completion = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
}
ecma_deref_object (glob_obj_p);
}
ecma_completion_value_t ret_value;
if (ecma_is_completion_value_throw (completion))
{
ret_value = completion;
@@ -782,14 +747,15 @@ ecma_op_function_declaration (ecma_completion_value_t &ret_value, /**< out: comp
JERRY_ASSERT (ecma_is_completion_value_empty (completion));
// f.
ecma_op_set_mutable_binding (ret_value,
lex_env_p,
function_name_p,
ecma_value_t (func_obj_p),
is_strict);
ret_value = ecma_op_set_mutable_binding (lex_env_p,
function_name_p,
ecma_make_object_value (func_obj_p),
is_strict);
}
ecma_deref_object (func_obj_p);
return ret_value;
} /* ecma_op_function_declaration */
/**
src/libecmaoperations/ecma-function-object.h
+11 -17
View File
@@ -17,7 +17,6 @@
#define ECMA_FUNCTION_OBJECT_H
#include "ecma-globals.h"
#include "ecma-value.h"
#include "interpreter.h"
/** \addtogroup ecma ECMA
@@ -30,35 +29,30 @@
extern bool ecma_op_is_callable (const ecma_value_t& value);
extern bool ecma_is_constructor (const ecma_value_t& value);
extern void
ecma_op_create_function_object (ecma_object_ptr_t &ret_val,
ecma_string_t* formal_parameter_list_p[],
extern ecma_object_t*
ecma_op_create_function_object (ecma_string_t* formal_parameter_list_p[],
ecma_length_t formal_parameters_number,
const ecma_object_ptr_t& scope_p,
ecma_object_t *scope_p,
bool is_strict,
opcode_counter_t first_opcode_idx);
extern void
ecma_op_function_call (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& func_obj_p,
extern ecma_completion_value_t
ecma_op_function_call (ecma_object_t *func_obj_p,
const ecma_value_t& this_arg_value,
const ecma_value_t* arguments_list_p,
ecma_length_t arguments_list_len);
extern void
ecma_op_function_construct (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& func_obj_p,
extern ecma_completion_value_t
ecma_op_function_construct (ecma_object_t *func_obj_p,
const ecma_value_t* arguments_list_p,
ecma_length_t arguments_list_len);
extern void
ecma_op_function_has_instance (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& func_obj_p,
extern ecma_completion_value_t
ecma_op_function_has_instance (ecma_object_t *func_obj_p,
const ecma_value_t& value);
extern void
ecma_op_function_declaration (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& lex_env_p,
extern ecma_completion_value_t
ecma_op_function_declaration (ecma_object_t *lex_env_p,
ecma_string_t *function_name_p,
opcode_counter_t function_code_opcode_idx,
ecma_string_t* formal_parameter_list_p[],
src/libecmaoperations/ecma-get-put-value.c
+79 -100
View File
@@ -43,33 +43,27 @@
* @return completion value
* Returned value must be freed with ecma_free_completion_value.
*/
void
ecma_op_get_value_lex_env_base (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& ref_base_lex_env_p, /**< reference's base
* (lexical environment) */
ecma_completion_value_t
ecma_op_get_value_lex_env_base (ecma_object_t *ref_base_lex_env_p, /**< reference's base (lexical environment) */
ecma_string_t *var_name_string_p, /**< variable name */
bool is_strict) /**< flag indicating strict mode */
{
const bool is_unresolvable_reference = (ref_base_lex_env_p.is_null ());
const bool is_unresolvable_reference = (ref_base_lex_env_p == NULL);
// 3.
if (unlikely (is_unresolvable_reference))
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_REFERENCE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
return;
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_REFERENCE));
}
// 5.
JERRY_ASSERT(ref_base_lex_env_p.is_not_null ()
JERRY_ASSERT(ref_base_lex_env_p != NULL
&& ecma_is_lexical_environment (ref_base_lex_env_p));
// 5.a
ecma_op_get_binding_value (ret_value,
ref_base_lex_env_p,
var_name_string_p,
is_strict);
return ecma_op_get_binding_value (ref_base_lex_env_p,
var_name_string_p,
is_strict);
} /* ecma_op_get_value_lex_env_base */
/**
@@ -80,23 +74,16 @@ ecma_op_get_value_lex_env_base (ecma_completion_value_t &ret_value, /**< out: co
* @return completion value
* Returned value must be freed with ecma_free_completion_value.
*/
void
ecma_op_get_value_object_base (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_reference_t& ref) /**< ECMA-reference */
ecma_completion_value_t
ecma_op_get_value_object_base (ecma_reference_t ref) /**< ECMA-reference */
{
const ecma_value_t& base = ref.base;
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));
bool has_object_base = false;
if (ecma_is_value_object (base))
{
ecma_object_ptr_t base_obj_p;
ecma_get_object_from_value (base_obj_p, base);
has_object_base = !ecma_is_lexical_environment (base_obj_p);
}
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);
@@ -107,28 +94,30 @@ ecma_op_get_value_object_base (ecma_completion_value_t &ret_value, /**< out: com
{
// 4.b case 1
ecma_object_ptr_t obj_p;
ecma_get_object_from_value (obj_p, base);
JERRY_ASSERT(obj_p.is_not_null ()
ecma_object_t *obj_p = ecma_get_object_from_value (base);
JERRY_ASSERT(obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
ecma_op_object_get (ret_value, obj_p, ECMA_GET_NON_NULL_POINTER (ecma_string_t,
ref.referenced_name_cp));
return ecma_op_object_get (obj_p, ECMA_GET_NON_NULL_POINTER (ecma_string_t,
ref.referenced_name_cp));
}
else
{
// 4.b case 2
ECMA_TRY_CATCH (ret_value, ecma_op_to_object, obj_base, base);
ecma_completion_value_t ret_value;
ecma_object_ptr_t obj_p;
ecma_get_object_from_value (obj_p, obj_base);
JERRY_ASSERT (obj_p.is_not_null ()
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_op_object_get (ret_value, obj_p, ECMA_GET_NON_NULL_POINTER (ecma_string_t,
ref.referenced_name_cp));
ret_value = ecma_op_object_get (obj_p, ECMA_GET_NON_NULL_POINTER (ecma_string_t,
ref.referenced_name_cp));
ECMA_FINALIZE (obj_base);
return ret_value;
}
} /* ecma_op_get_value_object_base */
@@ -140,15 +129,13 @@ ecma_op_get_value_object_base (ecma_completion_value_t &ret_value, /**< out: com
* @return completion value
* Returned value must be freed with ecma_free_completion_value.
*/
void
ecma_op_put_value_lex_env_base (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& ref_base_lex_env_p, /**< reference's base
* (lexical environment) */
ecma_completion_value_t
ecma_op_put_value_lex_env_base (ecma_object_t *ref_base_lex_env_p, /**< reference's base (lexical environment) */
ecma_string_t *var_name_string_p, /**< variable name */
bool is_strict, /**< flag indicating strict mode */
const ecma_value_t& value) /**< ECMA-value */
{
const bool is_unresolvable_reference = (ref_base_lex_env_p.is_null ());
const bool is_unresolvable_reference = (ref_base_lex_env_p == NULL);
// 3.
if (unlikely (is_unresolvable_reference))
@@ -156,44 +143,36 @@ ecma_op_put_value_lex_env_base (ecma_completion_value_t &ret_value, /**< out: co
// 3.a.
if (is_strict)
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_REFERENCE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
return;
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_REFERENCE));
}
else
{
// 3.b.
ecma_object_ptr_t global_object_p;
ecma_builtin_get (global_object_p, ECMA_BUILTIN_ID_GLOBAL);
ecma_object_t *global_object_p = ecma_builtin_get (ECMA_BUILTIN_ID_GLOBAL);
ecma_completion_value_t completion;
ecma_op_object_put (completion,
global_object_p,
var_name_string_p,
value,
false);
ecma_completion_value_t completion = ecma_op_object_put (global_object_p,
var_name_string_p,
value,
false);
ecma_deref_object (global_object_p);
JERRY_ASSERT(ecma_is_completion_value_normal_true (completion)
|| ecma_is_completion_value_normal_false (completion));
ecma_make_empty_completion_value (ret_value);
return;
return ecma_make_empty_completion_value ();
}
}
// 5.
JERRY_ASSERT(ref_base_lex_env_p.is_not_null ()
JERRY_ASSERT(ref_base_lex_env_p != NULL
&& ecma_is_lexical_environment (ref_base_lex_env_p));
// 5.a
ecma_op_set_mutable_binding (ret_value,
ref_base_lex_env_p,
var_name_string_p,
value,
is_strict);
return ecma_op_set_mutable_binding (ref_base_lex_env_p,
var_name_string_p,
value,
is_strict);
} /* ecma_op_put_value_lex_env_base */
/**
@@ -202,19 +181,16 @@ ecma_op_put_value_lex_env_base (ecma_completion_value_t &ret_value, /**< out: co
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
static void
ecma_reject_put (ecma_completion_value_t &ret_value, /**< out: completion value */
bool is_throw) /**< Throw flag */
static ecma_completion_value_t
ecma_reject_put (bool is_throw) /**< Throw flag */
{
if (is_throw)
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_TYPE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_EMPTY);
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_EMPTY);
}
} /* ecma_reject_put */
@@ -226,24 +202,17 @@ ecma_reject_put (ecma_completion_value_t &ret_value, /**< out: completion value
* @return completion value
* Returned value must be freed with ecma_free_completion_value.
*/
void
ecma_op_put_value_object_base (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_reference_t& ref, /**< ECMA-reference */
ecma_completion_value_t
ecma_op_put_value_object_base (ecma_reference_t ref, /**< ECMA-reference */
const ecma_value_t& value) /**< ECMA-value */
{
const ecma_value_t& base = ref.base;
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));
bool has_object_base = false;
if (ecma_is_value_object (base))
{
ecma_object_ptr_t base_obj_p;
ecma_get_object_from_value (base_obj_p, base);
has_object_base = !ecma_is_lexical_environment (base_obj_p);
}
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);
@@ -254,30 +223,36 @@ ecma_op_put_value_object_base (ecma_completion_value_t &ret_value, /**< out: com
{
// 4.b case 1
ecma_object_ptr_t obj_p;
ecma_get_object_from_value (obj_p, base);
JERRY_ASSERT (obj_p.is_not_null ()
ecma_object_t *obj_p = ecma_get_object_from_value (base);
JERRY_ASSERT (obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
ECMA_TRY_CATCH (ret_value, ecma_op_object_put, put_ret_value, obj_p,
ECMA_GET_NON_NULL_POINTER (ecma_string_t,
ref.referenced_name_cp),
value, ref.is_strict);
ecma_completion_value_t ret_value;
ecma_make_empty_completion_value (ret_value);
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_empty_completion_value ();
ECMA_FINALIZE (put_ret_value);
return ret_value;
}
else
{
// 4.b case 2
ecma_completion_value_t ret_value;
// sub_1.
ECMA_TRY_CATCH (ret_value, ecma_op_to_object, obj_base, base);
ECMA_TRY_CATCH (obj_base, ecma_op_to_object (base), ret_value);
ecma_object_ptr_t obj_p;
ecma_get_object_from_value (obj_p, obj_base);
JERRY_ASSERT (obj_p.is_not_null ()
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,
@@ -286,7 +261,7 @@ ecma_op_put_value_object_base (ecma_completion_value_t &ret_value, /**< out: com
// sub_2.
if (!ecma_op_object_can_put (obj_p, referenced_name_p))
{
ecma_reject_put (ret_value, ref.is_strict);
ret_value = ecma_reject_put (ref.is_strict);
}
else
{
@@ -302,26 +277,30 @@ ecma_op_put_value_object_base (ecma_completion_value_t &ret_value, /**< out: com
|| (prop_p == NULL)
|| (prop_p->type != ECMA_PROPERTY_NAMEDACCESSOR))
{
ecma_reject_put (ret_value, ref.is_strict);
ret_value = ecma_reject_put (ref.is_strict);
}
else
{
// sub_6.
JERRY_ASSERT (prop_p != NULL && prop_p->type == ECMA_PROPERTY_NAMEDACCESSOR);
ecma_object_ptr_t setter_p;
setter_p.unpack_from (prop_p->u.named_accessor_property.set_p);
JERRY_ASSERT (setter_p.is_not_null ());
ecma_object_t *setter_p = ECMA_GET_NON_NULL_POINTER(ecma_object_t,
prop_p->u.named_accessor_property.set_p);
JERRY_ASSERT (setter_p != NULL);
ECMA_TRY_CATCH (ret_value, ecma_op_function_call, call_ret, setter_p, base, &value, 1);
ECMA_TRY_CATCH (call_ret,
ecma_op_function_call (setter_p, base, &value, 1),
ret_value);
ecma_make_empty_completion_value (ret_value);
ret_value = ecma_make_empty_completion_value ();
ECMA_FINALIZE (call_ret);
}
}
ECMA_FINALIZE (obj_base);
return ret_value;
}
} /* ecma_op_put_value_object_base */
src/libecmaoperations/ecma-lex-env.c
+68 -116
View File
@@ -39,10 +39,10 @@
* @return true / false
*/
bool
ecma_op_has_binding (const ecma_object_ptr_t& lex_env_p, /**< lexical environment */
ecma_op_has_binding (ecma_object_t *lex_env_p, /**< lexical environment */
ecma_string_t *name_p) /**< argument N */
{
JERRY_ASSERT(lex_env_p.is_not_null ()
JERRY_ASSERT(lex_env_p != NULL
&& ecma_is_lexical_environment (lex_env_p));
if (ecma_get_lex_env_type (lex_env_p) == ECMA_LEXICAL_ENVIRONMENT_DECLARATIVE)
@@ -55,8 +55,7 @@ ecma_op_has_binding (const ecma_object_ptr_t& lex_env_p, /**< lexical environmen
{
JERRY_ASSERT (ecma_get_lex_env_type (lex_env_p) == ECMA_LEXICAL_ENVIRONMENT_OBJECTBOUND);
ecma_object_ptr_t binding_obj_p;
ecma_get_lex_env_binding_object (binding_obj_p, lex_env_p);
ecma_object_t *binding_obj_p = ecma_get_lex_env_binding_object (lex_env_p);
return (ecma_op_object_get_property (binding_obj_p, name_p) != NULL);
}
@@ -70,13 +69,12 @@ ecma_op_has_binding (const ecma_object_ptr_t& lex_env_p, /**< lexical environmen
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_create_mutable_binding (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& lex_env_p, /**< lexical environment */
ecma_completion_value_t
ecma_op_create_mutable_binding (ecma_object_t *lex_env_p, /**< lexical environment */
ecma_string_t *name_p, /**< argument N */
bool is_deletable) /**< argument D */
{
JERRY_ASSERT(lex_env_p.is_not_null ()
JERRY_ASSERT(lex_env_p != NULL
&& ecma_is_lexical_environment (lex_env_p));
JERRY_ASSERT(name_p != NULL);
@@ -90,13 +88,12 @@ ecma_op_create_mutable_binding (ecma_completion_value_t &ret_value, /**< out: co
{
JERRY_ASSERT (ecma_get_lex_env_type (lex_env_p) == ECMA_LEXICAL_ENVIRONMENT_OBJECTBOUND);
ecma_object_ptr_t binding_obj_p;
ecma_get_lex_env_binding_object (binding_obj_p, lex_env_p);
ecma_object_t *binding_obj_p = ecma_get_lex_env_binding_object (lex_env_p);
ecma_property_descriptor_t prop_desc = ecma_make_empty_property_descriptor ();
{
prop_desc.is_value_defined = true;
prop_desc.value = (ecma_value_packed_t) ecma_value_t (ECMA_SIMPLE_VALUE_UNDEFINED);
prop_desc.value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED);
prop_desc.is_writable_defined = true;
prop_desc.is_writable = true;
@@ -108,17 +105,14 @@ ecma_op_create_mutable_binding (ecma_completion_value_t &ret_value, /**< out: co
prop_desc.is_configurable = is_deletable;
}
ecma_completion_value_t completion;
ecma_op_object_define_own_property (completion,
binding_obj_p,
name_p,
&prop_desc,
true);
ecma_completion_value_t completion = ecma_op_object_define_own_property (binding_obj_p,
name_p,
&prop_desc,
true);
if (ecma_is_completion_value_throw (completion))
{
ret_value = completion;
return;
return completion;
}
else
{
@@ -127,7 +121,7 @@ ecma_op_create_mutable_binding (ecma_completion_value_t &ret_value, /**< out: co
}
}
ecma_make_empty_completion_value (ret_value);
return ecma_make_empty_completion_value ();
} /* ecma_op_create_mutable_binding */
/**
@@ -138,14 +132,13 @@ ecma_op_create_mutable_binding (ecma_completion_value_t &ret_value, /**< out: co
* @return completion value
* Returned value must be freed with ecma_free_completion_value.
*/
void
ecma_op_set_mutable_binding (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& lex_env_p, /**< lexical environment */
ecma_completion_value_t
ecma_op_set_mutable_binding (ecma_object_t *lex_env_p, /**< lexical environment */
ecma_string_t *name_p, /**< argument N */
const ecma_value_t& value, /**< argument V */
bool is_strict) /**< argument S */
{
JERRY_ASSERT(lex_env_p.is_not_null ()
JERRY_ASSERT(lex_env_p != NULL
&& ecma_is_lexical_environment (lex_env_p));
JERRY_ASSERT(name_p != NULL);
@@ -166,10 +159,7 @@ ecma_op_set_mutable_binding (ecma_completion_value_t &ret_value, /**< out: compl
if (is_equal)
{
ecma_object_ptr_t cp_error_obj_p;
ecma_builtin_get (cp_error_obj_p, ECMA_BUILTIN_ID_COMPACT_PROFILE_ERROR);
ecma_make_throw_obj_completion_value (ret_value, cp_error_obj_p);
return;
return ecma_make_throw_obj_completion_value (ecma_builtin_get (ECMA_BUILTIN_ID_COMPACT_PROFILE_ERROR));
}
# endif /* CONFIG_ECMA_COMPACT_PROFILE */
#endif /* !JERRY_NDEBUG */
@@ -182,30 +172,23 @@ ecma_op_set_mutable_binding (ecma_completion_value_t &ret_value, /**< out: compl
}
else if (is_strict)
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_TYPE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
return;
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
}
else
{
JERRY_ASSERT (ecma_get_lex_env_type (lex_env_p) == ECMA_LEXICAL_ENVIRONMENT_OBJECTBOUND);
ecma_object_ptr_t binding_obj_p;
ecma_get_lex_env_binding_object (binding_obj_p, lex_env_p);
ecma_object_t *binding_obj_p = ecma_get_lex_env_binding_object (lex_env_p);
ecma_completion_value_t completion;
ecma_op_object_put (completion,
binding_obj_p,
name_p,
value,
is_strict);
ecma_completion_value_t completion = ecma_op_object_put (binding_obj_p,
name_p,
value,
is_strict);
if (ecma_is_completion_value_throw (completion))
{
ret_value = completion;
return;
return completion;
}
else
{
@@ -214,7 +197,7 @@ ecma_op_set_mutable_binding (ecma_completion_value_t &ret_value, /**< out: compl
}
}
ecma_make_empty_completion_value (ret_value);
return ecma_make_empty_completion_value ();
} /* ecma_op_set_mutable_binding */
/**
@@ -225,13 +208,12 @@ ecma_op_set_mutable_binding (ecma_completion_value_t &ret_value, /**< out: compl
* @return completion value
* Returned value must be freed with ecma_free_completion_value.
*/
void
ecma_op_get_binding_value (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& lex_env_p, /**< lexical environment */
ecma_completion_value_t
ecma_op_get_binding_value (ecma_object_t *lex_env_p, /**< lexical environment */
ecma_string_t *name_p, /**< argument N */
bool is_strict) /**< argument S */
{
JERRY_ASSERT(lex_env_p.is_not_null ()
JERRY_ASSERT(lex_env_p != NULL
&& ecma_is_lexical_environment (lex_env_p));
JERRY_ASSERT(name_p != NULL);
@@ -252,18 +234,14 @@ ecma_op_get_binding_value (ecma_completion_value_t &ret_value, /**< out: complet
if (is_equal)
{
ecma_object_ptr_t cp_error_obj_p;
ecma_builtin_get (cp_error_obj_p, ECMA_BUILTIN_ID_COMPACT_PROFILE_ERROR);
ecma_make_throw_obj_completion_value (ret_value, cp_error_obj_p);
return;
return ecma_make_throw_obj_completion_value (ecma_builtin_get (ECMA_BUILTIN_ID_COMPACT_PROFILE_ERROR));
}
# endif /* CONFIG_ECMA_COMPACT_PROFILE */
#endif /* !JERRY_NDEBUG */
ecma_property_t *property_p = ecma_get_named_data_property (lex_env_p, name_p);
ecma_value_t prop_value;
ecma_get_named_data_property_value (prop_value, property_p);
ecma_value_t prop_value = ecma_get_named_data_property_value (property_p);
/* is the binding mutable? */
if (!ecma_is_property_writable (property_p)
@@ -272,47 +250,35 @@ ecma_op_get_binding_value (ecma_completion_value_t &ret_value, /**< out: complet
/* unitialized immutable binding */
if (is_strict)
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_REFERENCE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
return;
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_REFERENCE));
}
else
{
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_UNDEFINED);
return;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_UNDEFINED);
}
}
ecma_value_t prop_value_copy;
ecma_copy_value (prop_value_copy, prop_value, true);
ecma_make_normal_completion_value (ret_value, prop_value_copy);
return ecma_make_normal_completion_value (ecma_copy_value (prop_value, true));
}
else
{
JERRY_ASSERT (ecma_get_lex_env_type (lex_env_p) == ECMA_LEXICAL_ENVIRONMENT_OBJECTBOUND);
ecma_object_ptr_t binding_obj_p;
ecma_get_lex_env_binding_object (binding_obj_p, lex_env_p);
ecma_object_t *binding_obj_p = ecma_get_lex_env_binding_object (lex_env_p);
if (ecma_op_object_get_property (binding_obj_p, name_p) == NULL)
{
if (is_strict)
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_REFERENCE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
return;
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_REFERENCE));
}
else
{
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_UNDEFINED);
return;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_UNDEFINED);
}
}
ecma_op_object_get (ret_value, binding_obj_p, name_p);
return ecma_op_object_get (binding_obj_p, name_p);
}
} /* ecma_op_get_binding_value */
@@ -325,12 +291,11 @@ ecma_op_get_binding_value (ecma_completion_value_t &ret_value, /**< out: complet
* Return value is simple and so need not be freed.
* However, ecma_free_completion_value may be called for it, but it is a no-op.
*/
void
ecma_op_delete_binding (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& lex_env_p, /**< lexical environment */
ecma_completion_value_t
ecma_op_delete_binding (ecma_object_t *lex_env_p, /**< lexical environment */
ecma_string_t *name_p) /**< argument N */
{
JERRY_ASSERT(lex_env_p.is_not_null ()
JERRY_ASSERT(lex_env_p != NULL
&& ecma_is_lexical_environment (lex_env_p));
JERRY_ASSERT(name_p != NULL);
@@ -360,16 +325,15 @@ ecma_op_delete_binding (ecma_completion_value_t &ret_value, /**< out: completion
}
}
ecma_make_simple_completion_value (ret_value, ret_val);
return ecma_make_simple_completion_value (ret_val);
}
else
{
JERRY_ASSERT (ecma_get_lex_env_type (lex_env_p) == ECMA_LEXICAL_ENVIRONMENT_OBJECTBOUND);
ecma_object_ptr_t binding_obj_p;
ecma_get_lex_env_binding_object (binding_obj_p, lex_env_p);
ecma_object_t *binding_obj_p = ecma_get_lex_env_binding_object (lex_env_p);
ecma_op_object_delete (ret_value, binding_obj_p, name_p, false);
return ecma_op_object_delete (binding_obj_p, name_p, false);
}
} /* ecma_op_delete_binding */
@@ -381,16 +345,15 @@ ecma_op_delete_binding (ecma_completion_value_t &ret_value, /**< out: completion
* @return completion value
* Returned value must be freed with ecma_free_completion_value.
*/
void
ecma_op_implicit_this_value (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& lex_env_p) /**< lexical environment */
ecma_completion_value_t
ecma_op_implicit_this_value (ecma_object_t *lex_env_p) /**< lexical environment */
{
JERRY_ASSERT(lex_env_p.is_not_null ()
JERRY_ASSERT(lex_env_p != NULL
&& ecma_is_lexical_environment (lex_env_p));
if (ecma_get_lex_env_type (lex_env_p) == ECMA_LEXICAL_ENVIRONMENT_DECLARATIVE)
{
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_UNDEFINED);
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_UNDEFINED);
}
else
{
@@ -398,15 +361,14 @@ ecma_op_implicit_this_value (ecma_completion_value_t &ret_value, /**< out: compl
if (ecma_get_lex_env_provide_this (lex_env_p))
{
ecma_object_ptr_t binding_obj_p;
ecma_get_lex_env_binding_object (binding_obj_p, lex_env_p);
ecma_object_t *binding_obj_p = ecma_get_lex_env_binding_object (lex_env_p);
ecma_ref_object (binding_obj_p);
ecma_make_normal_completion_value (ret_value, ecma_value_t (binding_obj_p));
return ecma_make_normal_completion_value (ecma_make_object_value (binding_obj_p));
}
else
{
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_UNDEFINED);
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_UNDEFINED);
}
}
} /* ecma_op_implicit_this_value */
@@ -417,10 +379,10 @@ ecma_op_implicit_this_value (ecma_completion_value_t &ret_value, /**< out: compl
* See also: ECMA-262 v5, 10.2.1
*/
void
ecma_op_create_immutable_binding (const ecma_object_ptr_t& lex_env_p, /**< lexical environment */
ecma_op_create_immutable_binding (ecma_object_t *lex_env_p, /**< lexical environment */
ecma_string_t *name_p) /**< argument N */
{
JERRY_ASSERT(lex_env_p.is_not_null ()
JERRY_ASSERT(lex_env_p != NULL
&& ecma_is_lexical_environment (lex_env_p));
JERRY_ASSERT (ecma_get_lex_env_type (lex_env_p) == ECMA_LEXICAL_ENVIRONMENT_DECLARATIVE);
@@ -432,15 +394,10 @@ ecma_op_create_immutable_binding (const ecma_object_ptr_t& lex_env_p, /**< lexic
name_p,
false, false, false);
#ifndef JERRY_NDEBUG
ecma_value_t prop_value;
ecma_get_named_data_property_value (prop_value, prop_p);
JERRY_ASSERT(ecma_is_value_undefined (prop_value));
#endif /* !JERRY_NDEBUG */
JERRY_ASSERT(ecma_is_value_undefined (ecma_get_named_data_property_value (prop_p)));
ecma_set_named_data_property_value (prop_p,
ecma_value_t (ECMA_SIMPLE_VALUE_EMPTY));
ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY));
} /* ecma_op_create_immutable_binding */
/**
@@ -449,22 +406,19 @@ ecma_op_create_immutable_binding (const ecma_object_ptr_t& lex_env_p, /**< lexic
* See also: ECMA-262 v5, 10.2.1
*/
void
ecma_op_initialize_immutable_binding (const ecma_object_ptr_t& lex_env_p, /**< lexical environment */
ecma_op_initialize_immutable_binding (ecma_object_t *lex_env_p, /**< lexical environment */
ecma_string_t *name_p, /**< argument N */
const ecma_value_t& value) /**< argument V */
{
JERRY_ASSERT(lex_env_p.is_not_null ()
JERRY_ASSERT(lex_env_p != NULL
&& ecma_is_lexical_environment (lex_env_p));
JERRY_ASSERT (ecma_get_lex_env_type (lex_env_p) == ECMA_LEXICAL_ENVIRONMENT_DECLARATIVE);
ecma_property_t *prop_p = ecma_get_named_data_property (lex_env_p, name_p);
ecma_value_t prop_value;
ecma_get_named_data_property_value (prop_value, prop_p);
/* The binding must be unitialized immutable binding */
JERRY_ASSERT (!ecma_is_property_writable (prop_p)
&& ecma_is_value_empty (prop_value));
JERRY_ASSERT(!ecma_is_property_writable (prop_p)
&& ecma_is_value_empty (ecma_get_named_data_property_value (prop_p)));
ecma_named_data_property_assign_value (lex_env_p, prop_p, value);
} /* ecma_op_initialize_immutable_binding */
@@ -476,18 +430,17 @@ ecma_op_initialize_immutable_binding (const ecma_object_ptr_t& lex_env_p, /**< l
*
* @return pointer to created lexical environment
*/
void
ecma_op_create_global_environment (ecma_object_ptr_t &glob_env_p, /**< out: object pointer */
const ecma_object_ptr_t& glob_obj_p) /**< the Global object */
ecma_object_t*
ecma_op_create_global_environment (ecma_object_t *glob_obj_p) /**< the Global object */
{
ecma_object_ptr_t null_pointer;
#ifdef CONFIG_ECMA_GLOBAL_ENVIRONMENT_DECLARATIVE
(void) glob_obj_p;
ecma_create_decl_lex_env (glob_env_p, null_pointer);
ecma_object_t *glob_env_p = ecma_create_decl_lex_env (NULL);
#else /* !CONFIG_ECMA_GLOBAL_ENVIRONMENT_DECLARATIVE */
ecma_create_object_lex_env (glob_env_p, null_pointer, glob_obj_p, false);
ecma_object_t *glob_env_p = ecma_create_object_lex_env (NULL, glob_obj_p, false);
#endif /* !CONFIG_ECMA_GLOBAL_ENVIRONMENT_DECLARATIVE */
return glob_env_p;
} /* ecma_op_create_global_environment */
/**
@@ -497,17 +450,16 @@ ecma_op_create_global_environment (ecma_object_ptr_t &glob_env_p, /**< out: obje
* false - otherwise.
*/
bool
ecma_is_lexical_environment_global (const ecma_object_ptr_t& lex_env_p) /**< lexical environment */
ecma_is_lexical_environment_global (ecma_object_t *lex_env_p) /**< lexical environment */
{
JERRY_ASSERT(lex_env_p.is_not_null ()
JERRY_ASSERT(lex_env_p != NULL
&& ecma_is_lexical_environment (lex_env_p));
ecma_lexical_environment_type_t type = ecma_get_lex_env_type (lex_env_p);
if (type == ECMA_LEXICAL_ENVIRONMENT_OBJECTBOUND)
{
ecma_object_ptr_t binding_obj_p;
ecma_get_lex_env_binding_object (binding_obj_p, lex_env_p);
ecma_object_t *binding_obj_p = ecma_get_lex_env_binding_object (lex_env_p);
return ecma_builtin_is (binding_obj_p, ECMA_BUILTIN_ID_GLOBAL);
}
src/libecmaoperations/ecma-lex-env.h
+28 -47
View File
@@ -18,7 +18,6 @@
#include "ecma-globals.h"
#include "ecma-reference.h"
#include "ecma-value.h"
#include "globals.h"
/** \addtogroup ecma ECMA
@@ -31,61 +30,43 @@
*/
/* ECMA-262 v5, 8.7.1 and 8.7.2 */
extern void
ecma_op_get_value_lex_env_base (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& ref_base_lex_env_p,
ecma_string_t *var_name_string_p,
bool is_strict);
extern void
ecma_op_get_value_object_base (ecma_completion_value_t &ret_value,
const ecma_reference_t& ref);
extern void
ecma_op_put_value_lex_env_base (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& ref_base_lex_env_p,
ecma_string_t *var_name_string_p,
bool is_strict,
const ecma_value_t& value);
extern void
ecma_op_put_value_object_base (ecma_completion_value_t &ret_value,
const ecma_reference_t& ref,
const ecma_value_t& value);
extern ecma_completion_value_t ecma_op_get_value_lex_env_base (ecma_object_t *ref_base_lex_env_p,
ecma_string_t *var_name_string_p,
bool is_strict);
extern ecma_completion_value_t ecma_op_get_value_object_base (ecma_reference_t ref);
extern ecma_completion_value_t ecma_op_put_value_lex_env_base (ecma_object_t *ref_base_lex_env_p,
ecma_string_t *var_name_string_p,
bool is_strict,
const ecma_value_t& value);
extern ecma_completion_value_t ecma_op_put_value_object_base (ecma_reference_t ref,
const ecma_value_t& value);
/* ECMA-262 v5, Table 17. Abstract methods of Environment Records */
extern bool ecma_op_has_binding (const ecma_object_ptr_t& lex_env_p,
extern bool ecma_op_has_binding (ecma_object_t *lex_env_p,
ecma_string_t *name_p);
extern void
ecma_op_create_mutable_binding (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& lex_env_p,
ecma_string_t *name_p,
bool is_deletable);
extern void
ecma_op_set_mutable_binding (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& lex_env_p,
ecma_string_t *name_p,
const ecma_value_t& value,
bool is_strict);
extern void
ecma_op_get_binding_value (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& lex_env_p,
ecma_string_t *name_p,
bool is_strict);
extern void
ecma_op_delete_binding (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& lex_env_p,
ecma_string_t *name_p);
extern void
ecma_op_implicit_this_value (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& lex_env_p);
extern ecma_completion_value_t ecma_op_create_mutable_binding (ecma_object_t *lex_env_p,
ecma_string_t *name_p,
bool is_deletable);
extern ecma_completion_value_t ecma_op_set_mutable_binding (ecma_object_t *lex_env_p,
ecma_string_t *name_p,
const ecma_value_t& value,
bool is_strict);
extern ecma_completion_value_t ecma_op_get_binding_value (ecma_object_t *lex_env_p,
ecma_string_t *name_p,
bool is_strict);
extern ecma_completion_value_t ecma_op_delete_binding (ecma_object_t *lex_env_p,
ecma_string_t *name_p);
extern ecma_completion_value_t ecma_op_implicit_this_value (ecma_object_t *lex_env_p);
/* ECMA-262 v5, Table 18. Additional methods of Declarative Environment Records */
extern void ecma_op_create_immutable_binding (const ecma_object_ptr_t& lex_env_p,
extern void ecma_op_create_immutable_binding (ecma_object_t *lex_env_p,
ecma_string_t *name_p);
extern void ecma_op_initialize_immutable_binding (const ecma_object_ptr_t& lex_env_p,
extern void ecma_op_initialize_immutable_binding (ecma_object_t *lex_env_p,
ecma_string_t *name_p,
const ecma_value_t& value);
extern void ecma_op_create_global_environment (ecma_object_ptr_t &ret_val, const ecma_object_ptr_t& glob_obj_p);
extern bool ecma_is_lexical_environment_global (const ecma_object_ptr_t& lex_env_p);
extern ecma_object_t* ecma_op_create_global_environment (ecma_object_t *glob_obj_p);
extern bool ecma_is_lexical_environment_global (ecma_object_t *lex_env_p);
/**
* @}
src/libecmaoperations/ecma-number-object.c
+12 -19
View File
@@ -38,34 +38,27 @@
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_create_number_object (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_value_t& arg) /**< argument passed to the Number constructor */
ecma_completion_value_t
ecma_op_create_number_object (const ecma_value_t& arg) /**< argument passed to the Number constructor */
{
ecma_completion_value_t to_num_completion;
ecma_op_to_number (to_num_completion, arg);
ecma_completion_value_t conv_to_num_completion = ecma_op_to_number (arg);
if (!ecma_is_completion_value_normal (to_num_completion))
if (!ecma_is_completion_value_normal (conv_to_num_completion))
{
ret_value = to_num_completion;
return;
return conv_to_num_completion;
}
ecma_value_t num_value;
ecma_get_completion_value_value (num_value, to_num_completion);
ecma_number_t *prim_value_p = ecma_get_number_from_value (num_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_ptr_t prototype_obj_p;
ecma_builtin_get (prototype_obj_p, ECMA_BUILTIN_ID_NUMBER_PROTOTYPE);
ecma_object_t *prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_NUMBER_PROTOTYPE);
#else /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_NUMBER_BUILTIN */
ecma_object_ptr_t prototype_obj_p;
ecma_builtin_get (prototype_obj_p, ECMA_BUILTIN_ID_OBJECT_PROTOTYPE);
ecma_object_t *prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_OBJECT_PROTOTYPE);
#endif /* CONFIG_ECMA_COMPACT_PROFILE_DISABLE_NUMBER_BUILTIN */
ecma_object_ptr_t obj_p;
ecma_create_object (obj_p, prototype_obj_p, true, ECMA_OBJECT_TYPE_GENERAL);
ecma_object_t *obj_p = ecma_create_object (prototype_obj_p,
true,
ECMA_OBJECT_TYPE_GENERAL);
ecma_deref_object (prototype_obj_p);
ecma_property_t *class_prop_p = ecma_create_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_CLASS);
@@ -75,5 +68,5 @@ ecma_op_create_number_object (ecma_completion_value_t &ret_value, /**< out: comp
ECMA_INTERNAL_PROPERTY_PRIMITIVE_NUMBER_VALUE);
ECMA_SET_POINTER (prim_value_prop_p->u.internal_property.value, prim_value_p);
ecma_make_normal_completion_value (ret_value, ecma_value_t (obj_p));
return ecma_make_normal_completion_value (ecma_make_object_value (obj_p));
} /* ecma_op_create_number_object */
src/libecmaoperations/ecma-number-object.h
+1 -4
View File
@@ -17,7 +17,6 @@
#define ECMA_NUMBER_OBJECT_H
#include "ecma-globals.h"
#include "ecma-value.h"
/** \addtogroup ecma ECMA
* @{
@@ -26,9 +25,7 @@
* @{
*/
extern void
ecma_op_create_number_object (ecma_completion_value_t &ret_value,
const ecma_value_t& arg);
extern ecma_completion_value_t ecma_op_create_number_object (const ecma_value_t& arg);
/**
* @}
src/libecmaoperations/ecma-objects-arguments.c
+108 -116
View File
@@ -40,10 +40,9 @@
*
* @return pointer to newly created Arguments object
*/
void
ecma_create_arguments_object (ecma_object_ptr_t &obj_p, /**< out: object pointer */
const ecma_object_ptr_t& func_obj_p, /**< callee function */
const ecma_object_ptr_t& lex_env_p, /**< lexical environment the Arguments
ecma_object_t*
ecma_create_arguments_object (ecma_object_t *func_obj_p, /**< callee function */
ecma_object_t *lex_env_p, /**< lexical environment the Arguments
object is created for */
ecma_collection_iterator_t *formal_params_iter_p, /**< formal parameters
collection iterator */
@@ -56,10 +55,9 @@ ecma_create_arguments_object (ecma_object_ptr_t &obj_p, /**< out: object pointer
*len_p = ecma_uint32_to_number (arguments_list_length);
// 2., 3., 6.
ecma_object_ptr_t prototype_p;
ecma_builtin_get (prototype_p, ECMA_BUILTIN_ID_OBJECT_PROTOTYPE);
ecma_object_t *prototype_p = ecma_builtin_get (ECMA_BUILTIN_ID_OBJECT_PROTOTYPE);
ecma_create_object (obj_p, prototype_p, true, ECMA_OBJECT_TYPE_GENERAL);
ecma_object_t *obj_p = ecma_create_object (prototype_p, true, ECMA_OBJECT_TYPE_GENERAL);
ecma_deref_object (prototype_p);
@@ -71,7 +69,7 @@ ecma_create_arguments_object (ecma_object_ptr_t &obj_p, /**< out: object pointer
ecma_property_descriptor_t prop_desc = ecma_make_empty_property_descriptor ();
{
prop_desc.is_value_defined = true;
prop_desc.value = (ecma_value_packed_t) ecma_value_t (len_p);
prop_desc.value = ecma_make_number_value (len_p);
prop_desc.is_writable_defined = true;
prop_desc.is_writable = true;
@@ -83,12 +81,10 @@ ecma_create_arguments_object (ecma_object_ptr_t &obj_p, /**< out: object pointer
prop_desc.is_configurable = true;
}
ecma_string_t *length_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING_LENGTH);
ecma_completion_value_t completion;
ecma_op_object_define_own_property (completion,
obj_p,
length_magic_string_p,
&prop_desc,
false);
ecma_completion_value_t completion = ecma_op_object_define_own_property (obj_p,
length_magic_string_p,
&prop_desc,
false);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion));
ecma_deref_ecma_string (length_magic_string_p);
@@ -102,7 +98,7 @@ ecma_create_arguments_object (ecma_object_ptr_t &obj_p, /**< out: object pointer
prop_desc = ecma_make_empty_property_descriptor ();
{
prop_desc.is_value_defined = true;
prop_desc.value = (ecma_value_packed_t) arguments_list_p[indx];
prop_desc.value = arguments_list_p[indx];
prop_desc.is_writable_defined = true;
prop_desc.is_writable = true;
@@ -116,11 +112,10 @@ ecma_create_arguments_object (ecma_object_ptr_t &obj_p, /**< out: object pointer
ecma_string_t *indx_string_p = ecma_new_ecma_string_from_number (ecma_uint32_to_number (indx));
ecma_op_object_define_own_property (completion,
obj_p,
indx_string_p,
&prop_desc,
false);
completion = ecma_op_object_define_own_property (obj_p,
indx_string_p,
&prop_desc,
false);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion));
ecma_deref_ecma_string (indx_string_p);
@@ -132,8 +127,7 @@ ecma_create_arguments_object (ecma_object_ptr_t &obj_p, /**< out: object pointer
&& formal_params_number > 0)
{
// 8.
ecma_object_ptr_t map_p;
ecma_op_create_object_object_noarg (map_p);
ecma_object_t *map_p = ecma_op_create_object_object_noarg ();
// 11.c
MEM_DEFINE_LOCAL_ARRAY (formal_params, formal_params_number, ecma_string_t *);
@@ -147,9 +141,8 @@ ecma_create_arguments_object (ecma_object_ptr_t &obj_p, /**< out: object pointer
JERRY_ASSERT (formal_params_iter_p->current_value_p != NULL);
JERRY_ASSERT (param_index < formal_params_number);
ecma_value_t string_value (*formal_params_iter_p->current_value_p);
JERRY_ASSERT (ecma_is_value_string (string_value));
formal_params[param_index] = ecma_get_string_from_value (string_value);
JERRY_ASSERT (ecma_is_value_string (*formal_params_iter_p->current_value_p));
formal_params[param_index] = ecma_get_string_from_value (*formal_params_iter_p->current_value_p);
}
JERRY_ASSERT (param_index == formal_params_number);
@@ -179,14 +172,13 @@ ecma_create_arguments_object (ecma_object_ptr_t &obj_p, /**< out: object pointer
prop_desc = ecma_make_empty_property_descriptor ();
{
prop_desc.is_value_defined = true;
prop_desc.value = (ecma_value_packed_t) ecma_value_t (name_p);
prop_desc.value = ecma_make_string_value (name_p);
}
ecma_op_object_define_own_property (completion,
map_p,
indx_string_p,
&prop_desc,
false);
completion = ecma_op_object_define_own_property (map_p,
indx_string_p,
&prop_desc,
false);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion));
ecma_deref_ecma_string (indx_string_p);
@@ -200,18 +192,12 @@ ecma_create_arguments_object (ecma_object_ptr_t &obj_p, /**< out: object pointer
ecma_property_t *parameters_map_prop_p = ecma_create_internal_property (obj_p,
ECMA_INTERNAL_PROPERTY_PARAMETERS_MAP);
{
ecma_object_t *map_tmp_p = (ecma_object_t*) map_p;
ECMA_SET_POINTER(parameters_map_prop_p->u.internal_property.value, map_tmp_p);
}
ECMA_SET_POINTER(parameters_map_prop_p->u.internal_property.value, map_p);
ecma_gc_update_may_ref_younger_object_flag_by_object (obj_p, map_p);
ecma_property_t *scope_prop_p = ecma_create_internal_property (map_p,
ECMA_INTERNAL_PROPERTY_SCOPE);
{
ecma_object_t *lex_env_tmp_p = (ecma_object_t *) lex_env_p;
ECMA_SET_POINTER(scope_prop_p->u.internal_property.value, lex_env_tmp_p);
}
ECMA_SET_POINTER(scope_prop_p->u.internal_property.value, lex_env_p);
ecma_gc_update_may_ref_younger_object_flag_by_object (map_p, lex_env_p);
ecma_deref_object (map_p);
@@ -223,7 +209,7 @@ ecma_create_arguments_object (ecma_object_ptr_t &obj_p, /**< out: object pointer
prop_desc = ecma_make_empty_property_descriptor ();
{
prop_desc.is_value_defined = true;
prop_desc.value = (ecma_value_packed_t) ecma_value_t (func_obj_p);
prop_desc.value = ecma_make_object_value (func_obj_p);
prop_desc.is_writable_defined = true;
prop_desc.is_writable = true;
@@ -237,28 +223,26 @@ ecma_create_arguments_object (ecma_object_ptr_t &obj_p, /**< out: object pointer
ecma_string_t *callee_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING_CALLEE);
ecma_op_object_define_own_property (completion,
obj_p,
callee_magic_string_p,
&prop_desc,
false);
completion = ecma_op_object_define_own_property (obj_p,
callee_magic_string_p,
&prop_desc,
false);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion));
ecma_deref_ecma_string (callee_magic_string_p);
}
else
{
ecma_object_ptr_t thrower_p;
ecma_builtin_get (thrower_p, ECMA_BUILTIN_ID_TYPE_ERROR_THROWER);
ecma_object_t *thrower_p = ecma_builtin_get (ECMA_BUILTIN_ID_TYPE_ERROR_THROWER);
// 14.
prop_desc = ecma_make_empty_property_descriptor ();
{
prop_desc.is_get_defined = true;
prop_desc.get_p = (ecma_object_t*) thrower_p;
prop_desc.get_p = thrower_p;
prop_desc.is_set_defined = true;
prop_desc.set_p = (ecma_object_t*) thrower_p;
prop_desc.set_p = thrower_p;
prop_desc.is_enumerable_defined = true;
prop_desc.is_enumerable = false;
@@ -270,17 +254,18 @@ ecma_create_arguments_object (ecma_object_ptr_t &obj_p, /**< out: object pointer
ecma_string_t *callee_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING_CALLEE);
ecma_string_t *caller_magic_string_p = ecma_get_magic_string (ECMA_MAGIC_STRING_CALLER);
ecma_op_object_define_own_property (completion,
obj_p,
callee_magic_string_p,
&prop_desc,
false);
completion = ecma_op_object_define_own_property (obj_p,
callee_magic_string_p,
&prop_desc,
false);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion));
ecma_deref_ecma_string (callee_magic_string_p);
ecma_deref_ecma_string (caller_magic_string_p);
ecma_deref_object (thrower_p);
}
return obj_p;
} /* ecma_create_arguments_object */
/**
@@ -289,26 +274,28 @@ ecma_create_arguments_object (ecma_object_ptr_t &obj_p, /**< out: object pointer
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
static void
ecma_arguments_get_mapped_arg_value (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& map_p, /**< [[ParametersMap]] object */
static ecma_completion_value_t
ecma_arguments_get_mapped_arg_value (ecma_object_t *map_p, /**< [[ParametersMap]] object */
ecma_property_t *arg_name_prop_p) /**< property of [[ParametersMap]]
corresponding to index and value
equal to mapped argument's name */
{
ecma_property_t *scope_prop_p = ecma_get_internal_property (map_p, ECMA_INTERNAL_PROPERTY_SCOPE);
ecma_object_ptr_t lex_env_p;
lex_env_p.unpack_from (scope_prop_p->u.internal_property.value);
JERRY_ASSERT(lex_env_p.is_not_null ()
ecma_object_t *lex_env_p = ECMA_GET_NON_NULL_POINTER (ecma_object_t,
scope_prop_p->u.internal_property.value);
JERRY_ASSERT(lex_env_p != NULL
&& ecma_is_lexical_environment (lex_env_p));
ecma_value_t arg_name_prop_value;
ecma_get_named_data_property_value (arg_name_prop_value, arg_name_prop_p);
ecma_value_t arg_name_prop_value = ecma_get_named_data_property_value (arg_name_prop_p);
ecma_string_t *arg_name_p = ecma_get_string_from_value (arg_name_prop_value);
ecma_op_get_binding_value (ret_value, lex_env_p, arg_name_p, true);
JERRY_ASSERT (ecma_is_completion_value_normal (ret_value));
ecma_completion_value_t completion = ecma_op_get_binding_value (lex_env_p,
arg_name_p,
true);
JERRY_ASSERT (ecma_is_completion_value_normal (completion));
return completion;
} /* ecma_arguments_get_mapped_arg_value */
/**
@@ -321,15 +308,14 @@ ecma_arguments_get_mapped_arg_value (ecma_completion_value_t &ret_value, /**< ou
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_arguments_object_get (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& obj_p, /**< the object */
ecma_completion_value_t
ecma_op_arguments_object_get (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p) /**< property name */
{
// 1.
ecma_property_t *map_prop_p = ecma_get_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_PARAMETERS_MAP);
ecma_object_ptr_t map_p;
map_p.unpack_from (map_prop_p->u.internal_property.value);
ecma_object_t *map_p = ECMA_GET_NON_NULL_POINTER (ecma_object_t,
map_prop_p->u.internal_property.value);
// 2.
ecma_property_t *mapped_prop_p = ecma_op_object_get_own_property (map_p, property_name_p);
@@ -340,12 +326,12 @@ ecma_op_arguments_object_get (ecma_completion_value_t &ret_value, /**< out: comp
/* We don't check for 'caller' (item 3.b) here, because the 'caller' property is defined
as non-configurable and it's get/set are set to [[ThrowTypeError]] object */
ecma_op_general_object_get (ret_value, obj_p, property_name_p);
return ecma_op_general_object_get (obj_p, property_name_p);
}
else
{
// 4.
ecma_arguments_get_mapped_arg_value (ret_value, map_p, mapped_prop_p);
return ecma_arguments_get_mapped_arg_value (map_p, mapped_prop_p);
}
} /* ecma_op_arguments_object_get */
@@ -360,7 +346,7 @@ ecma_op_arguments_object_get (ecma_completion_value_t &ret_value, /**< out: comp
* Returned value must be freed with ecma_free_completion_value
*/
ecma_property_t*
ecma_op_arguments_object_get_own_property (const ecma_object_ptr_t& obj_p, /**< the object */
ecma_op_arguments_object_get_own_property (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p) /**< property name */
{
// 1.
@@ -374,8 +360,8 @@ ecma_op_arguments_object_get_own_property (const ecma_object_ptr_t& obj_p, /**<
// 3.
ecma_property_t *map_prop_p = ecma_get_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_PARAMETERS_MAP);
ecma_object_ptr_t map_p;
map_p.unpack_from (map_prop_p->u.internal_property.value);
ecma_object_t *map_p = ECMA_GET_NON_NULL_POINTER (ecma_object_t,
map_prop_p->u.internal_property.value);
// 4.
ecma_property_t *mapped_prop_p = ecma_op_object_get_own_property (map_p, property_name_p);
@@ -384,15 +370,11 @@ ecma_op_arguments_object_get_own_property (const ecma_object_ptr_t& obj_p, /**<
if (mapped_prop_p != NULL)
{
// a.
ecma_completion_value_t get_mapped_arg_completion;
ecma_arguments_get_mapped_arg_value (get_mapped_arg_completion, map_p, mapped_prop_p);
ecma_completion_value_t completion = ecma_arguments_get_mapped_arg_value (map_p, mapped_prop_p);
ecma_value_t value_to_assign;
ecma_get_completion_value_value (value_to_assign, get_mapped_arg_completion);
ecma_named_data_property_assign_value (obj_p, desc_p, ecma_get_completion_value_value (completion));
ecma_named_data_property_assign_value (obj_p, desc_p, value_to_assign);
ecma_free_completion_value (get_mapped_arg_completion);
ecma_free_completion_value (completion);
}
// 6.
@@ -409,9 +391,8 @@ ecma_op_arguments_object_get_own_property (const ecma_object_ptr_t& obj_p, /**<
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_arguments_object_define_own_property (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& obj_p, /**< the object */
ecma_completion_value_t
ecma_op_arguments_object_define_own_property (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p, /**< property name */
const ecma_property_descriptor_t* property_desc_p, /**< property
* descriptor */
@@ -419,15 +400,21 @@ ecma_op_arguments_object_define_own_property (ecma_completion_value_t &ret_value
{
// 1.
ecma_property_t *map_prop_p = ecma_get_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_PARAMETERS_MAP);
ecma_object_ptr_t map_p;
map_p.unpack_from (map_prop_p->u.internal_property.value);
ecma_object_t *map_p = ECMA_GET_NON_NULL_POINTER (ecma_object_t,
map_prop_p->u.internal_property.value);
// 2.
ecma_property_t *mapped_prop_p = ecma_op_object_get_own_property (map_p, property_name_p);
// 3.
ECMA_TRY_CATCH (ret_value, ecma_op_general_object_define_own_property, defined,
obj_p, property_name_p, property_desc_p, is_throw);
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (defined,
ecma_op_general_object_define_own_property (obj_p,
property_name_p,
property_desc_p,
is_throw),
ret_value);
// 5.
if (mapped_prop_p != NULL)
@@ -436,28 +423,26 @@ ecma_op_arguments_object_define_own_property (ecma_completion_value_t &ret_value
if (property_desc_p->is_get_defined
|| property_desc_p->is_set_defined)
{
ecma_completion_value_t completion;
ecma_op_object_delete (completion, map_p, property_name_p, false);
ecma_completion_value_t completion = ecma_op_object_delete (map_p, property_name_p, false);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion));
// 6.
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_TRUE);
ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
else
{
// b.
ecma_completion_value_t completion;
ecma_completion_value_t completion = ecma_make_empty_completion_value ();
// i.
if (property_desc_p->is_value_defined)
{
ecma_op_object_put (completion,
map_p,
property_name_p,
ecma_value_t (property_desc_p->value),
is_throw);
completion = ecma_op_object_put (map_p,
property_name_p,
property_desc_p->value,
is_throw);
}
if (unlikely (ecma_is_completion_value_throw (completion)))
@@ -470,24 +455,26 @@ ecma_op_arguments_object_define_own_property (ecma_completion_value_t &ret_value
if (property_desc_p->is_writable_defined
&& !property_desc_p->is_writable)
{
ecma_op_object_delete (completion,
map_p,
property_name_p,
false);
completion = ecma_op_object_delete (map_p,
property_name_p,
false);
JERRY_ASSERT (ecma_is_completion_value_normal_true (completion));
}
// 6.
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_TRUE);
ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
}
}
else
{
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_TRUE);
ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
ECMA_FINALIZE (defined);
return ret_value;
} /* ecma_op_arguments_object_define_own_property */
/**
@@ -500,45 +487,50 @@ ecma_op_arguments_object_define_own_property (ecma_completion_value_t &ret_value
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_arguments_object_delete (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& obj_p, /**< the object */
ecma_completion_value_t
ecma_op_arguments_object_delete (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p, /**< property name */
bool is_throw) /**< flag that controls failure handling */
{
// 1.
ecma_property_t *map_prop_p = ecma_get_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_PARAMETERS_MAP);
ecma_object_ptr_t map_p;
map_p.unpack_from (map_prop_p->u.internal_property.value);
ecma_object_t *map_p = ECMA_GET_NON_NULL_POINTER (ecma_object_t,
map_prop_p->u.internal_property.value);
// 2.
ecma_property_t *mapped_prop_p = ecma_op_object_get_own_property (map_p, property_name_p);
// 3.
ECMA_TRY_CATCH (ret_value, ecma_op_general_object_delete, delete_in_args_ret, obj_p, property_name_p, is_throw);
ecma_completion_value_t ret_value;
ECMA_TRY_CATCH (delete_in_args_ret,
ecma_op_general_object_delete (obj_p,
property_name_p,
is_throw),
ret_value);
if (ecma_is_value_true (delete_in_args_ret))
{
if (mapped_prop_p != NULL)
{
ecma_completion_value_t delete_in_map_completion;
ecma_op_object_delete (delete_in_map_completion,
map_p,
property_name_p,
false);
ecma_completion_value_t delete_in_map_completion = ecma_op_object_delete (map_p,
property_name_p,
false);
JERRY_ASSERT (ecma_is_completion_value_normal_true (delete_in_map_completion));
}
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_TRUE);
ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
else
{
JERRY_ASSERT (ecma_is_value_boolean (delete_in_args_ret));
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_FALSE);
ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE);
}
ECMA_FINALIZE (delete_in_args_ret);
return ret_value;
} /* ecma_op_arguments_object_delete */
/**
src/libecmaoperations/ecma-objects-arguments.h
+12 -20
View File
@@ -18,32 +18,24 @@
#include "ecma-globals.h"
#include "ecma-helpers.h"
#include "ecma-value.h"
extern void
ecma_create_arguments_object (ecma_object_ptr_t &ret_val,
const ecma_object_ptr_t& func_obj_p,
const ecma_object_ptr_t& lex_env_p,
extern ecma_object_t*
ecma_create_arguments_object (ecma_object_t *func_obj_p,
ecma_object_t *lex_env_p,
ecma_collection_iterator_t *formal_params_iter_p,
const ecma_value_t *arguments_list_p,
ecma_length_t arguments_list_length,
bool is_strict);
extern void
ecma_op_arguments_object_get (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& obj_p,
ecma_string_t *property_name_p);
extern ecma_property_t*
ecma_op_arguments_object_get_own_property (const ecma_object_ptr_t& obj_p,
ecma_string_t *property_name_p);
extern void
ecma_op_arguments_object_delete (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& obj_p,
ecma_string_t *property_name_p,
bool is_throw);
extern void
ecma_op_arguments_object_define_own_property (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& obj_p,
extern ecma_completion_value_t ecma_op_arguments_object_get (ecma_object_t *obj_p,
ecma_string_t *property_name_p);
extern ecma_property_t *ecma_op_arguments_object_get_own_property (ecma_object_t *obj_p,
ecma_string_t *property_name_p);
extern ecma_completion_value_t ecma_op_arguments_object_delete (ecma_object_t *obj_p,
ecma_string_t *property_name_p,
bool is_throw);
extern ecma_completion_value_t
ecma_op_arguments_object_define_own_property (ecma_object_t *obj_p,
ecma_string_t *property_name_p,
const ecma_property_descriptor_t* property_desc_p,
bool is_throw);
src/libecmaoperations/ecma-objects-general.c
+127 -185
View File
@@ -36,19 +36,16 @@
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
static void
ecma_reject (ecma_completion_value_t &ret_value, /**< out: completion value */
bool is_throw) /**< Throw flag */
static ecma_completion_value_t
ecma_reject (bool is_throw) /**< Throw flag */
{
if (is_throw)
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_TYPE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_FALSE);
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE);
}
} /* ecma_reject */
@@ -59,19 +56,20 @@ ecma_reject (ecma_completion_value_t &ret_value, /**< out: completion value */
*
* @return pointer to newly created 'Object' object
*/
void
ecma_op_create_object_object_noarg (ecma_object_ptr_t &obj_p) /**< out: object pointer */
ecma_object_t*
ecma_op_create_object_object_noarg (void)
{
ecma_object_ptr_t object_prototype_p;
ecma_builtin_get (object_prototype_p, ECMA_BUILTIN_ID_OBJECT_PROTOTYPE);
ecma_object_t *object_prototype_p = ecma_builtin_get (ECMA_BUILTIN_ID_OBJECT_PROTOTYPE);
// 3., 4., 6., 7.
ecma_create_object (obj_p, object_prototype_p, true, ECMA_OBJECT_TYPE_GENERAL);
ecma_object_t *obj_p = ecma_create_object (object_prototype_p, true, ECMA_OBJECT_TYPE_GENERAL);
ecma_deref_object (object_prototype_p);
ecma_property_t *class_prop_p = ecma_create_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_CLASS);
class_prop_p->u.internal_property.value = ECMA_MAGIC_STRING_OBJECT_UL;
return obj_p;
} /* ecma_op_create_object_object_noarg */
/**
@@ -81,9 +79,8 @@ ecma_op_create_object_object_noarg (ecma_object_ptr_t &obj_p) /**< out: object p
*
* @return pointer to newly created 'Object' object
*/
void
ecma_op_create_object_object_arg (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_value_t& value) /**< argument of constructor */
ecma_completion_value_t
ecma_op_create_object_object_arg (const ecma_value_t& value) /**< argument of constructor */
{
ecma_check_value_type_is_spec_defined (value);
@@ -93,7 +90,7 @@ ecma_op_create_object_object_arg (ecma_completion_value_t &ret_value, /**< out:
|| ecma_is_value_boolean (value))
{
// 1.b, 1.c, 1.d
ecma_op_to_object (ret_value, value);
return ecma_op_to_object (value);
}
else
{
@@ -101,10 +98,9 @@ ecma_op_create_object_object_arg (ecma_completion_value_t &ret_value, /**< out:
JERRY_ASSERT (ecma_is_value_undefined (value)
|| ecma_is_value_null (value));
ecma_object_ptr_t obj_p;
ecma_op_create_object_object_noarg (obj_p);
ecma_object_t *obj_p = ecma_op_create_object_object_noarg ();
ecma_make_normal_completion_value (ret_value, ecma_value_t (obj_p));
return ecma_make_normal_completion_value (ecma_make_object_value (obj_p));
}
} /* ecma_op_create_object_object_arg */
@@ -118,12 +114,11 @@ ecma_op_create_object_object_arg (ecma_completion_value_t &ret_value, /**< out:
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_general_object_get (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& obj_p, /**< the object */
ecma_completion_value_t
ecma_op_general_object_get (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p) /**< property name */
{
JERRY_ASSERT(obj_p.is_not_null ()
JERRY_ASSERT(obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
JERRY_ASSERT(property_name_p != NULL);
@@ -133,41 +128,36 @@ ecma_op_general_object_get (ecma_completion_value_t &ret_value, /**< out: comple
// 2.
if (prop_p == NULL)
{
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_UNDEFINED);
return;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_UNDEFINED);
}
// 3.
if (prop_p->type == ECMA_PROPERTY_NAMEDDATA)
{
ecma_value_t prop_value;
ecma_get_named_data_property_value (prop_value, prop_p);
ecma_value_t prop_value_copy;
ecma_copy_value (prop_value_copy, prop_value, true);
ecma_make_normal_completion_value (ret_value, prop_value_copy);
return ecma_make_normal_completion_value (ecma_copy_value (ecma_get_named_data_property_value (prop_p),
true));
}
else
{
// 4.
ecma_object_ptr_t getter_p;
getter_p.unpack_from (prop_p->u.named_accessor_property.get_p, true);
ecma_object_t *getter_p = ECMA_GET_POINTER (ecma_object_t,
prop_p->u.named_accessor_property.get_p);
// 5.
if (getter_p.is_null ())
if (getter_p == NULL)
{
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_UNDEFINED);
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_UNDEFINED);
}
else
{
ecma_op_function_call (ret_value,
getter_p,
ecma_value_t (obj_p),
NULL,
0);
return ecma_op_function_call (getter_p,
ecma_make_object_value (obj_p),
NULL,
0);
}
}
JERRY_UNREACHABLE();
} /* ecma_op_general_object_get */
/**
@@ -181,10 +171,10 @@ ecma_op_general_object_get (ecma_completion_value_t &ret_value, /**< out: comple
* NULL (i.e. ecma-undefined) - otherwise.
*/
ecma_property_t*
ecma_op_general_object_get_own_property (const ecma_object_ptr_t& obj_p, /**< the object */
ecma_op_general_object_get_own_property (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p) /**< property name */
{
JERRY_ASSERT(obj_p.is_not_null ()
JERRY_ASSERT(obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
JERRY_ASSERT(property_name_p != NULL);
@@ -202,10 +192,10 @@ ecma_op_general_object_get_own_property (const ecma_object_ptr_t& obj_p, /**< th
* NULL (i.e. ecma-undefined) - otherwise.
*/
ecma_property_t*
ecma_op_general_object_get_property (const ecma_object_ptr_t& obj_p, /**< the object */
ecma_op_general_object_get_property (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p) /**< property name */
{
JERRY_ASSERT(obj_p.is_not_null ()
JERRY_ASSERT(obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
JERRY_ASSERT(property_name_p != NULL);
@@ -219,11 +209,10 @@ ecma_op_general_object_get_property (const ecma_object_ptr_t& obj_p, /**< the ob
}
// 3.
ecma_object_ptr_t prototype_p;
ecma_get_object_prototype (prototype_p, obj_p);
ecma_object_t *prototype_p = ecma_get_object_prototype (obj_p);
// 4., 5.
if (prototype_p.is_not_null ())
if (prototype_p != NULL)
{
return ecma_op_object_get_property (prototype_p, property_name_p);
}
@@ -243,14 +232,13 @@ ecma_op_general_object_get_property (const ecma_object_ptr_t& obj_p, /**< the ob
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_general_object_put (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& obj_p, /**< the object */
ecma_completion_value_t
ecma_op_general_object_put (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p, /**< property name */
const ecma_value_t& value, /**< ecma-value */
bool is_throw) /**< flag that controls failure handling */
{
JERRY_ASSERT(obj_p.is_not_null ()
JERRY_ASSERT(obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
JERRY_ASSERT(property_name_p != NULL);
@@ -260,16 +248,12 @@ ecma_op_general_object_put (ecma_completion_value_t &ret_value, /**< out: comple
if (is_throw)
{
// a.
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_TYPE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
return;
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
// b.
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_FALSE);
return;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE);
}
}
@@ -284,16 +268,14 @@ ecma_op_general_object_put (ecma_completion_value_t &ret_value, /**< out: comple
ecma_property_descriptor_t value_desc = ecma_make_empty_property_descriptor ();
{
value_desc.is_value_defined = true;
value_desc.value = (ecma_value_packed_t) value;
value_desc.value = value;
}
// b., c.
ecma_op_object_define_own_property (ret_value,
obj_p,
property_name_p,
&value_desc,
is_throw);
return;
return ecma_op_object_define_own_property (obj_p,
property_name_p,
&value_desc,
is_throw);
}
// 4.
@@ -304,15 +286,24 @@ ecma_op_general_object_put (ecma_completion_value_t &ret_value, /**< out: comple
&& desc_p->type == ECMA_PROPERTY_NAMEDACCESSOR)
{
// a.
ecma_object_ptr_t setter_p;
setter_p.unpack_from (desc_p->u.named_accessor_property.set_p);
JERRY_ASSERT(setter_p.is_not_null ());
ecma_object_t *setter_p = ECMA_GET_NON_NULL_POINTER (ecma_object_t,
desc_p->u.named_accessor_property.set_p);
JERRY_ASSERT(setter_p != NULL);
ECMA_TRY_CATCH (ret_value, ecma_op_function_call, call_ret, setter_p, ecma_value_t (obj_p), &value, 1);
ecma_completion_value_t ret_value;
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_TRUE);
ECMA_TRY_CATCH (call_ret,
ecma_op_function_call (setter_p,
ecma_make_object_value (obj_p),
&value,
1),
ret_value);
ret_value = ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
ECMA_FINALIZE (call_ret);
return ret_value;
}
else
{
@@ -322,7 +313,7 @@ ecma_op_general_object_put (ecma_completion_value_t &ret_value, /**< out: comple
ecma_property_descriptor_t new_desc = ecma_make_empty_property_descriptor ();
{
new_desc.is_value_defined = true;
new_desc.value = (ecma_value_packed_t) value;
new_desc.value = value;
new_desc.is_writable_defined = true;
new_desc.is_writable = true;
@@ -335,12 +326,13 @@ ecma_op_general_object_put (ecma_completion_value_t &ret_value, /**< out: comple
}
// b.
ecma_op_object_define_own_property (ret_value,
obj_p,
property_name_p,
&new_desc,
is_throw);
return ecma_op_object_define_own_property (obj_p,
property_name_p,
&new_desc,
is_throw);
}
JERRY_UNREACHABLE();
} /* ecma_op_general_object_put */
/**
@@ -354,10 +346,10 @@ ecma_op_general_object_put (ecma_completion_value_t &ret_value, /**< out: comple
* false - otherwise.
*/
bool
ecma_op_general_object_can_put (const ecma_object_ptr_t& obj_p, /**< the object */
ecma_op_general_object_can_put (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p) /**< property name */
{
JERRY_ASSERT(obj_p.is_not_null ()
JERRY_ASSERT(obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
JERRY_ASSERT(property_name_p != NULL);
@@ -393,11 +385,10 @@ ecma_op_general_object_can_put (const ecma_object_ptr_t& obj_p, /**< the object
}
// 3.
ecma_object_ptr_t proto_p;
ecma_get_object_prototype (proto_p, obj_p);
ecma_object_t *proto_p = ecma_get_object_prototype (obj_p);
// 4.
if (proto_p.is_null ())
if (proto_p == NULL)
{
return ecma_get_object_extensible (obj_p);
}
@@ -414,11 +405,11 @@ ecma_op_general_object_can_put (const ecma_object_ptr_t& obj_p, /**< the object
// 7.
if (inherited_p->type == ECMA_PROPERTY_NAMEDACCESSOR)
{
ecma_object_ptr_t setter_p;
setter_p.unpack_from (inherited_p->u.named_accessor_property.set_p, true);
ecma_object_t *setter_p = ECMA_GET_POINTER (ecma_object_t,
inherited_p->u.named_accessor_property.set_p);
// a.
if (setter_p.is_null ())
if (setter_p == NULL)
{
return false;
}
@@ -456,13 +447,12 @@ ecma_op_general_object_can_put (const ecma_object_ptr_t& obj_p, /**< the object
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_general_object_delete (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& obj_p, /**< the object */
ecma_completion_value_t
ecma_op_general_object_delete (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p, /**< property name */
bool is_throw) /**< flag that controls failure handling */
{
JERRY_ASSERT(obj_p.is_not_null ()
JERRY_ASSERT(obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
JERRY_ASSERT(property_name_p != NULL);
@@ -472,8 +462,7 @@ ecma_op_general_object_delete (ecma_completion_value_t &ret_value, /**< out: com
// 2.
if (desc_p == NULL)
{
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_TRUE);
return;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
// 3.
@@ -483,20 +472,20 @@ ecma_op_general_object_delete (ecma_completion_value_t &ret_value, /**< out: com
ecma_delete_property (obj_p, desc_p);
// b.
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_TRUE);
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
else if (is_throw)
{
// 4.
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_TYPE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
// 5.
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_FALSE);
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE);
}
JERRY_UNREACHABLE();
} /* ecma_op_general_object_delete */
/**
@@ -509,12 +498,11 @@ ecma_op_general_object_delete (ecma_completion_value_t &ret_value, /**< out: com
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_general_object_default_value (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& obj_p, /**< the object */
ecma_completion_value_t
ecma_op_general_object_default_value (ecma_object_t *obj_p, /**< the object */
ecma_preferred_type_hint_t hint) /**< hint on preferred result type */
{
JERRY_ASSERT(obj_p.is_not_null ()
JERRY_ASSERT(obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
if (hint == ECMA_PREFERRED_TYPE_NO)
@@ -549,59 +537,43 @@ ecma_op_general_object_default_value (ecma_completion_value_t &ret_value, /**< o
ecma_string_t *function_name_p = ecma_get_magic_string (function_name_magic_string_id);
ecma_completion_value_t function_value_get_completion;
ecma_op_object_get (function_value_get_completion, obj_p, function_name_p);
ecma_completion_value_t function_value_get_completion = ecma_op_object_get (obj_p, function_name_p);
ecma_deref_ecma_string (function_name_p);
if (!ecma_is_completion_value_normal (function_value_get_completion))
{
ret_value = function_value_get_completion;
return;
return function_value_get_completion;
}
ecma_completion_value_t call_completion;
ecma_completion_value_t call_completion = ecma_make_empty_completion_value ();
ecma_value_t function_value_get;
ecma_get_completion_value_value (function_value_get, function_value_get_completion);
if (ecma_op_is_callable (function_value_get))
if (ecma_op_is_callable (ecma_get_completion_value_value (function_value_get_completion)))
{
ecma_object_ptr_t func_obj_p;
ecma_get_object_from_value (func_obj_p, function_value_get);
ecma_object_t *func_obj_p = ecma_get_object_from_completion_value (function_value_get_completion);
ecma_op_function_call (call_completion,
func_obj_p,
ecma_value_t (obj_p),
NULL, 0);
call_completion = ecma_op_function_call (func_obj_p,
ecma_make_object_value (obj_p),
NULL, 0);
}
ecma_free_completion_value (function_value_get_completion);
if (!ecma_is_completion_value_normal (call_completion))
{
ret_value = call_completion;
return;
return call_completion;
}
if (!ecma_is_completion_value_empty (call_completion))
if (!ecma_is_completion_value_empty (call_completion)
&& !ecma_is_value_object (ecma_get_completion_value_value (call_completion)))
{
ecma_value_t call_ret_value;
ecma_get_completion_value_value (call_ret_value, call_completion);
if (!ecma_is_value_object (call_ret_value))
{
ret_value = call_completion;
return;
}
return call_completion;
}
ecma_free_completion_value (call_completion);
}
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_TYPE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
} /* ecma_op_general_object_default_value */
/**
@@ -614,15 +586,14 @@ ecma_op_general_object_default_value (ecma_completion_value_t &ret_value, /**< o
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_general_object_define_own_property (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& obj_p, /**< the object */
ecma_completion_value_t
ecma_op_general_object_define_own_property (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p, /**< property name */
const ecma_property_descriptor_t* property_desc_p, /**< property
* descriptor */
bool is_throw) /**< flag that controls failure handling */
{
JERRY_ASSERT(obj_p.is_not_null ()
JERRY_ASSERT(obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
JERRY_ASSERT(property_name_p != NULL);
@@ -646,8 +617,7 @@ ecma_op_general_object_define_own_property (ecma_completion_value_t &ret_value,
// 3.
if (!extensible)
{
ecma_reject (ret_value, is_throw);
return;
return ecma_reject (is_throw);
}
// 4.
@@ -662,29 +632,23 @@ ecma_op_general_object_define_own_property (ecma_completion_value_t &ret_value,
property_desc_p->is_enumerable,
property_desc_p->is_configurable);
ecma_named_data_property_assign_value (obj_p, new_prop_p, ecma_value_t (property_desc_p->value));
ecma_named_data_property_assign_value (obj_p, new_prop_p, property_desc_p->value);
}
else
{
// b.
JERRY_ASSERT(is_property_desc_accessor_descriptor);
ecma_object_ptr_t get_p, set_p;
get_p = property_desc_p->get_p;
set_p = property_desc_p->set_p;
ecma_create_named_accessor_property (obj_p,
property_name_p,
get_p,
set_p,
property_desc_p->get_p,
property_desc_p->set_p,
property_desc_p->is_enumerable,
property_desc_p->is_configurable);
}
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_TRUE);
return;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
// 5.
@@ -692,8 +656,7 @@ ecma_op_general_object_define_own_property (ecma_completion_value_t &ret_value,
&& !property_desc_p->is_enumerable_defined
&& !property_desc_p->is_configurable_defined)
{
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_TRUE);
return;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
// 6.
@@ -705,12 +668,9 @@ ecma_op_general_object_define_own_property (ecma_completion_value_t &ret_value,
bool is_every_field_in_desc_also_occurs_in_current_desc_with_same_value = true;
if (property_desc_p->is_value_defined)
{
ecma_value_t prop_value;
ecma_get_named_data_property_value (prop_value, current_p);
if (!is_current_data_descriptor
|| !ecma_op_same_value (ecma_value_t (property_desc_p->value),
prop_value))
|| !ecma_op_same_value (property_desc_p->value,
ecma_get_named_data_property_value (current_p)))
{
is_every_field_in_desc_also_occurs_in_current_desc_with_same_value = false;
}
@@ -763,8 +723,7 @@ ecma_op_general_object_define_own_property (ecma_completion_value_t &ret_value,
if (is_every_field_in_desc_also_occurs_in_current_desc_with_same_value)
{
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_TRUE);
return;
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
// 7.
@@ -775,8 +734,7 @@ ecma_op_general_object_define_own_property (ecma_completion_value_t &ret_value,
&& property_desc_p->is_enumerable != ecma_is_property_enumerable (current_p)))
{
// a., b.
ecma_reject (ret_value, is_throw);
return;
return ecma_reject (is_throw);
}
}
@@ -791,8 +749,7 @@ ecma_op_general_object_define_own_property (ecma_completion_value_t &ret_value,
if (!ecma_is_property_configurable (current_p))
{
// a.
ecma_reject (ret_value, is_throw);
return;
return ecma_reject (is_throw);
}
ecma_delete_property (obj_p, current_p);
@@ -800,12 +757,11 @@ ecma_op_general_object_define_own_property (ecma_completion_value_t &ret_value,
if (is_current_data_descriptor)
{
// b.
ecma_object_ptr_t null_pointer;
current_p = ecma_create_named_accessor_property (obj_p,
property_name_p,
null_pointer,
null_pointer,
NULL,
NULL,
ecma_is_property_enumerable (current_p),
ecma_is_property_configurable (current_p));
}
@@ -831,20 +787,15 @@ ecma_op_general_object_define_own_property (ecma_completion_value_t &ret_value,
// i.
if (property_desc_p->is_writable)
{
ecma_reject (ret_value, is_throw);
return;
return ecma_reject (is_throw);
}
// ii.
ecma_value_t prop_value;
ecma_get_named_data_property_value (prop_value, current_p);
if (property_desc_p->is_value_defined
&& !ecma_op_same_value (ecma_value_t (property_desc_p->value),
prop_value))
&& !ecma_op_same_value (property_desc_p->value,
ecma_get_named_data_property_value (current_p)))
{
ecma_reject (ret_value, is_throw);
return;
return ecma_reject (is_throw);
}
}
}
@@ -867,8 +818,7 @@ ecma_op_general_object_define_own_property (ecma_completion_value_t &ret_value,
current_p->u.named_accessor_property.set_p)))
{
// i., ii.
ecma_reject (ret_value, is_throw);
return;
return ecma_reject (is_throw);
}
}
}
@@ -878,7 +828,7 @@ ecma_op_general_object_define_own_property (ecma_completion_value_t &ret_value,
{
JERRY_ASSERT(is_current_data_descriptor);
ecma_named_data_property_assign_value (obj_p, current_p, ecma_value_t (property_desc_p->value));
ecma_named_data_property_assign_value (obj_p, current_p, property_desc_p->value);
}
if (property_desc_p->is_writable_defined)
@@ -892,13 +842,9 @@ ecma_op_general_object_define_own_property (ecma_completion_value_t &ret_value,
{
JERRY_ASSERT(is_current_accessor_descriptor);
ecma_object_ptr_t get_p;
get_p = property_desc_p->get_p;
ecma_object_t *get_p = property_desc_p->get_p;
{
ecma_object_t *get_tmp_p = (ecma_object_t*) get_p;
ECMA_SET_POINTER(current_p->u.named_accessor_property.get_p, get_tmp_p);
}
ECMA_SET_POINTER(current_p->u.named_accessor_property.get_p, get_p);
ecma_gc_update_may_ref_younger_object_flag_by_object (obj_p, get_p);
}
@@ -906,13 +852,9 @@ ecma_op_general_object_define_own_property (ecma_completion_value_t &ret_value,
{
JERRY_ASSERT(is_current_accessor_descriptor);
ecma_object_ptr_t set_p;
set_p = property_desc_p->set_p;
ecma_object_t *set_p = property_desc_p->set_p;
{
ecma_object_t *set_tmp_p = (ecma_object_t*) set_p;
ECMA_SET_POINTER(current_p->u.named_accessor_property.set_p, set_tmp_p);
}
ECMA_SET_POINTER(current_p->u.named_accessor_property.set_p, set_p);
ecma_gc_update_may_ref_younger_object_flag_by_object (obj_p, set_p);
}
@@ -926,7 +868,7 @@ ecma_op_general_object_define_own_property (ecma_completion_value_t &ret_value,
ecma_set_property_configurable_attr (current_p, property_desc_p->is_configurable);
}
ecma_make_simple_completion_value (ret_value, ECMA_SIMPLE_VALUE_TRUE);
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
} /* ecma_op_general_object_define_own_property */
/**
src/libecmaoperations/ecma-objects-general.h
+21 -37
View File
@@ -18,7 +18,6 @@
#include "ecma-conversion.h"
#include "ecma-globals.h"
#include "ecma-value.h"
/** \addtogroup ecma ECMA
* @{
@@ -27,43 +26,28 @@
* @{
*/
extern void
ecma_op_create_object_object_noarg (ecma_object_ptr_t &ret_val);
extern void
ecma_op_create_object_object_arg (ecma_completion_value_t &ret_value,
const ecma_value_t& value);
extern ecma_object_t* ecma_op_create_object_object_noarg (void);
extern ecma_completion_value_t ecma_op_create_object_object_arg (const ecma_value_t& value);
extern void
ecma_op_general_object_get (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& obj_p,
ecma_string_t *property_name_p);
extern ecma_property_t*
ecma_op_general_object_get_own_property (const ecma_object_ptr_t& obj_p,
ecma_string_t *property_name_p);
extern ecma_property_t*
ecma_op_general_object_get_property (const ecma_object_ptr_t& obj_p,
ecma_string_t *property_name_p);
extern void
ecma_op_general_object_put (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& obj_p,
ecma_string_t *property_name_p,
const ecma_value_t& value,
bool is_throw);
extern bool
ecma_op_general_object_can_put (const ecma_object_ptr_t& obj_p,
ecma_string_t *property_name_p);
extern void
ecma_op_general_object_delete (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& obj_p,
ecma_string_t *property_name_p,
bool is_throw);
extern void
ecma_op_general_object_default_value (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& obj_p,
ecma_preferred_type_hint_t hint);
extern void
ecma_op_general_object_define_own_property (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& obj_p,
extern ecma_completion_value_t ecma_op_general_object_get (ecma_object_t *obj_p,
ecma_string_t *property_name_p);
extern ecma_property_t *ecma_op_general_object_get_own_property (ecma_object_t *obj_p,
ecma_string_t *property_name_p);
extern ecma_property_t *ecma_op_general_object_get_property (ecma_object_t *obj_p,
ecma_string_t *property_name_p);
extern ecma_completion_value_t ecma_op_general_object_put (ecma_object_t *obj_p,
ecma_string_t *property_name_p,
const ecma_value_t& value,
bool is_throw);
extern bool ecma_op_general_object_can_put (ecma_object_t *obj_p,
ecma_string_t *property_name_p);
extern ecma_completion_value_t ecma_op_general_object_delete (ecma_object_t *obj_p,
ecma_string_t *property_name_p,
bool is_throw);
extern ecma_completion_value_t ecma_op_general_object_default_value (ecma_object_t *obj_p,
ecma_preferred_type_hint_t hint);
extern ecma_completion_value_t
ecma_op_general_object_define_own_property (ecma_object_t *obj_p,
ecma_string_t *property_name_p,
const ecma_property_descriptor_t* property_desc_p,
bool is_throw);
src/libecmaoperations/ecma-objects.c
+56 -78
View File
@@ -40,12 +40,11 @@
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_object_get (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& obj_p, /**< the object */
ecma_completion_value_t
ecma_op_object_get (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p) /**< property name */
{
JERRY_ASSERT(obj_p.is_not_null ()
JERRY_ASSERT(obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
JERRY_ASSERT(property_name_p != NULL);
@@ -61,21 +60,19 @@ ecma_op_object_get (ecma_completion_value_t &ret_value, /**< out: completion val
case ECMA_OBJECT_TYPE_BUILT_IN_FUNCTION:
case ECMA_OBJECT_TYPE_STRING:
{
ecma_op_general_object_get (ret_value, obj_p, property_name_p);
return;
return ecma_op_general_object_get (obj_p, property_name_p);
}
case ECMA_OBJECT_TYPE_ARGUMENTS:
{
ecma_op_arguments_object_get (ret_value, obj_p, property_name_p);
return;
return ecma_op_arguments_object_get (obj_p, property_name_p);
}
default:
{
JERRY_ASSERT (false);
ecma_make_empty_completion_value (ret_value);
return ecma_make_empty_completion_value ();
}
}
} /* ecma_op_object_get */
@@ -87,7 +84,7 @@ ecma_op_object_get (ecma_completion_value_t &ret_value, /**< out: completion val
* NULL (i.e. ecma-undefined) - otherwise.
*/
static __noinline ecma_property_t*
ecma_op_object_get_own_property_longpath (const ecma_object_ptr_t& obj_p, /**< the object */
ecma_op_object_get_own_property_longpath (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p) /**< property name */
{
const ecma_object_type_t type = ecma_get_object_type (obj_p);
@@ -154,10 +151,10 @@ ecma_op_object_get_own_property_longpath (const ecma_object_ptr_t& obj_p, /**< t
* NULL (i.e. ecma-undefined) - otherwise.
*/
ecma_property_t*
ecma_op_object_get_own_property (const ecma_object_ptr_t& obj_p, /**< the object */
ecma_op_object_get_own_property (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p) /**< property name */
{
JERRY_ASSERT(obj_p.is_not_null ()
JERRY_ASSERT(obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
JERRY_ASSERT(property_name_p != NULL);
@@ -183,10 +180,10 @@ ecma_op_object_get_own_property (const ecma_object_ptr_t& obj_p, /**< the object
* NULL (i.e. ecma-undefined) - otherwise.
*/
ecma_property_t*
ecma_op_object_get_property (const ecma_object_ptr_t& obj_p, /**< the object */
ecma_op_object_get_property (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p) /**< property name */
{
JERRY_ASSERT(obj_p.is_not_null ()
JERRY_ASSERT(obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
JERRY_ASSERT(property_name_p != NULL);
@@ -194,7 +191,7 @@ ecma_op_object_get_property (const ecma_object_ptr_t& obj_p, /**< the object */
JERRY_ASSERT (type < ECMA_OBJECT_TYPE__COUNT);
/*
* typedef ecma_property_t* (*get_property_ptr_t) (const ecma_object_ptr_t& , ecma_string_t *);
* typedef ecma_property_t* (*get_property_ptr_t) (ecma_object_t *, ecma_string_t *);
* static const get_property_ptr_t get_property [ECMA_OBJECT_TYPE__COUNT] =
* {
* [ECMA_OBJECT_TYPE_GENERAL] = &ecma_op_general_object_get_property,
@@ -221,14 +218,13 @@ ecma_op_object_get_property (const ecma_object_ptr_t& obj_p, /**< the object */
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_object_put (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& obj_p, /**< the object */
ecma_completion_value_t
ecma_op_object_put (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p, /**< property name */
const ecma_value_t& value, /**< ecma-value */
bool is_throw) /**< flag that controls failure handling */
{
JERRY_ASSERT(obj_p.is_not_null ()
JERRY_ASSERT(obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
JERRY_ASSERT(property_name_p != NULL);
@@ -236,7 +232,7 @@ ecma_op_object_put (ecma_completion_value_t &ret_value, /**< out: completion val
JERRY_ASSERT (type < ECMA_OBJECT_TYPE__COUNT);
/*
* typedef ecma_property_t* (*put_ptr_t) (const ecma_object_ptr_t& , ecma_string_t *);
* typedef ecma_property_t* (*put_ptr_t) (ecma_object_t *, ecma_string_t *);
* static const put_ptr_t put [ECMA_OBJECT_TYPE__COUNT] =
* {
* [ECMA_OBJECT_TYPE_GENERAL] = &ecma_op_general_object_put,
@@ -251,7 +247,7 @@ ecma_op_object_put (ecma_completion_value_t &ret_value, /**< out: completion val
* return put[type] (obj_p, property_name_p);
*/
ecma_op_general_object_put (ret_value, obj_p, property_name_p, value, is_throw);
return ecma_op_general_object_put (obj_p, property_name_p, value, is_throw);
} /* ecma_op_object_put */
/**
@@ -264,10 +260,10 @@ ecma_op_object_put (ecma_completion_value_t &ret_value, /**< out: completion val
* false - otherwise.
*/
bool
ecma_op_object_can_put (const ecma_object_ptr_t& obj_p, /**< the object */
ecma_op_object_can_put (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p) /**< property name */
{
JERRY_ASSERT(obj_p.is_not_null ()
JERRY_ASSERT(obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
JERRY_ASSERT(property_name_p != NULL);
@@ -275,7 +271,7 @@ ecma_op_object_can_put (const ecma_object_ptr_t& obj_p, /**< the object */
JERRY_ASSERT (type < ECMA_OBJECT_TYPE__COUNT);
/*
* typedef ecma_property_t* (*can_put_ptr_t) (const ecma_object_ptr_t& , ecma_string_t *);
* typedef ecma_property_t* (*can_put_ptr_t) (ecma_object_t *, ecma_string_t *);
* static const can_put_ptr_t can_put [ECMA_OBJECT_TYPE__COUNT] =
* {
* [ECMA_OBJECT_TYPE_GENERAL] = &ecma_op_general_object_can_put,
@@ -302,13 +298,12 @@ ecma_op_object_can_put (const ecma_object_ptr_t& obj_p, /**< the object */
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_object_delete (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& obj_p, /**< the object */
ecma_completion_value_t
ecma_op_object_delete (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p, /**< property name */
bool is_throw) /**< flag that controls failure handling */
{
JERRY_ASSERT(obj_p.is_not_null ()
JERRY_ASSERT(obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
JERRY_ASSERT(property_name_p != NULL);
@@ -324,27 +319,23 @@ ecma_op_object_delete (ecma_completion_value_t &ret_value, /**< out: completion
case ECMA_OBJECT_TYPE_BUILT_IN_FUNCTION:
case ECMA_OBJECT_TYPE_STRING:
{
ecma_op_general_object_delete (ret_value,
obj_p,
property_name_p,
is_throw);
return;
return ecma_op_general_object_delete (obj_p,
property_name_p,
is_throw);
}
case ECMA_OBJECT_TYPE_ARGUMENTS:
{
ecma_op_arguments_object_delete (ret_value,
obj_p,
property_name_p,
is_throw);
return;
return ecma_op_arguments_object_delete (obj_p,
property_name_p,
is_throw);
}
default:
{
JERRY_ASSERT (false);
ecma_make_empty_completion_value (ret_value);
return ecma_make_empty_completion_value ();
}
}
} /* ecma_op_object_delete */
@@ -358,19 +349,18 @@ ecma_op_object_delete (ecma_completion_value_t &ret_value, /**< out: completion
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_object_default_value (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& obj_p, /**< the object */
ecma_completion_value_t
ecma_op_object_default_value (ecma_object_t *obj_p, /**< the object */
ecma_preferred_type_hint_t hint) /**< hint on preferred result type */
{
JERRY_ASSERT(obj_p.is_not_null ()
JERRY_ASSERT(obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
const ecma_object_type_t type = ecma_get_object_type (obj_p);
JERRY_ASSERT (type < ECMA_OBJECT_TYPE__COUNT);
/*
* typedef ecma_property_t* (*default_value_ptr_t) (const ecma_object_ptr_t& , ecma_string_t *);
* typedef ecma_property_t* (*default_value_ptr_t) (ecma_object_t *, ecma_string_t *);
* static const default_value_ptr_t default_value [ECMA_OBJECT_TYPE__COUNT] =
* {
* [ECMA_OBJECT_TYPE_GENERAL] = &ecma_op_general_object_default_value,
@@ -385,7 +375,7 @@ ecma_op_object_default_value (ecma_completion_value_t &ret_value, /**< out: comp
* return default_value[type] (obj_p, property_name_p);
*/
ecma_op_general_object_default_value (ret_value, obj_p, hint);
return ecma_op_general_object_default_value (obj_p, hint);
} /* ecma_op_object_default_value */
/**
@@ -397,15 +387,14 @@ ecma_op_object_default_value (ecma_completion_value_t &ret_value, /**< out: comp
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_object_define_own_property (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& obj_p, /**< the object */
ecma_completion_value_t
ecma_op_object_define_own_property (ecma_object_t *obj_p, /**< the object */
ecma_string_t *property_name_p, /**< property name */
const ecma_property_descriptor_t* property_desc_p, /**< property
* descriptor */
bool is_throw) /**< flag that controls failure handling */
{
JERRY_ASSERT(obj_p.is_not_null ()
JERRY_ASSERT(obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
JERRY_ASSERT(property_name_p != NULL);
@@ -420,39 +409,33 @@ ecma_op_object_define_own_property (ecma_completion_value_t &ret_value, /**< out
case ECMA_OBJECT_TYPE_BUILT_IN_FUNCTION:
case ECMA_OBJECT_TYPE_STRING:
{
ecma_op_general_object_define_own_property (ret_value,
obj_p,
property_name_p,
property_desc_p,
is_throw);
return;
return ecma_op_general_object_define_own_property (obj_p,
property_name_p,
property_desc_p,
is_throw);
}
case ECMA_OBJECT_TYPE_ARRAY:
{
ecma_op_array_object_define_own_property (ret_value,
obj_p,
property_name_p,
property_desc_p,
is_throw);
return;
return ecma_op_array_object_define_own_property (obj_p,
property_name_p,
property_desc_p,
is_throw);
}
case ECMA_OBJECT_TYPE_ARGUMENTS:
{
ecma_op_arguments_object_define_own_property (ret_value,
obj_p,
property_name_p,
property_desc_p,
is_throw);
return;
return ecma_op_arguments_object_define_own_property (obj_p,
property_name_p,
property_desc_p,
is_throw);
}
default:
{
JERRY_ASSERT (false);
ecma_make_empty_completion_value (ret_value);
return ecma_make_empty_completion_value ();
}
}
} /* ecma_op_object_define_own_property */
@@ -463,12 +446,11 @@ ecma_op_object_define_own_property (ecma_completion_value_t &ret_value, /**< out
* See also:
* ECMA-262 v5, 8.6.2; ECMA-262 v5, Table 9
*/
void
ecma_op_object_has_instance (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_object_ptr_t& obj_p, /**< the object */
ecma_completion_value_t
ecma_op_object_has_instance (ecma_object_t *obj_p, /**< the object */
const ecma_value_t& value) /**< argument 'V' */
{
JERRY_ASSERT(obj_p.is_not_null ()
JERRY_ASSERT(obj_p != NULL
&& !ecma_is_lexical_environment (obj_p));
const ecma_object_type_t type = ecma_get_object_type (obj_p);
@@ -480,18 +462,14 @@ ecma_op_object_has_instance (ecma_completion_value_t &ret_value, /**< out: compl
case ECMA_OBJECT_TYPE_STRING:
case ECMA_OBJECT_TYPE_ARGUMENTS:
{
ecma_object_ptr_t exception_obj_p;
ecma_new_standard_error (exception_obj_p, ECMA_ERROR_TYPE);
ecma_make_throw_obj_completion_value (ret_value, exception_obj_p);
return;
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
case ECMA_OBJECT_TYPE_FUNCTION:
case ECMA_OBJECT_TYPE_BOUND_FUNCTION:
case ECMA_OBJECT_TYPE_BUILT_IN_FUNCTION:
{
ecma_op_function_has_instance (ret_value, obj_p, value);
return;
return ecma_op_function_has_instance (obj_p, value);
}
case ECMA_OBJECT_TYPE__COUNT:
src/libecmaoperations/ecma-objects.h
+16 -36
View File
@@ -18,7 +18,6 @@
#include "ecma-conversion.h"
#include "ecma-globals.h"
#include "ecma-value.h"
/** \addtogroup ecma ECMA
* @{
@@ -27,44 +26,25 @@
* @{
*/
extern void
ecma_op_object_get (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& obj_p,
ecma_string_t *property_name_p);
extern ecma_property_t*
ecma_op_object_get_own_property (const ecma_object_ptr_t& obj_p,
ecma_string_t *property_name_p);
extern ecma_property_t*
ecma_op_object_get_property (const ecma_object_ptr_t& obj_p,
ecma_string_t *property_name_p);
extern void
ecma_op_object_put (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& obj_p,
ecma_string_t *property_name_p,
const ecma_value_t& value,
bool is_throw);
extern bool
ecma_op_object_can_put (const ecma_object_ptr_t& obj_p,
ecma_string_t *property_name_p);
extern void
ecma_op_object_delete (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& obj_p,
ecma_string_t *property_name_p,
bool is_throw);
extern void
ecma_op_object_default_value (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& obj_p,
ecma_preferred_type_hint_t hint);
extern void
ecma_op_object_define_own_property (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& obj_p,
extern ecma_completion_value_t ecma_op_object_get (ecma_object_t *obj_p, ecma_string_t *property_name_p);
extern ecma_property_t *ecma_op_object_get_own_property (ecma_object_t *obj_p, ecma_string_t *property_name_p);
extern ecma_property_t *ecma_op_object_get_property (ecma_object_t *obj_p, ecma_string_t *property_name_p);
extern ecma_completion_value_t ecma_op_object_put (ecma_object_t *obj_p,
ecma_string_t *property_name_p,
const ecma_value_t& value,
bool is_throw);
extern bool ecma_op_object_can_put (ecma_object_t *obj_p, ecma_string_t *property_name_p);
extern ecma_completion_value_t ecma_op_object_delete (ecma_object_t *obj_p,
ecma_string_t *property_name_p,
bool is_throw);
extern ecma_completion_value_t ecma_op_object_default_value (ecma_object_t *obj_p, ecma_preferred_type_hint_t hint);
extern ecma_completion_value_t
ecma_op_object_define_own_property (ecma_object_t *obj_p,
ecma_string_t *property_name_p,
const ecma_property_descriptor_t* property_desc_p,
bool is_throw);
extern void
ecma_op_object_has_instance (ecma_completion_value_t &ret_value,
const ecma_object_ptr_t& obj_p,
const ecma_value_t& value);
extern ecma_completion_value_t ecma_op_object_has_instance (ecma_object_t *obj_p,
const ecma_value_t& value);
/**
* @}
* @}
src/libecmaoperations/ecma-reference.c
+29 -30
View File
@@ -36,24 +36,25 @@
* pointer to lexical environment - reference's base,
* else - NULL.
*/
void
ecma_op_resolve_reference_base (ecma_object_ptr_t &lex_env_iter_p, /**< out: object pointer */
const ecma_object_ptr_t &lex_env_p, /**< starting lexical environment */
ecma_object_t*
ecma_op_resolve_reference_base (ecma_object_t *lex_env_p, /**< starting lexical environment */
ecma_string_t *name_p) /**< identifier's name */
{
JERRY_ASSERT(lex_env_p.is_not_null ());
JERRY_ASSERT(lex_env_p != NULL);
lex_env_iter_p = lex_env_p;
ecma_object_t *lex_env_iter_p = lex_env_p;
while (lex_env_iter_p.is_not_null ())
while (lex_env_iter_p != NULL)
{
if (ecma_op_has_binding (lex_env_iter_p, name_p))
{
return;
return lex_env_iter_p;
}
ecma_get_lex_env_outer_reference (lex_env_iter_p, lex_env_iter_p);
lex_env_iter_p = ecma_get_lex_env_outer_reference (lex_env_iter_p);
}
return NULL;
} /* ecma_op_resolve_reference_base */
/**
@@ -62,30 +63,26 @@ ecma_op_resolve_reference_base (ecma_object_ptr_t &lex_env_iter_p, /**< out: obj
* @return ECMA-reference
* Returned value must be freed through ecma_free_reference.
*/
void
ecma_op_get_identifier_reference (ecma_reference_t &ret, /**< out: reference */
const ecma_object_ptr_t& lex_env_p, /**< lexical environment */
ecma_reference_t
ecma_op_get_identifier_reference (ecma_object_t *lex_env_p, /**< lexical environment */
ecma_string_t *name_p, /**< identifier's name */
bool is_strict) /**< strict reference flag */
{
JERRY_ASSERT(lex_env_p.is_not_null ());
JERRY_ASSERT(lex_env_p != NULL);
ecma_object_ptr_t base_lex_env_p;
ecma_op_resolve_reference_base (base_lex_env_p, lex_env_p, name_p);
ecma_object_t *base_lex_env_p = ecma_op_resolve_reference_base (lex_env_p, name_p);
if (base_lex_env_p.is_not_null ())
if (base_lex_env_p != NULL)
{
ecma_make_reference (ret,
ecma_value_t (base_lex_env_p),
name_p,
is_strict);
return ecma_make_reference (ecma_make_object_value (base_lex_env_p),
name_p,
is_strict);
}
else
{
ecma_make_reference (ret,
ecma_value_t (ECMA_SIMPLE_VALUE_UNDEFINED),
name_p,
is_strict);
return ecma_make_reference (ecma_make_simple_value (ECMA_SIMPLE_VALUE_UNDEFINED),
name_p,
is_strict);
}
} /* ecma_op_get_identifier_reference */
@@ -95,18 +92,20 @@ ecma_op_get_identifier_reference (ecma_reference_t &ret, /**< out: reference */
* @return ECMA-reference
* Returned value must be freed through ecma_free_reference.
*/
void
ecma_make_reference (ecma_reference_t &ret, /**< out: reference */
const ecma_value_t& base, /**< base value */
ecma_reference_t
ecma_make_reference (const ecma_value_t& base, /**< base value */
ecma_string_t *name_p, /**< referenced name */
bool is_strict) /**< strict reference flag */
{
name_p = ecma_copy_or_ref_ecma_string (name_p);
ecma_copy_value (ret.base, base, true);
ret.is_strict = is_strict;
ecma_reference_t ref;
ref.base = ecma_copy_value (base, true);
ref.is_strict = is_strict;
ECMA_SET_POINTER (ret.referenced_name_cp, name_p);
ECMA_SET_POINTER (ref.referenced_name_cp, name_p);
return ref;
} /* ecma_make_reference */
/**
@@ -116,7 +115,7 @@ ecma_make_reference (ecma_reference_t &ret, /**< out: reference */
* freeing invalidates all copies of the reference.
*/
void
ecma_free_reference (ecma_reference_t& ref) /**< reference */
ecma_free_reference (ecma_reference_t ref) /**< reference */
{
ecma_free_value (ref.base, true);
ecma_deref_ecma_string (ECMA_GET_NON_NULL_POINTER (ecma_string_t,
src/libecmaoperations/ecma-reference.h
+10 -19
View File
@@ -17,7 +17,6 @@
#define ECMA_REFERENCE_H
#include "ecma-globals.h"
#include "ecma-value.h"
#include "globals.h"
/** \addtogroup ecma ECMA
@@ -32,12 +31,8 @@
/**
* ECMA-reference (see also: ECMA-262 v5, 8.7).
*/
typedef struct ecma_reference_t
typedef struct
{
ecma_reference_t () : base (), referenced_name_cp (ECMA_NULL_POINTER), is_strict (false)
{
}
/** base value */
ecma_value_t base;
@@ -48,20 +43,16 @@ typedef struct ecma_reference_t
unsigned int is_strict : 1;
} ecma_reference_t;
extern void
ecma_op_resolve_reference_base (ecma_object_ptr_t &ret_val,
const ecma_object_ptr_t& lex_env_p,
ecma_string_t *name_p);
extern ecma_object_t* ecma_op_resolve_reference_base (ecma_object_t *lex_env_p,
ecma_string_t *name_p);
extern void ecma_op_get_identifier_reference (ecma_reference_t &ret,
const ecma_object_ptr_t& lex_env_p,
ecma_string_t *name_p,
bool is_strict);
extern void ecma_make_reference (ecma_reference_t &ret,
const ecma_value_t& base,
ecma_string_t *name_p,
bool is_strict);
extern void ecma_free_reference (ecma_reference_t& ref);
extern ecma_reference_t ecma_op_get_identifier_reference (ecma_object_t *lex_env_p,
ecma_string_t *name_p,
bool is_strict);
extern ecma_reference_t ecma_make_reference (const ecma_value_t& base,
ecma_string_t *name_p,
bool is_strict);
extern void ecma_free_reference (ecma_reference_t ref);
/**
* @}
src/libecmaoperations/ecma-string-object.c
+17 -24
View File
@@ -38,9 +38,8 @@
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
void
ecma_op_create_string_object (ecma_completion_value_t &ret_value, /**< out: completion value */
const ecma_value_t *arguments_list_p, /**< list of arguments that
ecma_completion_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 */
{
@@ -58,23 +57,18 @@ ecma_op_create_string_object (ecma_completion_value_t &ret_value, /**< out: comp
}
else
{
ecma_completion_value_t to_str_arg_completion;
ecma_op_to_string (to_str_arg_completion, arguments_list_p [0]);
ecma_completion_value_t to_str_arg_value = ecma_op_to_string (arguments_list_p [0]);
if (ecma_is_completion_value_throw (to_str_arg_completion))
if (ecma_is_completion_value_throw (to_str_arg_value))
{
ret_value = to_str_arg_completion;
return;
return to_str_arg_value;
}
else
{
JERRY_ASSERT (ecma_is_completion_value_normal (to_str_arg_completion));
JERRY_ASSERT (ecma_is_completion_value_normal (to_str_arg_value));
ecma_value_t to_str_arg_value;
ecma_get_completion_value_value (to_str_arg_value, to_str_arg_completion);
JERRY_ASSERT (ecma_is_value_string (to_str_arg_value));
prim_prop_str_value_p = ecma_get_string_from_value (to_str_arg_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);
@@ -84,15 +78,14 @@ ecma_op_create_string_object (ecma_completion_value_t &ret_value, /**< out: comp
}
#ifndef CONFIG_ECMA_COMPACT_PROFILE_DISABLE_STRING_BUILTIN
ecma_object_ptr_t prototype_obj_p;
ecma_builtin_get (prototype_obj_p, ECMA_BUILTIN_ID_STRING_PROTOTYPE);
ecma_object_t *prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_STRING_PROTOTYPE);
#else /* !CONFIG_ECMA_COMPACT_PROFILE_DISABLE_STRING_BUILTIN */
ecma_object_ptr_t prototype_obj_p;
ecma_builtin_get (prototype_obj_p, ECMA_BUILTIN_ID_OBJECT_PROTOTYPE);
ecma_object_t *prototype_obj_p = ecma_builtin_get (ECMA_BUILTIN_ID_OBJECT_PROTOTYPE);
#endif /* CONFIG_ECMA_COMPACT_PROFILE_DISABLE_STRING_BUILTIN */
ecma_object_ptr_t obj_p;
ecma_create_object (obj_p, prototype_obj_p, true, ECMA_OBJECT_TYPE_STRING);
ecma_object_t *obj_p = ecma_create_object (prototype_obj_p,
true,
ECMA_OBJECT_TYPE_STRING);
ecma_deref_object (prototype_obj_p);
ecma_property_t *class_prop_p = ecma_create_internal_property (obj_p, ECMA_INTERNAL_PROPERTY_CLASS);
@@ -109,10 +102,10 @@ ecma_op_create_string_object (ecma_completion_value_t &ret_value, /**< out: comp
false, false, false);
ecma_number_t *length_prop_value_p = ecma_alloc_number ();
*length_prop_value_p = length_value;
ecma_set_named_data_property_value (length_prop_p, ecma_value_t (length_prop_value_p));
ecma_set_named_data_property_value (length_prop_p, ecma_make_number_value (length_prop_value_p));
ecma_deref_ecma_string (length_magic_string_p);
ecma_make_normal_completion_value (ret_value, ecma_value_t (obj_p));
return ecma_make_normal_completion_value (ecma_make_object_value (obj_p));
} /* ecma_op_create_string_object */
/**
@@ -126,7 +119,7 @@ ecma_op_create_string_object (ecma_completion_value_t &ret_value, /**< out: comp
* Returned value must be freed with ecma_free_completion_value
*/
ecma_property_t*
ecma_op_string_object_get_own_property (const ecma_object_ptr_t& obj_p, /**< the array object */
ecma_op_string_object_get_own_property (ecma_object_t *obj_p, /**< the array object */
ecma_string_t *property_name_p) /**< property name */
{
JERRY_ASSERT (ecma_get_object_type (obj_p) == ECMA_OBJECT_TYPE_STRING);
@@ -202,7 +195,7 @@ ecma_op_string_object_get_own_property (const ecma_object_ptr_t& obj_p, /**< the
false, true, false);
ecma_set_named_data_property_value (new_prop_p,
ecma_value_t (new_prop_str_value_p));
ecma_make_string_value (new_prop_str_value_p));
}
ecma_deref_ecma_string (new_prop_name_p);
src/libecmaoperations/ecma-string-object.h
+3 -5
View File
@@ -17,7 +17,6 @@
#define ECMA_STRING_OBJECT_H
#include "ecma-globals.h"
#include "ecma-value.h"
/** \addtogroup ecma ECMA
* @{
@@ -26,13 +25,12 @@
* @{
*/
extern void
ecma_op_create_string_object (ecma_completion_value_t &ret_value,
const ecma_value_t *arguments_list_p,
extern ecma_completion_value_t
ecma_op_create_string_object (const ecma_value_t *arguments_list_p,
ecma_length_t arguments_list_len);
extern ecma_property_t*
ecma_op_string_object_get_own_property (const ecma_object_ptr_t& obj_p,
ecma_op_string_object_get_own_property (ecma_object_t *obj_p,
ecma_string_t *property_name_p);
/**
src/libecmaoperations/ecma-try-catch-macro.h
+7 -7
View File
@@ -29,9 +29,8 @@
* Each ECMA_TRY_CATCH should have it's own corresponding ECMA_FINALIZE
* statement with same argument as corresponding ECMA_TRY_CATCH's first argument.
*/
#define ECMA_TRY_CATCH(return_value, op, var, ...) \
ecma_completion_value_t var ## _completion; \
op (var ## _completion, __VA_ARGS__); \
#define ECMA_TRY_CATCH(var, op, return_value) \
ecma_completion_value_t var ## _completion = op; \
if (unlikely (ecma_is_completion_value_throw (var ## _completion))) \
{ \
return_value = var ## _completion; \
@@ -40,8 +39,7 @@
{ \
JERRY_ASSERT(ecma_is_completion_value_normal (var ## _completion)); \
\
ecma_value_t var; \
ecma_get_completion_value_value (var, var ## _completion)
ecma_value_t var __unused = ecma_get_completion_value_value (var ## _completion)
/**
* The macro marks end of code block that is defined by corresponding
@@ -66,7 +64,7 @@
* statement with same argument as corresponding ECMA_OP_TO_NUMBER_TRY_CATCH's first argument.
*/
#define ECMA_OP_TO_NUMBER_TRY_CATCH(num_var, value, return_value) \
ecma_make_empty_completion_value (return_value); \
JERRY_ASSERT (ecma_is_completion_value_empty (return_value)); \
ecma_number_t num_var = ecma_number_make_nan (); \
if (ecma_is_value_number (value)) \
{ \
@@ -74,7 +72,9 @@
} \
else \
{ \
ECMA_TRY_CATCH (return_value, ecma_op_to_number, to_number_value, value); \
ECMA_TRY_CATCH (to_number_value, \
ecma_op_to_number (value), \
return_value); \
\
num_var = *ecma_get_number_from_value (to_number_value); \
\