/**
* The Object object's 'isSealed' routine
*
* See also:
* ECMA-262 v5, 15.2.3.11
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value.
*/
static ecma_completion_value_t
ecma_builtin_object_object_is_sealed (ecma_value_t this_arg __attr_unused___, /**< 'this' argument */
ecma_value_t arg) /**< routine's argument */
{
ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
// 1.
if (!ecma_is_value_object (arg))
{
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
ecma_object_t *obj_p = ecma_get_object_from_value (arg);
bool is_sealed;
// 3.
if (ecma_get_object_extensible (obj_p))
{
is_sealed = false;
}
else
{
/* the value can be updated in the loop below */
is_sealed = true;
// 2.
ecma_collection_header_t *props_p = ecma_op_object_get_property_names (obj_p, false, false, false);
ecma_collection_iterator_t iter;
ecma_collection_iterator_init (&iter, props_p);
while (ecma_collection_iterator_next (&iter))
{
ecma_string_t *property_name_p = ecma_get_string_from_value (*iter.current_value_p);
// 2.a
ecma_property_t *property_p = ecma_op_object_get_own_property (obj_p, property_name_p);
// 2.b
if (ecma_is_property_configurable (property_p))
{
is_sealed = false;
break;
}
}
ecma_free_values_collection (props_p, true);
}
// 4.
ret_value = ecma_make_simple_completion_value (is_sealed
? ECMA_SIMPLE_VALUE_TRUE
: ECMA_SIMPLE_VALUE_FALSE);
}
return ret_value;
} /* ecma_builtin_object_object_is_sealed */
/**
* DeleteBinding operation.
*
* See also: ECMA-262 v5, 10.2.1
*
* @return ecma value
* Return value is simple and so need not be freed.
* However, ecma_free_value may be called for it, but it is a no-op.
*/
ecma_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 != NULL
&& ecma_is_lexical_environment (lex_env_p));
JERRY_ASSERT (name_p != NULL);
if (ecma_get_lex_env_type (lex_env_p) == ECMA_LEXICAL_ENVIRONMENT_DECLARATIVE)
{
ecma_property_t *prop_p = ecma_find_named_property (lex_env_p, name_p);
ecma_simple_value_t ret_val;
if (prop_p == NULL)
{
ret_val = ECMA_SIMPLE_VALUE_TRUE;
}
else
{
JERRY_ASSERT (prop_p->type == ECMA_PROPERTY_NAMEDDATA);
if (!ecma_is_property_configurable (prop_p))
{
ret_val = ECMA_SIMPLE_VALUE_FALSE;
}
else
{
ecma_delete_property (lex_env_p, prop_p);
ret_val = ECMA_SIMPLE_VALUE_TRUE;
}
}
return ecma_make_simple_value (ret_val);
}
else
{
JERRY_ASSERT (ecma_get_lex_env_type (lex_env_p) == ECMA_LEXICAL_ENVIRONMENT_OBJECTBOUND);
ecma_object_t *binding_obj_p = ecma_get_lex_env_binding_object (lex_env_p);
return ecma_op_object_delete (binding_obj_p, name_p, false);
}
} /* ecma_op_delete_binding */
/**
* [[Delete]] ecma general object's operation
*
* See also:
* ECMA-262 v5, 8.6.2; ECMA-262 v5, Table 8
* ECMA-262 v5, 8.12.7
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
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 != NULL
&& !ecma_is_lexical_environment (obj_p));
JERRY_ASSERT (property_name_p != NULL);
// 1.
ecma_property_t *desc_p = ecma_op_object_get_own_property (obj_p, property_name_p);
// 2.
if (desc_p == NULL)
{
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
// 3.
if (ecma_is_property_configurable (desc_p))
{
// a.
ecma_delete_property (obj_p, desc_p);
// b.
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
else if (is_throw)
{
// 4.
return ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
// 5.
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_FALSE);
}
JERRY_UNREACHABLE ();
} /* ecma_op_general_object_delete */
/**
* Construct property descriptor from specified property
*
* @return property descriptor, corresponding to type and content of the specified property, i.e.:
* - for named data properties: { [Value], [Writable], [Enumerable], [Configurable] };
* - for named accessor properties: { [Get] - if defined,
* [Set] - if defined,
* [Enumerable], [Configurable]
* }.
*/
ecma_property_descriptor_t
ecma_get_property_descriptor_from_property (ecma_property_t *prop_p) /**< property */
{
ecma_property_descriptor_t prop_desc = ecma_make_empty_property_descriptor ();
prop_desc.is_enumerable = ecma_is_property_enumerable (prop_p);
prop_desc.is_enumerable_defined = true;
prop_desc.is_configurable = ecma_is_property_configurable (prop_p);
prop_desc.is_configurable_defined = true;
if (ECMA_PROPERTY_GET_TYPE (prop_p) == ECMA_PROPERTY_TYPE_NAMEDDATA)
{
prop_desc.value = ecma_copy_value (ecma_get_named_data_property_value (prop_p));
prop_desc.is_value_defined = true;
prop_desc.is_writable = ecma_is_property_writable (prop_p);
prop_desc.is_writable_defined = true;
}
else
{
JERRY_ASSERT (ECMA_PROPERTY_GET_TYPE (prop_p) == ECMA_PROPERTY_TYPE_NAMEDACCESSOR);
prop_desc.get_p = ecma_get_named_accessor_property_getter (prop_p);
prop_desc.is_get_defined = true;
if (prop_desc.get_p != NULL)
{
ecma_ref_object (prop_desc.get_p);
}
prop_desc.set_p = ecma_get_named_accessor_property_setter (prop_p);
prop_desc.is_set_defined = true;
if (prop_desc.set_p != NULL)
{
ecma_ref_object (prop_desc.set_p);
}
}
return prop_desc;
} /* ecma_get_property_descriptor_from_property */
/**
* If the property's name is one of built-in properties of the object
* that is not instantiated yet, instantiate the property and
* return pointer to the instantiated property.
*
* @return pointer property, if one was instantiated,
* NULL - otherwise.
*/
ecma_property_t *
ecma_builtin_try_to_instantiate_property (ecma_object_t *object_p, /**< object */
ecma_string_t *string_p) /**< property's name */
{
JERRY_ASSERT (ecma_get_object_is_builtin (object_p));
const ecma_object_type_t type = ecma_get_object_type (object_p);
if (type == ECMA_OBJECT_TYPE_BUILT_IN_FUNCTION)
{
ecma_string_t *magic_string_length_p = ecma_get_magic_string (LIT_MAGIC_STRING_LENGTH);
bool is_length_property = ecma_compare_ecma_strings (string_p, magic_string_length_p);
ecma_deref_ecma_string (magic_string_length_p);
if (is_length_property)
{
/*
* Lazy instantiation of 'length' property
*
* Note:
* We don't need to mark that the property was already lazy instantiated,
* as it is non-configurable and so can't be deleted
*/
ecma_property_t *desc_prop_p = ecma_get_internal_property (object_p,
ECMA_INTERNAL_PROPERTY_BUILT_IN_ROUTINE_DESC);
uint64_t builtin_routine_desc = desc_prop_p->u.internal_property.value;
JERRY_STATIC_ASSERT (sizeof (uint8_t) * JERRY_BITSINBYTE == ECMA_BUILTIN_ROUTINE_ID_LENGTH_VALUE_WIDTH,
bits_in_uint8_t_must_be_equal_to_ECMA_BUILTIN_ROUTINE_ID_LENGTH_VALUE_WIDTH);
uint8_t length_prop_value = (uint8_t) jrt_extract_bit_field (builtin_routine_desc,
ECMA_BUILTIN_ROUTINE_ID_LENGTH_VALUE_POS,
ECMA_BUILTIN_ROUTINE_ID_LENGTH_VALUE_WIDTH);
ecma_property_t *len_prop_p = ecma_create_named_data_property (object_p,
string_p,
false, false, false);
ecma_number_t *len_p = ecma_alloc_number ();
*len_p = length_prop_value;
ecma_set_named_data_property_value (len_prop_p, ecma_make_number_value (len_p));
JERRY_ASSERT (!ecma_is_property_configurable (len_prop_p));
return len_prop_p;
}
return NULL;
}
else
{
ecma_property_t *built_in_id_prop_p = ecma_get_internal_property (object_p,
ECMA_INTERNAL_PROPERTY_BUILT_IN_ID);
ecma_builtin_id_t builtin_id = (ecma_builtin_id_t) built_in_id_prop_p->u.internal_property.value;
JERRY_ASSERT (ecma_builtin_is (object_p, builtin_id));
switch (builtin_id)
{
#define BUILTIN(builtin_id, \
object_type, \
object_prototype_builtin_id, \
is_extensible, \
is_static, \
lowercase_name) \
case builtin_id: \
{ \
return ecma_builtin_ ## lowercase_name ## _try_to_instantiate_property (object_p, \
string_p); \
}
#include "ecma-builtins.inc.h"
case ECMA_BUILTIN_ID__COUNT:
{
JERRY_UNREACHABLE ();
}
default:
{
#ifdef CONFIG_ECMA_COMPACT_PROFILE
JERRY_UNREACHABLE ();
#else /* CONFIG_ECMA_COMPACT_PROFILE */
JERRY_UNIMPLEMENTED ("The built-in is not implemented.");
#endif /* !CONFIG_ECMA_COMPACT_PROFILE */
}
}
JERRY_UNREACHABLE ();
}
} /* ecma_builtin_try_to_instantiate_property */
/**
* [[DefineOwnProperty]] ecma general object's operation
*
* See also:
* ECMA-262 v5, 8.6.2; ECMA-262 v5, Table 8
* ECMA-262 v5, 8.12.9
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value
*/
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 != NULL
&& !ecma_is_lexical_environment (obj_p));
JERRY_ASSERT (property_name_p != NULL);
const bool is_property_desc_generic_descriptor = (!property_desc_p->is_value_defined
&& !property_desc_p->is_writable_defined
&& !property_desc_p->is_get_defined
&& !property_desc_p->is_set_defined);
const bool is_property_desc_data_descriptor = (property_desc_p->is_value_defined
|| property_desc_p->is_writable_defined);
const bool is_property_desc_accessor_descriptor = (property_desc_p->is_get_defined
|| property_desc_p->is_set_defined);
// 1.
ecma_property_t *current_p = ecma_op_object_get_own_property (obj_p, property_name_p);
// 2.
bool extensible = ecma_get_object_extensible (obj_p);
if (current_p == NULL)
{
// 3.
if (!extensible)
{
return ecma_reject (is_throw);
}
// 4.
// a.
if (is_property_desc_generic_descriptor
|| is_property_desc_data_descriptor)
{
ecma_property_t *new_prop_p = ecma_create_named_data_property (obj_p,
property_name_p,
property_desc_p->is_writable,
property_desc_p->is_enumerable,
property_desc_p->is_configurable);
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_create_named_accessor_property (obj_p,
property_name_p,
property_desc_p->get_p,
property_desc_p->set_p,
property_desc_p->is_enumerable,
property_desc_p->is_configurable);
}
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
// 5.
if (is_property_desc_generic_descriptor
&& !property_desc_p->is_enumerable_defined
&& !property_desc_p->is_configurable_defined)
{
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
// 6.
const bool is_current_data_descriptor = (current_p->type == ECMA_PROPERTY_NAMEDDATA);
const bool is_current_accessor_descriptor = (current_p->type == ECMA_PROPERTY_NAMEDACCESSOR);
JERRY_ASSERT (is_current_data_descriptor || is_current_accessor_descriptor);
bool is_every_field_in_desc_also_occurs_in_current_desc_with_same_value = true;
if (property_desc_p->is_value_defined)
{
if (!is_current_data_descriptor
|| !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;
}
}
if (property_desc_p->is_writable_defined)
{
if (!is_current_data_descriptor
|| property_desc_p->is_writable != ecma_is_property_writable (current_p))
{
is_every_field_in_desc_also_occurs_in_current_desc_with_same_value = false;
}
}
if (property_desc_p->is_get_defined)
{
if (!is_current_accessor_descriptor
|| property_desc_p->get_p != ecma_get_named_accessor_property_getter (current_p))
{
is_every_field_in_desc_also_occurs_in_current_desc_with_same_value = false;
}
}
if (property_desc_p->is_set_defined)
{
if (!is_current_accessor_descriptor
|| property_desc_p->set_p != ecma_get_named_accessor_property_setter (current_p))
{
is_every_field_in_desc_also_occurs_in_current_desc_with_same_value = false;
}
}
if (property_desc_p->is_enumerable_defined)
{
if (property_desc_p->is_enumerable != ecma_is_property_enumerable (current_p))
{
is_every_field_in_desc_also_occurs_in_current_desc_with_same_value = false;
}
}
if (property_desc_p->is_configurable_defined)
{
if (property_desc_p->is_configurable != ecma_is_property_configurable (current_p))
{
is_every_field_in_desc_also_occurs_in_current_desc_with_same_value = false;
}
}
if (is_every_field_in_desc_also_occurs_in_current_desc_with_same_value)
{
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
}
// 7.
if (!ecma_is_property_configurable (current_p))
{
if (property_desc_p->is_configurable
|| (property_desc_p->is_enumerable_defined
&& property_desc_p->is_enumerable != ecma_is_property_enumerable (current_p)))
{
// a., b.
return ecma_reject (is_throw);
}
}
// 8.
if (is_property_desc_generic_descriptor)
{
// no action required
}
else if (is_property_desc_data_descriptor != is_current_data_descriptor)
{
// 9.
if (!ecma_is_property_configurable (current_p))
{
// a.
return ecma_reject (is_throw);
}
bool was_enumerable = ecma_is_property_enumerable (current_p);
bool was_configurable = ecma_is_property_configurable (current_p);
ecma_delete_property (obj_p, current_p);
if (is_current_data_descriptor)
{
// b.
current_p = ecma_create_named_accessor_property (obj_p,
property_name_p,
NULL,
NULL,
was_enumerable,
was_configurable);
}
else
{
// c.
current_p = ecma_create_named_data_property (obj_p,
property_name_p,
false,
was_enumerable,
was_configurable);
}
}
else if (is_property_desc_data_descriptor && is_current_data_descriptor)
{
// 10.
if (!ecma_is_property_configurable (current_p))
{
// a.
if (!ecma_is_property_writable (current_p))
{
// i.
if (property_desc_p->is_writable)
{
return ecma_reject (is_throw);
}
// ii.
if (property_desc_p->is_value_defined
&& !ecma_op_same_value (property_desc_p->value,
ecma_get_named_data_property_value (current_p)))
{
return ecma_reject (is_throw);
}
}
}
}
else
{
JERRY_ASSERT (is_property_desc_accessor_descriptor && is_current_accessor_descriptor);
// 11.
if (!ecma_is_property_configurable (current_p))
{
// a.
if ((property_desc_p->is_get_defined
&& property_desc_p->get_p != ecma_get_named_accessor_property_getter (current_p))
|| (property_desc_p->is_set_defined
&& property_desc_p->set_p != ecma_get_named_accessor_property_setter (current_p)))
{
// i., ii.
return ecma_reject (is_throw);
}
}
}
// 12.
if (property_desc_p->is_value_defined)
{
JERRY_ASSERT (current_p->type == ECMA_PROPERTY_NAMEDDATA);
ecma_named_data_property_assign_value (obj_p, current_p, property_desc_p->value);
}
if (property_desc_p->is_writable_defined)
{
JERRY_ASSERT (current_p->type == ECMA_PROPERTY_NAMEDDATA);
ecma_set_property_writable_attr (current_p, property_desc_p->is_writable);
}
if (property_desc_p->is_get_defined)
{
JERRY_ASSERT (current_p->type == ECMA_PROPERTY_NAMEDACCESSOR);
ecma_set_named_accessor_property_getter (obj_p, current_p, property_desc_p->get_p);
}
if (property_desc_p->is_set_defined)
{
JERRY_ASSERT (current_p->type == ECMA_PROPERTY_NAMEDACCESSOR);
ecma_set_named_accessor_property_setter (obj_p, current_p, property_desc_p->set_p);
}
if (property_desc_p->is_enumerable_defined)
{
ecma_set_property_enumerable_attr (current_p, property_desc_p->is_enumerable);
}
if (property_desc_p->is_configurable_defined)
{
ecma_set_property_configurable_attr (current_p, property_desc_p->is_configurable);
}
return ecma_make_simple_completion_value (ECMA_SIMPLE_VALUE_TRUE);
} /* ecma_op_general_object_define_own_property */
/**
* The Object object's 'isFrozen' routine
*
* See also:
* ECMA-262 v5, 15.2.3.12
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value.
*/
static ecma_completion_value_t
ecma_builtin_object_object_is_frozen (ecma_value_t this_arg __attr_unused___, /**< 'this' argument */
ecma_value_t arg) /**< routine's argument */
{
ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
// 1.
if (!ecma_is_value_object (arg))
{
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
ecma_object_t *obj_p = ecma_get_object_from_value (arg);
bool is_frozen;
// 3.
if (ecma_get_object_extensible (obj_p))
{
is_frozen = false;
}
else
{
is_frozen = true;
// 2.
ecma_collection_header_t *props_p = ecma_op_object_get_property_names (obj_p, false, false, false);
ecma_collection_iterator_t iter;
ecma_collection_iterator_init (&iter, props_p);
while (ecma_collection_iterator_next (&iter))
{
ecma_string_t *property_name_p = ecma_get_string_from_value (*iter.current_value_p);
// 2.a
ecma_property_t *property_p = ecma_op_object_get_own_property (obj_p, property_name_p);
JERRY_ASSERT (property_p->type == ECMA_PROPERTY_NAMEDDATA || property_p->type == ECMA_PROPERTY_NAMEDACCESSOR);
// 2.b
if (property_p->type == ECMA_PROPERTY_NAMEDDATA && ecma_is_property_writable (property_p))
{
is_frozen = false;
break;
}
// 2.c
if (ecma_is_property_configurable (property_p))
{
is_frozen = false;
break;
}
}
ecma_free_values_collection (props_p, true);
}
// 4.
ret_value = ecma_make_simple_completion_value (is_frozen
? ECMA_SIMPLE_VALUE_TRUE
: ECMA_SIMPLE_VALUE_FALSE);
}
return ret_value;
} /* ecma_builtin_object_object_is_frozen */
/**
* The Object object's 'freeze' routine
*
* See also:
* ECMA-262 v5, 15.2.3.9
*
* @return completion value
* Returned value must be freed with ecma_free_completion_value.
*/
static ecma_completion_value_t
ecma_builtin_object_object_freeze (ecma_value_t this_arg __attr_unused___, /**< 'this' argument */
ecma_value_t arg) /**< routine's argument */
{
ecma_completion_value_t ret_value = ecma_make_empty_completion_value ();
// 1.
if (!ecma_is_value_object (arg))
{
ret_value = ecma_make_throw_obj_completion_value (ecma_new_standard_error (ECMA_ERROR_TYPE));
}
else
{
// 2.
ecma_object_t *obj_p = ecma_get_object_from_value (arg);
ecma_collection_header_t *props_p = ecma_op_object_get_property_names (obj_p, false, false, false);
ecma_collection_iterator_t iter;
ecma_collection_iterator_init (&iter, props_p);
while (ecma_collection_iterator_next (&iter)
&& ecma_is_completion_value_empty (ret_value))
{
ecma_string_t *property_name_p = ecma_get_string_from_value (*iter.current_value_p);
ecma_property_t *property_p = ecma_op_object_get_own_property (obj_p, property_name_p);
// 2.a
ecma_property_descriptor_t prop_desc = ecma_get_property_descriptor_from_property (property_p);
// 2.b
if (property_p->type == ECMA_PROPERTY_NAMEDDATA && ecma_is_property_writable (property_p))
{
prop_desc.is_writable = false;
}
// 2.c
if (ecma_is_property_configurable (property_p))
{
prop_desc.is_configurable = false;
}
// 2.d
ECMA_TRY_CATCH (define_own_prop_ret,
ecma_op_object_define_own_property (obj_p,
property_name_p,
&prop_desc,
true),
ret_value);
ECMA_FINALIZE (define_own_prop_ret);
ecma_free_property_descriptor (&prop_desc);
}
ecma_free_values_collection (props_p, true);
if (ecma_is_completion_value_empty (ret_value))
{
// 3.
ecma_set_object_extensible (obj_p, false);
// 4.
ret_value = ecma_make_normal_completion_value (ecma_copy_value (arg, true));
}
}
return ret_value;
} /* ecma_builtin_object_object_freeze */
/**
* If the property's name is one of built-in properties of the object
* that is not instantiated yet, instantiate the property and
* return pointer to the instantiated property.
*
* @return pointer property, if one was instantiated,
* NULL - otherwise.
*/
ecma_property_t *
ecma_builtin_try_to_instantiate_property (ecma_object_t *object_p, /**< object */
ecma_string_t *string_p) /**< property's name */
{
JERRY_ASSERT (ecma_get_object_is_builtin (object_p));
ecma_extended_object_t *ext_obj_p = (ecma_extended_object_t *) object_p;
if (ecma_get_object_type (object_p) == ECMA_OBJECT_TYPE_FUNCTION
&& ecma_builtin_function_is_routine (object_p))
{
if (ecma_string_is_length (string_p))
{
/*
* Lazy instantiation of 'length' property
*
* Note:
* We don't need to mark that the property was already lazy instantiated,
* as it is non-configurable and so can't be deleted
*/
ecma_property_t *len_prop_p = ecma_create_named_data_property (object_p,
string_p,
ECMA_PROPERTY_FIXED);
ecma_set_named_data_property_value (len_prop_p,
ecma_make_integer_value (ext_obj_p->u.built_in.length));
JERRY_ASSERT (!ecma_is_property_configurable (len_prop_p));
return len_prop_p;
}
return NULL;
}
lit_magic_string_id_t magic_string_id;
if (!ecma_is_string_magic (string_p, &magic_string_id))
{
return NULL;
}
ecma_builtin_id_t builtin_id = (ecma_builtin_id_t) ext_obj_p->u.built_in.id;
JERRY_ASSERT (builtin_id < ECMA_BUILTIN_ID__COUNT);
JERRY_ASSERT (ecma_builtin_is (object_p, builtin_id));
const ecma_builtin_property_descriptor_t *property_list_p = ecma_builtin_property_list_references[builtin_id];
const ecma_builtin_property_descriptor_t *curr_property_p = property_list_p;
while (curr_property_p->magic_string_id != magic_string_id)
{
if (curr_property_p->magic_string_id == LIT_MAGIC_STRING__COUNT)
{
return NULL;
}
curr_property_p++;
}
uint32_t index = (uint32_t) (curr_property_p - property_list_p);
JERRY_ASSERT (index < 64);
if (likely (index < 32))
{
uint32_t bit_for_index = (uint32_t) 1u << index;
if (ext_obj_p->u.built_in.instantiated_bitset & bit_for_index)
{
/* This property was instantiated before. */
return NULL;
}
ext_obj_p->u.built_in.instantiated_bitset |= bit_for_index;
}
else
{
uint32_t bit_for_index = (uint32_t) 1u << (index - 32);
ecma_value_t *mask_prop_p = ecma_find_internal_property (object_p,
ECMA_INTERNAL_PROPERTY_INSTANTIATED_MASK_32_63);
uint32_t instantiated_bitset;
if (mask_prop_p == NULL)
{
mask_prop_p = ecma_create_internal_property (object_p, ECMA_INTERNAL_PROPERTY_INSTANTIATED_MASK_32_63);
instantiated_bitset = 0;
}
else
{
instantiated_bitset = *mask_prop_p;
if (instantiated_bitset & bit_for_index)
{
/* This property was instantiated before. */
return NULL;
}
}
*mask_prop_p = (instantiated_bitset | bit_for_index);
}
ecma_value_t value = ecma_make_simple_value (ECMA_SIMPLE_VALUE_EMPTY);
switch (curr_property_p->type)
{
case ECMA_BUILTIN_PROPERTY_SIMPLE:
{
value = ecma_make_simple_value (curr_property_p->value);
break;
}
case ECMA_BUILTIN_PROPERTY_NUMBER:
{
ecma_number_t num = 0.0;
if (curr_property_p->value < ECMA_BUILTIN_NUMBER_MAX)
{
num = curr_property_p->value;
}
else if (curr_property_p->value < ECMA_BUILTIN_NUMBER_NAN)
{
static const ecma_number_t builtin_number_list[] =
{
ECMA_NUMBER_MAX_VALUE,
ECMA_NUMBER_MIN_VALUE,
ECMA_NUMBER_E,
ECMA_NUMBER_PI,
ECMA_NUMBER_LN10,
ECMA_NUMBER_LN2,
ECMA_NUMBER_LOG2E,
ECMA_NUMBER_LOG10E,
ECMA_NUMBER_SQRT2,
ECMA_NUMBER_SQRT_1_2
};
num = builtin_number_list[curr_property_p->value - ECMA_BUILTIN_NUMBER_MAX];
}
else
{
switch (curr_property_p->value)
{
case ECMA_BUILTIN_NUMBER_NAN:
{
num = ecma_number_make_nan ();
break;
}
case ECMA_BUILTIN_NUMBER_POSITIVE_INFINITY:
{
num = ecma_number_make_infinity (false);
break;
}
case ECMA_BUILTIN_NUMBER_NEGATIVE_INFINITY:
{
num = ecma_number_make_infinity (true);
break;
}
default:
{
JERRY_UNREACHABLE ();
break;
}
}
}
value = ecma_make_number_value (num);
break;
}
case ECMA_BUILTIN_PROPERTY_STRING:
{
value = ecma_make_string_value (ecma_get_magic_string (curr_property_p->value));
break;
}
case ECMA_BUILTIN_PROPERTY_OBJECT:
{
value = ecma_make_object_value (ecma_builtin_get (curr_property_p->value));
break;
}
case ECMA_BUILTIN_PROPERTY_ROUTINE:
{
ecma_object_t *func_obj_p;
func_obj_p = ecma_builtin_make_function_object_for_routine (builtin_id,
ECMA_GET_ROUTINE_ID (curr_property_p->value),
ECMA_GET_ROUTINE_LENGTH (curr_property_p->value));
value = ecma_make_object_value (func_obj_p);
break;
}
default:
{
JERRY_UNREACHABLE ();
return NULL;
}
}
ecma_property_t *prop_p = ecma_create_named_data_property (object_p,
string_p,
curr_property_p->attributes);
ecma_set_named_data_property_value (prop_p, value);
/* Reference count of objects must be decreased. */
if (ecma_is_value_object (value))
{
ecma_free_value (value);
}
return prop_p;
} /* ecma_builtin_try_to_instantiate_property */
/**
* Low level delete of array items from new_length to old_length
*
* Note: new_length must be less than old_length
*
* @return the updated value of new_length
*/
uint32_t
ecma_delete_array_properties (ecma_object_t *object_p, /**< object */
uint32_t new_length, /**< new length */
uint32_t old_length) /**< old length */
{
JERRY_ASSERT (new_length < old_length);
/* First the minimum value of new_length is updated. */
ecma_property_header_t *current_prop_p = ecma_get_property_list (object_p);
if (current_prop_p == NULL)
{
return new_length;
}
if (current_prop_p->types[0] == ECMA_PROPERTY_TYPE_HASHMAP)
{
current_prop_p = ECMA_GET_POINTER (ecma_property_header_t,
current_prop_p->next_property_cp);
}
while (current_prop_p != NULL)
{
JERRY_ASSERT (ECMA_PROPERTY_IS_PROPERTY_PAIR (current_prop_p));
ecma_property_pair_t *prop_pair_p = (ecma_property_pair_t *) current_prop_p;
for (int i = 0; i < ECMA_PROPERTY_PAIR_ITEM_COUNT; i++)
{
if (ECMA_PROPERTY_IS_NAMED_PROPERTY (current_prop_p->types[i])
&& !ecma_is_property_configurable (current_prop_p->types[i]))
{
uint32_t index = ecma_string_get_property_index (current_prop_p->types[i],
prop_pair_p->names_cp[i]);
if (index < old_length && index >= new_length)
{
JERRY_ASSERT (index != ECMA_STRING_NOT_ARRAY_INDEX);
new_length = index + 1;
if (new_length == old_length)
{
/* Early return. */
return new_length;
}
}
}
}
current_prop_p = ECMA_GET_POINTER (ecma_property_header_t,
current_prop_p->next_property_cp);
}
/* Second all properties between new_length and old_length are deleted. */
current_prop_p = ecma_get_property_list (object_p);
ecma_property_header_t *prev_prop_p = NULL;
ecma_property_hashmap_delete_status hashmap_status = ECMA_PROPERTY_HASHMAP_DELETE_NO_HASHMAP;
if (current_prop_p->types[0] == ECMA_PROPERTY_TYPE_HASHMAP)
{
prev_prop_p = current_prop_p;
current_prop_p = ECMA_GET_POINTER (ecma_property_header_t,
current_prop_p->next_property_cp);
hashmap_status = ECMA_PROPERTY_HASHMAP_DELETE_HAS_HASHMAP;
}
while (current_prop_p != NULL)
{
ecma_property_pair_t *prop_pair_p = (ecma_property_pair_t *) current_prop_p;
for (int i = 0; i < ECMA_PROPERTY_PAIR_ITEM_COUNT; i++)
{
if (ECMA_PROPERTY_IS_NAMED_PROPERTY (current_prop_p->types[i])
&& ecma_is_property_configurable (current_prop_p->types[i]))
{
uint32_t index = ecma_string_get_property_index (current_prop_p->types[i],
prop_pair_p->names_cp[i]);
if (index < old_length && index >= new_length)
{
JERRY_ASSERT (index != ECMA_STRING_NOT_ARRAY_INDEX);
if (hashmap_status == ECMA_PROPERTY_HASHMAP_DELETE_HAS_HASHMAP)
{
hashmap_status = ecma_property_hashmap_delete (object_p,
prop_pair_p->names_cp[i],
current_prop_p->types + i);
}
ecma_free_property (object_p, prop_pair_p->names_cp[i], current_prop_p->types + i);
JERRY_ASSERT (current_prop_p->types[i] == ECMA_PROPERTY_TYPE_DELETED);
}
}
}
if (current_prop_p->types[0] == ECMA_PROPERTY_TYPE_DELETED
&& current_prop_p->types[1] == ECMA_PROPERTY_TYPE_DELETED)
{
if (prev_prop_p == NULL)
{
object_p->property_list_or_bound_object_cp = current_prop_p->next_property_cp;
}
else
{
prev_prop_p->next_property_cp = current_prop_p->next_property_cp;
}
ecma_property_header_t *next_prop_p = ECMA_GET_POINTER (ecma_property_header_t,
current_prop_p->next_property_cp);
ecma_dealloc_property_pair ((ecma_property_pair_t *) current_prop_p);
current_prop_p = next_prop_p;
}
else
{
prev_prop_p = current_prop_p;
current_prop_p = ECMA_GET_POINTER (ecma_property_header_t,
current_prop_p->next_property_cp);
}
}
if (hashmap_status == ECMA_PROPERTY_HASHMAP_DELETE_RECREATE_HASHMAP)
{
ecma_property_hashmap_free (object_p);
ecma_property_hashmap_create (object_p);
}
return new_length;
} /* ecma_delete_array_properties */
/**
* [[DefineOwnProperty]] ecma general object's operation
*
* See also:
* ECMA-262 v5, 8.6.2; ECMA-262 v5, Table 8
* ECMA-262 v5, 8.12.9
*
* @return ecma value
* Returned value must be freed with ecma_free_value
*/
ecma_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 != NULL
&& !ecma_is_lexical_environment (obj_p));
JERRY_ASSERT (property_name_p != NULL);
ecma_property_types_t property_desc_type = ECMA_PROPERTY_TYPE_GENERIC;
if (property_desc_p->is_value_defined
|| property_desc_p->is_writable_defined)
{
/* A property descriptor cannot be both named data and named accessor. */
JERRY_ASSERT (!property_desc_p->is_get_defined
&& !property_desc_p->is_set_defined);
property_desc_type = ECMA_PROPERTY_TYPE_NAMEDDATA;
}
else if (property_desc_p->is_get_defined
|| property_desc_p->is_set_defined)
{
property_desc_type = ECMA_PROPERTY_TYPE_NAMEDACCESSOR;
}
/* These three asserts ensures that a new property is created with the appropriate default flags.
* E.g. if is_configurable_defined is false, the newly created property must be non-configurable. */
JERRY_ASSERT (property_desc_p->is_configurable_defined || !property_desc_p->is_configurable);
JERRY_ASSERT (property_desc_p->is_enumerable_defined || !property_desc_p->is_enumerable);
JERRY_ASSERT (property_desc_p->is_writable_defined || !property_desc_p->is_writable);
// 1.
ecma_property_t *current_p = ecma_op_object_get_own_property (obj_p, property_name_p);
if (current_p == NULL)
{
// 3.
if (!ecma_get_object_extensible (obj_p))
{
// 2.
return ecma_reject (is_throw);
}
// 4.
if (property_desc_type != ECMA_PROPERTY_TYPE_NAMEDACCESSOR)
{
// a.
JERRY_ASSERT (property_desc_type == ECMA_PROPERTY_TYPE_GENERIC
|| property_desc_type == ECMA_PROPERTY_TYPE_NAMEDDATA);
ecma_property_t *new_prop_p = ecma_create_named_data_property (obj_p,
property_name_p,
property_desc_p->is_writable,
property_desc_p->is_enumerable,
property_desc_p->is_configurable);
JERRY_ASSERT (property_desc_p->is_value_defined
|| ecma_is_value_undefined (property_desc_p->value));
ecma_named_data_property_assign_value (obj_p, new_prop_p, property_desc_p->value);
}
else
{
// b.
ecma_create_named_accessor_property (obj_p,
property_name_p,
property_desc_p->get_p,
property_desc_p->set_p,
property_desc_p->is_enumerable,
property_desc_p->is_configurable);
}
return ecma_make_simple_value (ECMA_SIMPLE_VALUE_TRUE);
}
// 6.
ecma_property_types_t current_property_type = ECMA_PROPERTY_GET_TYPE (current_p);
const bool is_current_configurable = ecma_is_property_configurable (current_p);
JERRY_ASSERT (current_property_type == ECMA_PROPERTY_TYPE_NAMEDDATA
|| current_property_type == ECMA_PROPERTY_TYPE_NAMEDACCESSOR);
// 7. a., b.
if (!is_current_configurable
&& (property_desc_p->is_configurable
|| (property_desc_p->is_enumerable_defined
&& (property_desc_p->is_enumerable != ecma_is_property_enumerable (current_p)))))
{
return ecma_reject (is_throw);
}
// 8.
if (property_desc_type == ECMA_PROPERTY_TYPE_GENERIC)
{
/* No action required. */
}
else if (likely (property_desc_type == current_property_type))
{
/* If property is configurable, there is no need for checks. */
if (unlikely (!is_current_configurable))
{
if (property_desc_type == ECMA_PROPERTY_TYPE_NAMEDDATA)
{
// 10. a. i. & ii.
if (!ecma_is_property_writable (current_p)
&& (property_desc_p->is_writable
|| (property_desc_p->is_value_defined
&& !ecma_op_same_value (property_desc_p->value,
ecma_get_named_data_property_value (current_p)))))
{
return ecma_reject (is_throw);
}
}
else
{
// 11.
// a.
if ((property_desc_p->is_get_defined
&& property_desc_p->get_p != ecma_get_named_accessor_property_getter (current_p))
|| (property_desc_p->is_set_defined
&& property_desc_p->set_p != ecma_get_named_accessor_property_setter (current_p)))
{
// i., ii.
return ecma_reject (is_throw);
}
}
}
}
else
{
// 9.
if (!is_current_configurable)
{
// a.
return ecma_reject (is_throw);
}
/* The following implementation can be optimized by directly overwriting
* the fields of current_p if this code path is performance critical. */
bool was_enumerable = ecma_is_property_enumerable (current_p);
ecma_delete_property (obj_p, current_p);
if (property_desc_type == ECMA_PROPERTY_TYPE_NAMEDACCESSOR)
{
// b.
current_p = ecma_create_named_accessor_property (obj_p,
property_name_p,
NULL,
NULL,
was_enumerable,
true);
}
else
{
// c.
current_p = ecma_create_named_data_property (obj_p,
property_name_p,
false,
was_enumerable,
true);
}
}
// 12.
if (property_desc_type == ECMA_PROPERTY_TYPE_NAMEDDATA)
{
JERRY_ASSERT (ECMA_PROPERTY_GET_TYPE (current_p) == ECMA_PROPERTY_TYPE_NAMEDDATA);
if (property_desc_p->is_value_defined)
{
ecma_named_data_property_assign_value (obj_p, current_p, property_desc_p->value);
}
if (property_desc_p->is_writable_defined)
{
ecma_set_property_writable_attr (current_p, property_desc_p->is_writable);
}
}
else if (property_desc_type == ECMA_PROPERTY_TYPE_NAMEDACCESSOR)
{
JERRY_ASSERT (ECMA_PROPERTY_GET_TYPE (current_p) == ECMA_PROPERTY_TYPE_NAMEDACCESSOR);
if (property_desc_p->is_get_defined)
{
ecma_set_named_accessor_property_getter (obj_p, current_p, property_desc_p->get_p);
}
if (property_desc_p->is_set_defined)
{
ecma_set_named_accessor_property_setter (obj_p, current_p, property_desc_p->set_p);
}
}
if (property_desc_p->is_enumerable_defined)
{
ecma_set_property_enumerable_attr (current_p, property_desc_p->is_enumerable);
}
if (property_desc_p->is_configurable_defined)
{
ecma_set_property_configurable_attr (current_p, property_desc_p->is_configurable);
}
return ecma_make_simple_value (ECMA_SIMPLE_VALUE_TRUE);
} /* ecma_op_general_object_define_own_property */
