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

Renaming ecma_* identifiers from 'camelCase' to 'underscore_naming'.

Browse Source
This commit is contained in:
Ruben Ayrapetyan
2014-07-23 12:54:56 +04:00
parent b3b4c74cbe
commit bc0c7824c2
26 changed files with 702 additions and 702 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/libecmaobjects/ecma-alloc.c
+15 -15
View File
@@ -38,13 +38,13 @@
#include "ecma-gc.h"
#include "mem-poolman.h"
JERRY_STATIC_ASSERT( sizeof (ecma_Value_t) <= sizeof (uint16_t) );
JERRY_STATIC_ASSERT( sizeof (ecma_Property_t) <= sizeof (uint64_t) );
JERRY_STATIC_ASSERT( sizeof (ecma_Object_t) <= sizeof (uint64_t) );
JERRY_STATIC_ASSERT( sizeof (ecma_ArrayHeader_t) <= sizeof (uint32_t) );
JERRY_STATIC_ASSERT( sizeof (ecma_ArrayFirstChunk_t) == ECMA_ARRAY_CHUNK_SIZE_IN_BYTES );
JERRY_STATIC_ASSERT( sizeof (ecma_ArrayNonFirstChunk_t) == ECMA_ARRAY_CHUNK_SIZE_IN_BYTES );
JERRY_STATIC_ASSERT( sizeof (ecma_CompletionValue_t) == sizeof(uint32_t) );
JERRY_STATIC_ASSERT( sizeof (ecma_value_t) <= sizeof (uint16_t) );
JERRY_STATIC_ASSERT( sizeof (ecma_property_t) <= sizeof (uint64_t) );
JERRY_STATIC_ASSERT( sizeof (ecma_object_t) <= sizeof (uint64_t) );
JERRY_STATIC_ASSERT( sizeof (ecma_array_header_t) <= sizeof (uint32_t) );
JERRY_STATIC_ASSERT( sizeof (ecma_array_first_chunk_t) == ECMA_ARRAY_CHUNK_SIZE_IN_BYTES );
JERRY_STATIC_ASSERT( sizeof (ecma_array_non_first_chunk_t) == ECMA_ARRAY_CHUNK_SIZE_IN_BYTES );
JERRY_STATIC_ASSERT( sizeof (ecma_completion_value_t) == sizeof(uint32_t) );
/**
* Template of an allocation routine.
@@ -52,12 +52,12 @@ JERRY_STATIC_ASSERT( sizeof (ecma_CompletionValue_t) == sizeof(uint32_t) );
* FIXME: Run GC only if allocation failed.
*/
#define ALLOC( ecmaType) ecma_ ## ecmaType ## _t * \
ecma_Alloc ## ecmaType (void) \
ecma_alloc_ ## ecmaType (void) \
{ \
ecma_ ## ecmaType ## _t *p ## ecmaType = (ecma_ ## ecmaType ## _t *) \
mem_pools_alloc( mem_size_to_pool_chunk_type( sizeof(ecma_ ## ecmaType ## _t))); \
\
ecma_GCRun(); \
ecma_gc_run(); \
JERRY_ASSERT( p ## ecmaType != NULL ); \
\
return p ## ecmaType; \
@@ -67,7 +67,7 @@ ecma_Alloc ## ecmaType (void) \
* Deallocation routine template
*/
#define DEALLOC( ecmaType) void \
ecma_Dealloc ## ecmaType( ecma_ ## ecmaType ## _t *p ## ecmaType) \
ecma_dealloc_ ## ecmaType( ecma_ ## ecmaType ## _t *p ## ecmaType) \
{ \
mem_pools_free( mem_size_to_pool_chunk_type( sizeof(ecma_ ## ecmaType ## _t)), \
(uint8_t*) p ## ecmaType); \
@@ -80,11 +80,11 @@ ecma_Dealloc ## ecmaType( ecma_ ## ecmaType ## _t *p ## ecmaType) \
ALLOC( ecmaType) \
DEALLOC( ecmaType)
DECLARE_ROUTINES_FOR (Object)
DECLARE_ROUTINES_FOR (Property)
DECLARE_ROUTINES_FOR (Number)
DECLARE_ROUTINES_FOR (ArrayFirstChunk)
DECLARE_ROUTINES_FOR (ArrayNonFirstChunk)
DECLARE_ROUTINES_FOR (object)
DECLARE_ROUTINES_FOR (property)
DECLARE_ROUTINES_FOR (number)
DECLARE_ROUTINES_FOR (array_first_chunk)
DECLARE_ROUTINES_FOR (array_non_first_chunk)
/**
* @}
src/libecmaobjects/ecma-alloc.h
+10 -10
View File
@@ -30,60 +30,60 @@
*
* @return pointer to allocated memory
*/
extern ecma_Object_t *ecma_AllocObject(void);
extern ecma_object_t *ecma_alloc_object(void);
/**
* Dealloc memory from an ecma-object
*/
extern void ecma_DeallocObject( ecma_Object_t *pObject);
extern void ecma_dealloc_object( ecma_object_t *pObject);
/**
* Allocate memory for ecma-property
*
* @return pointer to allocated memory
*/
extern ecma_Property_t *ecma_AllocProperty(void);
extern ecma_property_t *ecma_alloc_property(void);
/**
* Dealloc memory from an ecma-property
*/
extern void ecma_DeallocProperty( ecma_Property_t *pProperty);
extern void ecma_dealloc_property( ecma_property_t *pProperty);
/**
* Allocate memory for ecma-number
*
* @return pointer to allocated memory
*/
extern ecma_Number_t *ecma_AllocNumber(void);
extern ecma_number_t *ecma_alloc_number(void);
/**
* Dealloc memory from an ecma-number
*/
extern void ecma_DeallocNumber( ecma_Number_t *pNumber);
extern void ecma_dealloc_number( ecma_number_t *pNumber);
/**
* Allocate memory for first chunk of an ecma-array
*
* @return pointer to allocated memory
*/
extern ecma_ArrayFirstChunk_t *ecma_AllocArrayFirstChunk(void);
extern ecma_array_first_chunk_t *ecma_alloc_array_first_chunk(void);
/**
* Dealloc memory from first chunk of an ecma-array
*/
extern void ecma_DeallocArrayFirstChunk( ecma_ArrayFirstChunk_t *pFirstChunk);
extern void ecma_dealloc_array_first_chunk( ecma_array_first_chunk_t *pFirstChunk);
/**
* Allocate memory for non-first chunk of an ecma-array
*
* @return pointer to allocated memory
*/
extern ecma_ArrayNonFirstChunk_t *ecma_AllocArrayNonFirstChunk(void);
extern ecma_array_non_first_chunk_t *ecma_alloc_array_non_first_chunk(void);
/**
* Dealloc memory from non-first chunk of an ecma-array
*/
extern void ecma_DeallocArrayNonFirstChunk( ecma_ArrayNonFirstChunk_t *pNumber);
extern void ecma_dealloc_array_non_first_chunk( ecma_array_non_first_chunk_t *pNumber);
#endif /* JERRY_ECMA_ALLOC_H */
src/libecmaobjects/ecma-gc.c
+26 -26
View File
@@ -33,7 +33,7 @@
/**
* Queue of objects, awaiting for GC
*/
static ecma_Object_t *ecma_GC_Queue;
static ecma_object_t *ecma_gc_objs_to_free_queue;
/**
* Queue object for GC.
@@ -42,23 +42,23 @@ static ecma_Object_t *ecma_GC_Queue;
* After this operation the object is not longer valid for general use.
*/
static void
ecma_GCQueue( ecma_Object_t *pObject) /**< object */
ecma_gc_queue( ecma_object_t *pObject) /**< object */
{
JERRY_ASSERT( pObject != NULL );
JERRY_ASSERT( pObject->GCInfo.IsObjectValid );
JERRY_ASSERT( pObject->GCInfo.u.Refs == 0 );
pObject->GCInfo.IsObjectValid = false;
ecma_SetPointer( pObject->GCInfo.u.NextQueuedForGC, ecma_GC_Queue);
ecma_set_pointer( pObject->GCInfo.u.NextQueuedForGC, ecma_gc_objs_to_free_queue);
ecma_GC_Queue = pObject;
} /* ecma_QueueGC */
ecma_gc_objs_to_free_queue = pObject;
} /* ecma_gc_queue */
/**
* Increase reference counter of an object
*/
void
ecma_RefObject(ecma_Object_t *pObject) /**< object */
ecma_ref_object(ecma_object_t *pObject) /**< object */
{
JERRY_ASSERT(pObject->GCInfo.IsObjectValid);
@@ -68,13 +68,13 @@ ecma_RefObject(ecma_Object_t *pObject) /**< object */
* Check that value was not overflowed
*/
JERRY_ASSERT(pObject->GCInfo.u.Refs > 0);
} /* ecma_RefObject */
} /* ecma_ref_object */
/**
* Decrease reference counter of an object
*/
void
ecma_DerefObject(ecma_Object_t *pObject) /**< object */
ecma_deref_object(ecma_object_t *pObject) /**< object */
{
JERRY_ASSERT(pObject != NULL);
JERRY_ASSERT(pObject->GCInfo.IsObjectValid);
@@ -84,62 +84,62 @@ ecma_DerefObject(ecma_Object_t *pObject) /**< object */
if ( pObject->GCInfo.u.Refs == 0 )
{
ecma_GCQueue( pObject);
ecma_gc_queue( pObject);
}
} /* ecma_DerefObject */
} /* ecma_deref_object */
/**
* Initialize garbage collector
*/
void
ecma_GCInit( void)
ecma_gc_init( void)
{
ecma_GC_Queue = NULL;
} /* ecma_GCInit */
ecma_gc_objs_to_free_queue = NULL;
} /* ecma_gc_init */
/**
* Run garbage collecting
*/
void
ecma_GCRun( void)
ecma_gc_run( void)
{
while ( ecma_GC_Queue != NULL )
while ( ecma_gc_objs_to_free_queue != NULL )
{
ecma_Object_t *pObject = ecma_GC_Queue;
ecma_GC_Queue = ecma_GetPointer( pObject->GCInfo.u.NextQueuedForGC);
ecma_object_t *pObject = ecma_gc_objs_to_free_queue;
ecma_gc_objs_to_free_queue = ecma_get_pointer( pObject->GCInfo.u.NextQueuedForGC);
JERRY_ASSERT( !pObject->GCInfo.IsObjectValid );
for ( ecma_Property_t *property = ecma_GetPointer( pObject->pProperties), *pNextProperty;
for ( ecma_property_t *property = ecma_get_pointer( pObject->pProperties), *pNextProperty;
property != NULL;
property = pNextProperty )
{
pNextProperty = ecma_GetPointer( property->pNextProperty);
pNextProperty = ecma_get_pointer( property->pNextProperty);
ecma_FreeProperty( property);
ecma_free_property( property);
}
if ( pObject->IsLexicalEnvironment )
{
ecma_Object_t *pOuterLexicalEnvironment = ecma_GetPointer( pObject->u.LexicalEnvironment.pOuterReference);
ecma_object_t *pOuterLexicalEnvironment = ecma_get_pointer( pObject->u.LexicalEnvironment.pOuterReference);
if ( pOuterLexicalEnvironment != NULL )
{
ecma_DerefObject( pOuterLexicalEnvironment);
ecma_deref_object( pOuterLexicalEnvironment);
}
} else
{
ecma_Object_t *pPrototypeObject = ecma_GetPointer( pObject->u.Object.pPrototypeObject);
ecma_object_t *pPrototypeObject = ecma_get_pointer( pObject->u.Object.pPrototypeObject);
if ( pPrototypeObject != NULL )
{
ecma_DerefObject( pPrototypeObject);
ecma_deref_object( pPrototypeObject);
}
}
ecma_DeallocObject( pObject);
ecma_dealloc_object( pObject);
}
} /* ecma_RunGC */
} /* ecma_gc_run */
/**
* @}
src/libecmaobjects/ecma-gc.h
+5 -5
View File
@@ -29,14 +29,14 @@
#include "ecma-globals.h"
extern void ecma_GCInit( void);
extern void ecma_RefObject(ecma_Object_t *pObject);
extern void ecma_DerefObject(ecma_Object_t *pObject);
extern void ecma_GCRun( void);
extern void ecma_gc_init( void);
extern void ecma_ref_object(ecma_object_t *pObject);
extern void ecma_deref_object(ecma_object_t *pObject);
extern void ecma_gc_run( void);
#endif /* !ECMA_GC_H */
/**
* @}
* @}
*/
*/
src/libecmaobjects/ecma-globals.h
+46 -46
View File
@@ -57,7 +57,7 @@ typedef enum {
ECMA_TYPE_STRING, /**< pointer to description of a string */
ECMA_TYPE_OBJECT, /**< pointer to description of an object */
ECMA_TYPE__COUNT /**< count of types */
} ecma_Type_t;
} ecma_type_t;
/**
* Simple ecma-values
@@ -72,7 +72,7 @@ typedef enum {
but is stored directly in the array's property list
(used for array elements with non-default attribute values) */
ECMA_SIMPLE_VALUE__COUNT /** count of simple ecma-values */
} ecma_SimpleValue_t;
} ecma_simple_value_t;
/**
* Type of ecma-property
@@ -81,7 +81,7 @@ typedef enum {
ECMA_PROPERTY_NAMEDDATA, /**< named data property */
ECMA_PROPERTY_NAMEDACCESSOR, /**< named accessor property */
ECMA_PROPERTY_INTERNAL /**< internal property */
} ecma_PropertyType_t;
} ecma_property_type_t;
/**
* Type of block evaluation (completion) result.
@@ -96,20 +96,20 @@ typedef enum {
ECMA_COMPLETION_TYPE_THROW, /**< block completed with throw */
ECMA_COMPLETION_TYPE_EXIT /**< implementation-defined completion type
for finishing script execution */
} ecma_CompletionType_t;
} ecma_completion_type_t;
/**
* Description of an ecma-value
*/
typedef struct {
/** Value type (ecma_Type_t) */
/** Value type (ecma_type_t) */
unsigned int ValueType : 2;
/**
* Simple value (ecma_SimpleValue_t) or compressed pointer to value (depending on ValueType)
* Simple value (ecma_simple_value_t) or compressed pointer to value (depending on ValueType)
*/
unsigned int Value : ECMA_POINTER_FIELD_WIDTH;
} __packed ecma_Value_t;
} __packed ecma_value_t;
/**
* Description of a block completion value
@@ -117,19 +117,19 @@ typedef struct {
* See also: ECMA-262 v5, 8.9.
*/
typedef struct {
/** Type (ecma_CompletionType_t) */
/** Type (ecma_completion_type_t) */
unsigned int type : 3;
/** Value */
ecma_Value_t value;
ecma_value_t value;
/** Target */
unsigned int target : 8;
} __packed ecma_CompletionValue_t;
} __packed ecma_completion_value_t;
/**
* Target value indicating that target field
* of ecma_CompletionValue_t defines no target.
* of ecma_completion_value_t defines no target.
*/
#define ECMA_TARGET_ID_RESERVED 255
@@ -153,7 +153,7 @@ typedef enum {
/** Part of an array, that is indexed by strings */
ECMA_INTERNAL_PROPERTY_STRING_INDEXED_ARRAY_VALUES
} ecma_InternalPropertyId_t;
} ecma_internal_property_id_t;
/**
* Property's 'Writable' attribute's values description.
@@ -162,7 +162,7 @@ typedef enum
{
ECMA_PROPERTY_NOT_WRITABLE, /**< property's 'Writable' attribute is false */
ECMA_PROPERTY_WRITABLE /**< property's 'Writable' attribute is true */
} ecma_PropertyWritableValue_t;
} ecma_property_writable_value_t;
/**
* Property's 'Enumerable' attribute's values description.
@@ -171,7 +171,7 @@ typedef enum
{
ECMA_PROPERTY_NOT_ENUMERABLE, /**< property's 'Enumerable' attribute is false */
ECMA_PROPERTY_ENUMERABLE /**< property's 'Enumerable' attribute is true */
} ecma_PropertyEnumerableValue_t;
} ecma_property_enumerable_value_t;
/**
* Property's 'Configurable' attribute's values description.
@@ -180,13 +180,13 @@ typedef enum
{
ECMA_PROPERTY_NOT_CONFIGURABLE, /**< property's 'Configurable' attribute is false */
ECMA_PROPERTY_CONFIGURABLE /**< property's 'Configurable' attribute is true */
} ecma_PropertyConfigurableValue_t;
} ecma_property_configurable_value_t;
/**
* Description of ecma-property.
*/
typedef struct ecma_Property_t {
/** Property's type (ecma_PropertyType_t) */
typedef struct ecma_property_t {
/** Property's type (ecma_property_type_t) */
unsigned int Type : 2;
/** Compressed pointer to next property */
@@ -196,32 +196,32 @@ typedef struct ecma_Property_t {
union {
/** Description of named data property */
struct __packed ecma_NamedDataProperty_t {
struct __packed ecma_named_data_property_t {
/** Compressed pointer to property's name (pointer to String) */
unsigned int pName : ECMA_POINTER_FIELD_WIDTH;
/** Attribute 'Writable' (ecma_PropertyWritableValue_t) */
/** Attribute 'Writable' (ecma_property_writable_value_t) */
unsigned int Writable : 1;
/** Attribute 'Enumerable' (ecma_PropertyEnumerableValue_t) */
/** Attribute 'Enumerable' (ecma_property_enumerable_value_t) */
unsigned int Enumerable : 1;
/** Attribute 'Configurable' (ecma_PropertyConfigurableValue_t) */
/** Attribute 'Configurable' (ecma_property_configurable_value_t) */
unsigned int Configurable : 1;
/** Value */
ecma_Value_t Value;
ecma_value_t Value;
} NamedDataProperty;
/** Description of named accessor property */
struct __packed ecma_NamedAccessorProperty_t {
struct __packed ecma_named_accessor_property_t {
/** Compressed pointer to property's name (pointer to String) */
unsigned int pName : ECMA_POINTER_FIELD_WIDTH;
/** Attribute 'Enumerable' (ecma_PropertyEnumerableValue_t) */
/** Attribute 'Enumerable' (ecma_property_enumerable_value_t) */
unsigned int Enumerable : 1;
/** Attribute 'Configurable' (ecma_PropertyConfigurableValue_t) */
/** Attribute 'Configurable' (ecma_property_configurable_value_t) */
unsigned int Configurable : 1;
/** Compressed pointer to property's getter */
@@ -232,7 +232,7 @@ typedef struct ecma_Property_t {
} NamedAccessorProperty;
/** Description of internal property */
struct __packed ecma_InternalProperty_t {
struct __packed ecma_internal_property_t {
/** Internal property's type */
unsigned int InternalPropertyType : 4;
@@ -240,7 +240,7 @@ typedef struct ecma_Property_t {
unsigned int Value : ECMA_POINTER_FIELD_WIDTH;
} InternalProperty;
} u;
} ecma_Property_t;
} ecma_property_t;
/**
* Description of GC's information layout
@@ -267,7 +267,7 @@ typedef struct {
/** Compressed pointer to next object in the list of objects, queued for GC (if !IsObjectValid) */
unsigned int NextQueuedForGC : ECMA_POINTER_FIELD_WIDTH;
} __packed u;
} ecma_GCInfo_t;
} ecma_GC_info_t;
/**
* Types of lexical environments
@@ -275,13 +275,13 @@ typedef struct {
typedef enum {
ECMA_LEXICAL_ENVIRONMENT_DECLARATIVE, /**< declarative lexical environment */
ECMA_LEXICAL_ENVIRONMENT_OBJECTBOUND /**< object-bound lexical environment */
} ecma_LexicalEnvironmentType_t;
} ecma_lexical_environment_type_t;
/**
* Description of ECMA-object or lexical environment
* (depending on IsLexicalEnvironment).
*/
typedef struct ecma_Object_t {
typedef struct ecma_object_t {
/** Compressed pointer to property list */
unsigned int pProperties : ECMA_POINTER_FIELD_WIDTH;
@@ -301,7 +301,7 @@ typedef struct ecma_Object_t {
/** Attribute 'Extensible' */
unsigned int Extensible : 1;
/** Compressed pointer to prototype object (ecma_Object_t) */
/** Compressed pointer to prototype object (ecma_object_t) */
unsigned int pPrototypeObject : ECMA_POINTER_FIELD_WIDTH;
} __packed Object;
@@ -310,7 +310,7 @@ typedef struct ecma_Object_t {
*/
struct {
/**
* Type of lexical environment (ecma_LexicalEnvironmentType_t).
* Type of lexical environment (ecma_lexical_environment_type_t).
*/
unsigned int Type : 1;
@@ -321,23 +321,23 @@ typedef struct ecma_Object_t {
} __packed u;
/** GC's information */
ecma_GCInfo_t GCInfo;
} ecma_Object_t;
ecma_GC_info_t GCInfo;
} ecma_object_t;
/**
* Description of an ecma-character
*/
typedef uint8_t ecma_Char_t;
typedef uint8_t ecma_char_t;
/**
* Description of an ecma-number
*/
typedef float ecma_Number_t;
typedef float ecma_number_t;
/**
* Description of arrays'/strings' length
*/
typedef uint16_t ecma_Length_t;
typedef uint16_t ecma_length_t;
/**
* Description of an Array's header
@@ -347,8 +347,8 @@ typedef struct {
uint16_t pNextChunk;
/** Number of elements in the Array */
ecma_Length_t UnitNumber;
} ecma_ArrayHeader_t;
ecma_length_t UnitNumber;
} ecma_array_header_t;
/**
* Size of a chunk, containing a String's part, in bytes
@@ -360,11 +360,11 @@ typedef struct {
*/
typedef struct {
/** Array's header */
ecma_ArrayHeader_t Header;
ecma_array_header_t Header;
/** Elements */
uint8_t Data[ ECMA_ARRAY_CHUNK_SIZE_IN_BYTES - sizeof (ecma_ArrayHeader_t) ];
} ecma_ArrayFirstChunk_t;
uint8_t Data[ ECMA_ARRAY_CHUNK_SIZE_IN_BYTES - sizeof (ecma_array_header_t) ];
} ecma_array_first_chunk_t;
/**
* Description of non-first chunk in a chain of chunks that contains an Array
@@ -375,7 +375,7 @@ typedef struct {
/** Characters */
uint8_t Data[ ECMA_ARRAY_CHUNK_SIZE_IN_BYTES - sizeof (uint16_t) ];
} ecma_ArrayNonFirstChunk_t;
} ecma_array_non_first_chunk_t;
/**
* \addtogroup reference ECMA-reference
@@ -388,14 +388,14 @@ typedef struct {
typedef struct
{
/** base value */
ecma_Value_t base;
ecma_value_t base;
/** referenced name value pointer */
ecma_Char_t *referenced_name_p;
ecma_char_t *referenced_name_p;
/** strict reference flag */
bool is_strict;
} ecma_Reference_t;
} ecma_reference_t;
/**
* @}
src/libecmaobjects/ecma-helpers-value.c
+78 -78
View File
@@ -33,10 +33,10 @@
* false - otherwise.
*/
bool
ecma_IsValueUndefined( ecma_Value_t value) /**< ecma-value */
ecma_is_value_undefined( ecma_value_t value) /**< ecma-value */
{
return ( value.ValueType == ECMA_TYPE_SIMPLE && value.Value == ECMA_SIMPLE_VALUE_UNDEFINED );
} /* ecma_IsValueUndefined */
} /* ecma_is_value_undefined */
/**
* Check if the value is null.
@@ -45,10 +45,10 @@ ecma_IsValueUndefined( ecma_Value_t value) /**< ecma-value */
* false - otherwise.
*/
bool
ecma_IsValueNull( ecma_Value_t value) /**< ecma-value */
ecma_is_value_null( ecma_value_t value) /**< ecma-value */
{
return ( value.ValueType == ECMA_TYPE_SIMPLE && value.Value == ECMA_SIMPLE_VALUE_NULL );
} /* ecma_IsValueNull */
} /* ecma_is_value_null */
/**
* Check if the value is boolean.
@@ -57,11 +57,11 @@ ecma_IsValueNull( ecma_Value_t value) /**< ecma-value */
* false - otherwise.
*/
bool
ecma_IsValueBoolean( ecma_Value_t value) /**< ecma-value */
ecma_is_value_boolean( ecma_value_t value) /**< ecma-value */
{
return ( ( value.ValueType == ECMA_TYPE_SIMPLE && value.Value == ECMA_SIMPLE_VALUE_FALSE )
|| ( value.ValueType == ECMA_TYPE_SIMPLE && value.Value == ECMA_SIMPLE_VALUE_TRUE ) );
} /* ecma_IsValueBoolean */
} /* ecma_is_value_boolean */
/**
* Check if the value is true.
@@ -73,50 +73,50 @@ ecma_IsValueBoolean( ecma_Value_t value) /**< ecma-value */
* false - otherwise.
*/
bool
ecma_IsValueTrue( ecma_Value_t value) /**< ecma-value */
ecma_is_value_true( ecma_value_t value) /**< ecma-value */
{
JERRY_ASSERT( ecma_IsValueBoolean( value) );
JERRY_ASSERT( ecma_is_value_boolean( value) );
return ( value.ValueType == ECMA_TYPE_SIMPLE && value.Value == ECMA_SIMPLE_VALUE_TRUE );
} /* ecma_IsValueTrue */
} /* ecma_is_value_true */
/**
* Simple value constructor
*/
ecma_Value_t
ecma_MakeSimpleValue( ecma_SimpleValue_t value) /**< simple value */
ecma_value_t
ecma_make_simple_value( ecma_simple_value_t value) /**< simple value */
{
return (ecma_Value_t) { .ValueType = ECMA_TYPE_SIMPLE, .Value = value };
} /* ecma_MakeSimpleValue */
return (ecma_value_t) { .ValueType = ECMA_TYPE_SIMPLE, .Value = value };
} /* ecma_make_simple_value */
/**
* Number value constructor
*/
ecma_Value_t
ecma_MakeNumberValue( ecma_Number_t* num_p) /**< number to reference in value */
ecma_value_t
ecma_make_number_value( ecma_number_t* num_p) /**< number to reference in value */
{
JERRY_ASSERT( num_p != NULL );
ecma_Value_t number_value;
ecma_value_t number_value;
number_value.ValueType = ECMA_TYPE_NUMBER;
ecma_SetPointer( number_value.Value, num_p);
ecma_set_pointer( number_value.Value, num_p);
return number_value;
} /* ecma_MakeNumberValue */
} /* ecma_make_number_value */
/**
* String value constructor
*/
ecma_Value_t
ecma_make_string_value( ecma_ArrayFirstChunk_t* ecma_string_p) /**< string to reference in value */
ecma_value_t
ecma_make_string_value( ecma_array_first_chunk_t* ecma_string_p) /**< string to reference in value */
{
JERRY_ASSERT( ecma_string_p != NULL );
ecma_Value_t string_value;
ecma_value_t string_value;
string_value.ValueType = ECMA_TYPE_STRING;
ecma_SetPointer( string_value.Value, ecma_string_p);
ecma_set_pointer( string_value.Value, ecma_string_p);
return string_value;
} /* ecma_make_string_value */
@@ -124,18 +124,18 @@ ecma_make_string_value( ecma_ArrayFirstChunk_t* ecma_string_p) /**< string to re
/**
* Object value constructor
*/
ecma_Value_t
ecma_MakeObjectValue( ecma_Object_t* object_p) /**< object to reference in value */
ecma_value_t
ecma_make_object_value( ecma_object_t* object_p) /**< object to reference in value */
{
JERRY_ASSERT( object_p != NULL );
ecma_Value_t object_value;
ecma_value_t object_value;
object_value.ValueType = ECMA_TYPE_OBJECT;
ecma_SetPointer( object_value.Value, object_p);
ecma_set_pointer( object_value.Value, object_p);
return object_value;
} /* ecma_MakeObjectValue */
} /* ecma_make_object_value */
/**
* Copy ecma-value.
@@ -158,12 +158,12 @@ ecma_MakeObjectValue( ecma_Object_t* object_p) /**< object to reference in value
*
* @return See note.
*/
ecma_Value_t
ecma_CopyValue( const ecma_Value_t value) /**< ecma-value */
ecma_value_t
ecma_copy_value( const ecma_value_t value) /**< ecma-value */
{
ecma_Value_t value_copy;
ecma_value_t value_copy;
switch ( (ecma_Type_t)value.ValueType )
switch ( (ecma_type_t)value.ValueType )
{
case ECMA_TYPE_SIMPLE:
{
@@ -173,35 +173,35 @@ ecma_CopyValue( const ecma_Value_t value) /**< ecma-value */
}
case ECMA_TYPE_NUMBER:
{
ecma_Number_t *num_p = ecma_GetPointer( value.Value);
ecma_number_t *num_p = ecma_get_pointer( value.Value);
JERRY_ASSERT( num_p != NULL );
ecma_Number_t *number_copy_p = ecma_AllocNumber();
ecma_number_t *number_copy_p = ecma_alloc_number();
*number_copy_p = *num_p;
value_copy = (ecma_Value_t) { .ValueType = ECMA_TYPE_NUMBER };
ecma_SetPointer( value_copy.Value, number_copy_p);
value_copy = (ecma_value_t) { .ValueType = ECMA_TYPE_NUMBER };
ecma_set_pointer( value_copy.Value, number_copy_p);
break;
}
case ECMA_TYPE_STRING:
{
ecma_ArrayFirstChunk_t *string_p = ecma_GetPointer( value.Value);
ecma_array_first_chunk_t *string_p = ecma_get_pointer( value.Value);
JERRY_ASSERT( string_p != NULL );
ecma_ArrayFirstChunk_t *string_copy_p = ecma_DuplicateEcmaString( string_p);
ecma_array_first_chunk_t *string_copy_p = ecma_duplicate_ecma_string( string_p);
value_copy = (ecma_Value_t) { .ValueType = ECMA_TYPE_STRING };
ecma_SetPointer( value_copy.Value, string_copy_p);
value_copy = (ecma_value_t) { .ValueType = ECMA_TYPE_STRING };
ecma_set_pointer( value_copy.Value, string_copy_p);
break;
}
case ECMA_TYPE_OBJECT:
{
ecma_Object_t *obj_p = ecma_GetPointer( value.Value);
ecma_object_t *obj_p = ecma_get_pointer( value.Value);
JERRY_ASSERT( obj_p != NULL );
ecma_RefObject( obj_p);
ecma_ref_object( obj_p);
value_copy = value;
@@ -214,15 +214,15 @@ ecma_CopyValue( const ecma_Value_t value) /**< ecma-value */
}
return value_copy;
} /* ecma_CopyValue */
} /* ecma_copy_value */
/**
* Free the ecma-value
*/
void
ecma_FreeValue( ecma_Value_t value) /**< value description */
ecma_free_value( ecma_value_t value) /**< value description */
{
switch ( (ecma_Type_t) value.ValueType )
switch ( (ecma_type_t) value.ValueType )
{
case ECMA_TYPE_SIMPLE:
{
@@ -232,21 +232,21 @@ ecma_FreeValue( ecma_Value_t value) /**< value description */
case ECMA_TYPE_NUMBER:
{
ecma_Number_t *pNumber = ecma_GetPointer( value.Value);
ecma_DeallocNumber( pNumber);
ecma_number_t *pNumber = ecma_get_pointer( value.Value);
ecma_dealloc_number( pNumber);
break;
}
case ECMA_TYPE_STRING:
{
ecma_ArrayFirstChunk_t *pString = ecma_GetPointer( value.Value);
ecma_FreeArray( pString);
ecma_array_first_chunk_t *pString = ecma_get_pointer( value.Value);
ecma_free_array( pString);
break;
}
case ECMA_TYPE_OBJECT:
{
ecma_DerefObject( ecma_GetPointer( value.Value));
ecma_deref_object( ecma_get_pointer( value.Value));
break;
}
@@ -255,61 +255,61 @@ ecma_FreeValue( ecma_Value_t value) /**< value description */
JERRY_UNREACHABLE();
}
}
} /* ecma_FreeValue */
} /* ecma_free_value */
/**
* Completion value constructor
*
* @return completion value
*/
ecma_CompletionValue_t
ecma_MakeCompletionValue(ecma_CompletionType_t type, /**< type */
ecma_Value_t value, /**< value */
ecma_completion_value_t
ecma_make_completion_value(ecma_completion_type_t type, /**< type */
ecma_value_t value, /**< value */
uint8_t target) /**< target */
{
return (ecma_CompletionValue_t) { .type = type, .value = value, .target = target };
} /* ecma_MakeCompletionValue */
return (ecma_completion_value_t) { .type = type, .value = value, .target = target };
} /* ecma_make_completion_value */
/**
* Throw completion value constructor.
*
* @return 'throw' completion value
*/
ecma_CompletionValue_t
ecma_MakeThrowValue( ecma_Object_t *exception_p) /**< an object */
ecma_completion_value_t
ecma_make_throw_value( ecma_object_t *exception_p) /**< an object */
{
JERRY_ASSERT( exception_p != NULL && !exception_p->IsLexicalEnvironment );
ecma_Value_t exception = ecma_MakeObjectValue( exception_p);
ecma_value_t exception = ecma_make_object_value( exception_p);
return ecma_MakeCompletionValue(ECMA_COMPLETION_TYPE_THROW,
return ecma_make_completion_value(ECMA_COMPLETION_TYPE_THROW,
exception,
ECMA_TARGET_ID_RESERVED);
} /* ecma_MakeThrowValue */
} /* ecma_make_throw_value */
/**
* Empty completion value constructor.
*
* @return (normal, empty, reserved) completion value.
*/
ecma_CompletionValue_t
ecma_completion_value_t
ecma_make_empty_completion_value( void)
{
return ecma_MakeCompletionValue( ECMA_COMPLETION_TYPE_NORMAL,
ecma_MakeSimpleValue( ECMA_SIMPLE_VALUE_EMPTY),
return ecma_make_completion_value( ECMA_COMPLETION_TYPE_NORMAL,
ecma_make_simple_value( ECMA_SIMPLE_VALUE_EMPTY),
ECMA_TARGET_ID_RESERVED);
} /* ecma_make_empty_completion_value */
/**
* Copy ecma-completion value.
*
* @return (source.type, ecma_CopyValue( source.value), source.target).
* @return (source.type, ecma_copy_value( source.value), source.target).
*/
ecma_CompletionValue_t
ecma_copy_completion_value( ecma_CompletionValue_t value) /**< completion value */
ecma_completion_value_t
ecma_copy_completion_value( ecma_completion_value_t value) /**< completion value */
{
return ecma_MakeCompletionValue( value.type,
ecma_CopyValue( value.value),
return ecma_make_completion_value( value.type,
ecma_copy_value( value.value),
value.target);
} /* ecma_copy_completion_value */
@@ -317,14 +317,14 @@ ecma_copy_completion_value( ecma_CompletionValue_t value) /**< completion value
* Free the completion value.
*/
void
ecma_free_completion_value( ecma_CompletionValue_t completion_value) /**< completion value */
ecma_free_completion_value( ecma_completion_value_t completion_value) /**< completion value */
{
switch ( completion_value.type )
{
case ECMA_COMPLETION_TYPE_NORMAL:
case ECMA_COMPLETION_TYPE_THROW:
case ECMA_COMPLETION_TYPE_RETURN:
ecma_FreeValue( completion_value.value);
ecma_free_value( completion_value.value);
break;
case ECMA_COMPLETION_TYPE_CONTINUE:
case ECMA_COMPLETION_TYPE_BREAK:
@@ -341,7 +341,7 @@ ecma_free_completion_value( ecma_CompletionValue_t completion_value) /**< comple
* false - otherwise.
*/
bool
ecma_is_completion_value_normal( ecma_CompletionValue_t value) /**< completion value */
ecma_is_completion_value_normal( ecma_completion_value_t value) /**< completion value */
{
return ( value.type == ECMA_COMPLETION_TYPE_NORMAL );
} /* ecma_is_completion_value_normal */
@@ -353,7 +353,7 @@ ecma_is_completion_value_normal( ecma_CompletionValue_t value) /**< completion v
* false - otherwise.
*/
bool
ecma_is_completion_value_throw( ecma_CompletionValue_t value) /**< completion value */
ecma_is_completion_value_throw( ecma_completion_value_t value) /**< completion value */
{
return ( value.type == ECMA_COMPLETION_TYPE_THROW );
} /* ecma_is_completion_value_throw */
@@ -366,8 +366,8 @@ ecma_is_completion_value_throw( ecma_CompletionValue_t value) /**< completion va
* false - otherwise.
*/
bool
ecma_is_completion_value_normal_simple_value(ecma_CompletionValue_t value, /**< completion value */
ecma_SimpleValue_t simple_value) /**< simple value to check for equality with */
ecma_is_completion_value_normal_simple_value(ecma_completion_value_t value, /**< completion value */
ecma_simple_value_t simple_value) /**< simple value to check for equality with */
{
return ( value.type == ECMA_COMPLETION_TYPE_NORMAL
&& value.value.ValueType == ECMA_TYPE_SIMPLE
@@ -382,10 +382,10 @@ ecma_is_completion_value_normal_simple_value(ecma_CompletionValue_t value, /**<
* false - otherwise.
*/
bool
ecma_IsCompletionValueNormalTrue( ecma_CompletionValue_t value) /**< completion value */
ecma_is_completion_value_normal_true( ecma_completion_value_t value) /**< completion value */
{
return ecma_is_completion_value_normal_simple_value( value, ECMA_SIMPLE_VALUE_TRUE);
} /* ecma_IsCompletionValueNormalTrue */
} /* ecma_is_completion_value_normal_true */
/**
* Check if the completion value is normal false.
@@ -395,10 +395,10 @@ ecma_IsCompletionValueNormalTrue( ecma_CompletionValue_t value) /**< completion
* false - otherwise.
*/
bool
ecma_IsCompletionValueNormalFalse( ecma_CompletionValue_t value) /**< completion value */
ecma_is_completion_value_normal_false( ecma_completion_value_t value) /**< completion value */
{
return ecma_is_completion_value_normal_simple_value( value, ECMA_SIMPLE_VALUE_FALSE);
} /* ecma_IsCompletionValueNormalFalse */
} /* ecma_is_completion_value_normal_false */
/**
* @}
src/libecmaobjects/ecma-helpers.c
+160 -160
View File
@@ -30,7 +30,7 @@
* Compress pointer.
*/
uintptr_t
ecma_CompressPointer(void *pointer) /**< pointer to compress */
ecma_compress_pointer(void *pointer) /**< pointer to compress */
{
if ( pointer == NULL )
{
@@ -47,13 +47,13 @@ ecma_CompressPointer(void *pointer) /**< pointer to compress */
JERRY_ASSERT((intPtr & ~((1u << ECMA_POINTER_FIELD_WIDTH) - 1)) == 0);
return intPtr;
} /* ecma_CompressPointer */
} /* ecma_compress_pointer */
/**
* Decompress pointer.
*/
void*
ecma_DecompressPointer(uintptr_t compressedPointer) /**< pointer to decompress */
ecma_decompress_pointer(uintptr_t compressedPointer) /**< pointer to decompress */
{
if ( compressedPointer == ECMA_NULL_POINTER )
{
@@ -66,7 +66,7 @@ ecma_DecompressPointer(uintptr_t compressedPointer) /**< pointer to decompress *
intPtr += mem_get_base_pointer();
return (void*) intPtr;
} /* ecma_DecompressPointer */
} /* ecma_decompress_pointer */
/**
* Create an object with specified prototype object
@@ -77,11 +77,11 @@ ecma_DecompressPointer(uintptr_t compressedPointer) /**< pointer to decompress *
*
* @return pointer to the object's descriptor
*/
ecma_Object_t*
ecma_CreateObject( ecma_Object_t *pPrototypeObject, /**< pointer to prototybe of the object (or NULL) */
ecma_object_t*
ecma_create_object( ecma_object_t *pPrototypeObject, /**< pointer to prototybe of the object (or NULL) */
bool isExtensible) /**< value of extensible attribute */
{
ecma_Object_t *pObject = ecma_AllocObject();
ecma_object_t *pObject = ecma_alloc_object();
pObject->pProperties = ECMA_NULL_POINTER;
pObject->IsLexicalEnvironment = false;
@@ -92,10 +92,10 @@ ecma_CreateObject( ecma_Object_t *pPrototypeObject, /**< pointer to prototybe of
pObject->GCInfo.u.Refs = 1;
pObject->u.Object.Extensible = isExtensible;
ecma_SetPointer( pObject->u.Object.pPrototypeObject, pPrototypeObject);
ecma_set_pointer( pObject->u.Object.pPrototypeObject, pPrototypeObject);
return pObject;
} /* ecma_CreateObject */
} /* ecma_create_object */
/**
* Create a lexical environment with specified outer lexical environment
@@ -109,11 +109,11 @@ ecma_CreateObject( ecma_Object_t *pPrototypeObject, /**< pointer to prototybe of
*
* @return pointer to the descriptor of lexical environment
*/
ecma_Object_t*
ecma_CreateLexicalEnvironment(ecma_Object_t *pOuterLexicalEnvironment, /**< outer lexical environment */
ecma_LexicalEnvironmentType_t type) /**< type of lexical environment to create */
ecma_object_t*
ecma_create_lexical_environment(ecma_object_t *pOuterLexicalEnvironment, /**< outer lexical environment */
ecma_lexical_environment_type_t type) /**< type of lexical environment to create */
{
ecma_Object_t *pNewLexicalEnvironment = ecma_AllocObject();
ecma_object_t *pNewLexicalEnvironment = ecma_alloc_object();
pNewLexicalEnvironment->IsLexicalEnvironment = true;
pNewLexicalEnvironment->u.LexicalEnvironment.Type = type;
@@ -123,10 +123,10 @@ ecma_CreateLexicalEnvironment(ecma_Object_t *pOuterLexicalEnvironment, /**< oute
pNewLexicalEnvironment->GCInfo.IsObjectValid = true;
pNewLexicalEnvironment->GCInfo.u.Refs = 1;
ecma_SetPointer( pNewLexicalEnvironment->u.LexicalEnvironment.pOuterReference, pOuterLexicalEnvironment);
ecma_set_pointer( pNewLexicalEnvironment->u.LexicalEnvironment.pOuterReference, pOuterLexicalEnvironment);
return pNewLexicalEnvironment;
} /* ecma_CreateLexicalEnvironment */
} /* ecma_create_lexical_environment */
/**
* Create internal property in an object and link it
@@ -134,22 +134,22 @@ ecma_CreateLexicalEnvironment(ecma_Object_t *pOuterLexicalEnvironment, /**< oute
*
* @return pointer to newly created property's des
*/
ecma_Property_t*
ecma_CreateInternalProperty(ecma_Object_t *pObject, /**< the object */
ecma_InternalPropertyId_t propertyId) /**< internal property identifier */
ecma_property_t*
ecma_create_internal_property(ecma_object_t *pObject, /**< the object */
ecma_internal_property_id_t propertyId) /**< internal property identifier */
{
ecma_Property_t *pNewProperty = ecma_AllocProperty();
ecma_property_t *pNewProperty = ecma_alloc_property();
pNewProperty->Type = ECMA_PROPERTY_INTERNAL;
ecma_SetPointer( pNewProperty->pNextProperty, ecma_GetPointer( pObject->pProperties));
ecma_SetPointer( pObject->pProperties, pNewProperty);
ecma_set_pointer( pNewProperty->pNextProperty, ecma_get_pointer( pObject->pProperties));
ecma_set_pointer( pObject->pProperties, pNewProperty);
pNewProperty->u.InternalProperty.InternalPropertyType = propertyId;
pNewProperty->u.InternalProperty.Value = ECMA_NULL_POINTER;
return pNewProperty;
} /* ecma_CreateInternalProperty */
} /* ecma_create_internal_property */
/**
* Find internal property in the object's property set.
@@ -157,18 +157,18 @@ ecma_CreateInternalProperty(ecma_Object_t *pObject, /**< the object */
* @return pointer to the property, if it is found,
* NULL - otherwise.
*/
ecma_Property_t*
ecma_FindInternalProperty(ecma_Object_t *pObject, /**< object descriptor */
ecma_InternalPropertyId_t propertyId) /**< internal property identifier */
ecma_property_t*
ecma_find_internal_property(ecma_object_t *pObject, /**< object descriptor */
ecma_internal_property_id_t propertyId) /**< internal property identifier */
{
JERRY_ASSERT( pObject != NULL );
JERRY_ASSERT( propertyId != ECMA_INTERNAL_PROPERTY_PROTOTYPE
&& propertyId != ECMA_INTERNAL_PROPERTY_EXTENSIBLE );
for ( ecma_Property_t *pProperty = ecma_GetPointer( pObject->pProperties);
for ( ecma_property_t *pProperty = ecma_get_pointer( pObject->pProperties);
pProperty != NULL;
pProperty = ecma_GetPointer( pProperty->pNextProperty) )
pProperty = ecma_get_pointer( pProperty->pNextProperty) )
{
if ( pProperty->Type == ECMA_PROPERTY_INTERNAL )
{
@@ -180,7 +180,7 @@ ecma_FindInternalProperty(ecma_Object_t *pObject, /**< object descriptor */
}
return NULL;
} /* ecma_FindInternalProperty */
} /* ecma_find_internal_property */
/**
* Get an internal property.
@@ -190,16 +190,16 @@ ecma_FindInternalProperty(ecma_Object_t *pObject, /**< object descriptor */
*
* @return pointer to the property
*/
ecma_Property_t*
ecma_GetInternalProperty(ecma_Object_t *pObject, /**< object descriptor */
ecma_InternalPropertyId_t propertyId) /**< internal property identifier */
ecma_property_t*
ecma_get_internal_property(ecma_object_t *pObject, /**< object descriptor */
ecma_internal_property_id_t propertyId) /**< internal property identifier */
{
ecma_Property_t *pProperty = ecma_FindInternalProperty( pObject, propertyId);
ecma_property_t *pProperty = ecma_find_internal_property( pObject, propertyId);
JERRY_ASSERT( pProperty != NULL );
return pProperty;
} /* ecma_GetInternalProperty */
} /* ecma_get_internal_property */
/**
* Create named data property with given name, attributes and undefined value
@@ -207,32 +207,32 @@ ecma_GetInternalProperty(ecma_Object_t *pObject, /**< object descriptor */
*
* @return pointer to newly created property
*/
ecma_Property_t*
ecma_CreateNamedProperty(ecma_Object_t *obj_p, /**< object */
ecma_Char_t *name_p, /**< property name */
ecma_PropertyWritableValue_t writable, /**< 'writable' attribute */
ecma_PropertyEnumerableValue_t enumerable, /**< 'enumerable' attribute */
ecma_PropertyConfigurableValue_t configurable) /**< 'configurable' attribute */
ecma_property_t*
ecma_create_named_property(ecma_object_t *obj_p, /**< object */
ecma_char_t *name_p, /**< property name */
ecma_property_writable_value_t writable, /**< 'writable' attribute */
ecma_property_enumerable_value_t enumerable, /**< 'enumerable' attribute */
ecma_property_configurable_value_t configurable) /**< 'configurable' attribute */
{
JERRY_ASSERT( obj_p != NULL && name_p != NULL );
ecma_Property_t *prop = ecma_AllocProperty();
ecma_property_t *prop = ecma_alloc_property();
prop->Type = ECMA_PROPERTY_NAMEDDATA;
ecma_SetPointer( prop->u.NamedDataProperty.pName, ecma_NewEcmaString( name_p));
ecma_set_pointer( prop->u.NamedDataProperty.pName, ecma_new_ecma_string( name_p));
prop->u.NamedDataProperty.Writable = writable;
prop->u.NamedDataProperty.Enumerable = enumerable;
prop->u.NamedDataProperty.Configurable = configurable;
prop->u.NamedDataProperty.Value = ecma_MakeSimpleValue( ECMA_SIMPLE_VALUE_UNDEFINED);
prop->u.NamedDataProperty.Value = ecma_make_simple_value( ECMA_SIMPLE_VALUE_UNDEFINED);
ecma_SetPointer( prop->pNextProperty, ecma_GetPointer( obj_p->pProperties));
ecma_SetPointer( obj_p->pProperties, prop);
ecma_set_pointer( prop->pNextProperty, ecma_get_pointer( obj_p->pProperties));
ecma_set_pointer( obj_p->pProperties, prop);
return prop;
} /* ecma_CreateNamedProperty */
} /* ecma_create_named_property */
/**
* Find named data property or named access property in specified object.
@@ -240,25 +240,25 @@ ecma_CreateNamedProperty(ecma_Object_t *obj_p, /**< object */
* @return pointer to the property, if it is found,
* NULL - otherwise.
*/
ecma_Property_t*
ecma_FindNamedProperty(ecma_Object_t *obj_p, /**< object to find property in */
ecma_Char_t *name_p) /**< property's name */
ecma_property_t*
ecma_find_named_property(ecma_object_t *obj_p, /**< object to find property in */
ecma_char_t *name_p) /**< property's name */
{
JERRY_ASSERT( obj_p != NULL );
JERRY_ASSERT( name_p != NULL );
for ( ecma_Property_t *property_p = ecma_GetPointer( obj_p->pProperties);
for ( ecma_property_t *property_p = ecma_get_pointer( obj_p->pProperties);
property_p != NULL;
property_p = ecma_GetPointer( property_p->pNextProperty) )
property_p = ecma_get_pointer( property_p->pNextProperty) )
{
ecma_ArrayFirstChunk_t *property_name_p;
ecma_array_first_chunk_t *property_name_p;
if ( property_p->Type == ECMA_PROPERTY_NAMEDDATA )
{
property_name_p = ecma_GetPointer( property_p->u.NamedDataProperty.pName);
property_name_p = ecma_get_pointer( property_p->u.NamedDataProperty.pName);
} else if ( property_p->Type == ECMA_PROPERTY_NAMEDACCESSOR )
{
property_name_p = ecma_GetPointer( property_p->u.NamedAccessorProperty.pName);
property_name_p = ecma_get_pointer( property_p->u.NamedAccessorProperty.pName);
} else
{
continue;
@@ -266,14 +266,14 @@ ecma_FindNamedProperty(ecma_Object_t *obj_p, /**< object to find property in */
JERRY_ASSERT( property_name_p != NULL );
if ( ecma_CompareZtStringToEcmaString( name_p, property_name_p) )
if ( ecma_compare_zt_string_to_ecma_string( name_p, property_name_p) )
{
return property_p;
}
}
return NULL;
} /* ecma_FindNamedProperty */
} /* ecma_find_named_property */
/**
* Get named data property or named access property in specified object.
@@ -284,19 +284,19 @@ ecma_FindNamedProperty(ecma_Object_t *obj_p, /**< object to find property in */
* @return pointer to the property, if it is found,
* NULL - otherwise.
*/
ecma_Property_t*
ecma_GetNamedProperty(ecma_Object_t *obj_p, /**< object to find property in */
ecma_Char_t *name_p) /**< property's name */
ecma_property_t*
ecma_get_named_property(ecma_object_t *obj_p, /**< object to find property in */
ecma_char_t *name_p) /**< property's name */
{
JERRY_ASSERT( obj_p != NULL );
JERRY_ASSERT( name_p != NULL );
ecma_Property_t *property_p = ecma_FindNamedProperty( obj_p, name_p);
ecma_property_t *property_p = ecma_find_named_property( obj_p, name_p);
JERRY_ASSERT( property_p != NULL );
return property_p;
} /* ecma_GetNamedProperty */
} /* ecma_get_named_property */
/**
* Get named data property in specified object.
@@ -307,69 +307,69 @@ ecma_GetNamedProperty(ecma_Object_t *obj_p, /**< object to find property in */
* @return pointer to the property, if it is found,
* NULL - otherwise.
*/
ecma_Property_t*
ecma_GetNamedDataProperty(ecma_Object_t *obj_p, /**< object to find property in */
ecma_Char_t *name_p) /**< property's name */
ecma_property_t*
ecma_get_named_data_property(ecma_object_t *obj_p, /**< object to find property in */
ecma_char_t *name_p) /**< property's name */
{
JERRY_ASSERT( obj_p != NULL );
JERRY_ASSERT( name_p != NULL );
ecma_Property_t *property_p = ecma_FindNamedProperty( obj_p, name_p);
ecma_property_t *property_p = ecma_find_named_property( obj_p, name_p);
JERRY_ASSERT( property_p != NULL && property_p->Type == ECMA_PROPERTY_NAMEDDATA );
return property_p;
} /* ecma_GetNamedDataProperty */
} /* ecma_get_named_data_property */
/**
* Free the named data property and values it references.
*/
void
ecma_FreeNamedDataProperty( ecma_Property_t *pProperty) /**< the property */
ecma_free_named_data_property( ecma_property_t *pProperty) /**< the property */
{
JERRY_ASSERT( pProperty->Type == ECMA_PROPERTY_NAMEDDATA );
ecma_FreeArray( ecma_GetPointer( pProperty->u.NamedDataProperty.pName));
ecma_FreeValue( pProperty->u.NamedDataProperty.Value);
ecma_free_array( ecma_get_pointer( pProperty->u.NamedDataProperty.pName));
ecma_free_value( pProperty->u.NamedDataProperty.Value);
ecma_DeallocProperty( pProperty);
} /* ecma_FreeNamedDataProperty */
ecma_dealloc_property( pProperty);
} /* ecma_free_named_data_property */
/**
* Free the named accessor property and values it references.
*/
void
ecma_FreeNamedAccessorProperty( ecma_Property_t *pProperty) /**< the property */
ecma_free_named_accessor_property( ecma_property_t *pProperty) /**< the property */
{
JERRY_ASSERT( pProperty->Type == ECMA_PROPERTY_NAMEDACCESSOR );
ecma_FreeArray( ecma_GetPointer( pProperty->u.NamedAccessorProperty.pName));
ecma_free_array( ecma_get_pointer( pProperty->u.NamedAccessorProperty.pName));
ecma_Object_t *pGet = ecma_GetPointer(pProperty->u.NamedAccessorProperty.pGet);
ecma_Object_t *pSet = ecma_GetPointer(pProperty->u.NamedAccessorProperty.pSet);
ecma_object_t *pGet = ecma_get_pointer(pProperty->u.NamedAccessorProperty.pGet);
ecma_object_t *pSet = ecma_get_pointer(pProperty->u.NamedAccessorProperty.pSet);
if ( pGet != NULL )
{
ecma_DerefObject( pGet);
ecma_deref_object( pGet);
}
if ( pSet != NULL )
{
ecma_DerefObject( pSet);
ecma_deref_object( pSet);
}
ecma_DeallocProperty( pProperty);
} /* ecma_FreeNamedAccessorProperty */
ecma_dealloc_property( pProperty);
} /* ecma_free_named_accessor_property */
/**
* Free the internal property and values it references.
*/
void
ecma_FreeInternalProperty( ecma_Property_t *pProperty) /**< the property */
ecma_free_internal_property( ecma_property_t *pProperty) /**< the property */
{
JERRY_ASSERT( pProperty->Type == ECMA_PROPERTY_INTERNAL );
ecma_InternalPropertyId_t propertyId = pProperty->u.InternalProperty.InternalPropertyType;
ecma_internal_property_id_t propertyId = pProperty->u.InternalProperty.InternalPropertyType;
uint32_t propertyValue = pProperty->u.InternalProperty.Value;
switch ( propertyId )
@@ -378,58 +378,58 @@ ecma_FreeInternalProperty( ecma_Property_t *pProperty) /**< the property */
case ECMA_INTERNAL_PROPERTY_NUMBER_INDEXED_ARRAY_VALUES: /* an array */
case ECMA_INTERNAL_PROPERTY_STRING_INDEXED_ARRAY_VALUES: /* an array */
{
ecma_FreeArray( ecma_GetPointer( propertyValue));
ecma_free_array( ecma_get_pointer( propertyValue));
break;
}
case ECMA_INTERNAL_PROPERTY_SCOPE: /* a lexical environment */
case ECMA_INTERNAL_PROPERTY_BINDING_OBJECT: /* an object */
{
ecma_DerefObject( ecma_GetPointer( propertyValue));
ecma_deref_object( ecma_get_pointer( propertyValue));
break;
}
case ECMA_INTERNAL_PROPERTY_PROTOTYPE: /* the property's value is located in ecma_Object_t */
case ECMA_INTERNAL_PROPERTY_EXTENSIBLE: /* the property's value is located in ecma_Object_t */
case ECMA_INTERNAL_PROPERTY_PROTOTYPE: /* the property's value is located in ecma_object_t */
case ECMA_INTERNAL_PROPERTY_EXTENSIBLE: /* the property's value is located in ecma_object_t */
case ECMA_INTERNAL_PROPERTY_PROVIDE_THIS: /* a boolean flag */
{
break;
}
}
ecma_DeallocProperty( pProperty);
} /* ecma_FreeInternalProperty */
ecma_dealloc_property( pProperty);
} /* ecma_free_internal_property */
/**
* Free the property and values it references.
*/
void
ecma_FreeProperty(ecma_Property_t *prop_p) /**< property */
ecma_free_property(ecma_property_t *prop_p) /**< property */
{
switch ( (ecma_PropertyType_t) prop_p->Type )
switch ( (ecma_property_type_t) prop_p->Type )
{
case ECMA_PROPERTY_NAMEDDATA:
{
ecma_FreeNamedDataProperty( prop_p);
ecma_free_named_data_property( prop_p);
break;
}
case ECMA_PROPERTY_NAMEDACCESSOR:
{
ecma_FreeNamedAccessorProperty( prop_p);
ecma_free_named_accessor_property( prop_p);
break;
}
case ECMA_PROPERTY_INTERNAL:
{
ecma_FreeInternalProperty( prop_p);
ecma_free_internal_property( prop_p);
break;
}
}
} /* ecma_FreeProperty */
} /* ecma_free_property */
/**
* Delete the object's property.
@@ -437,25 +437,25 @@ ecma_FreeProperty(ecma_Property_t *prop_p) /**< property */
* Warning: specified property must be owned by specified object.
*/
void
ecma_DeleteProperty(ecma_Object_t *obj_p, /**< object */
ecma_Property_t *prop_p) /**< property */
ecma_delete_property(ecma_object_t *obj_p, /**< object */
ecma_property_t *prop_p) /**< property */
{
for ( ecma_Property_t *cur_prop_p = ecma_GetPointer( obj_p->pProperties), *prev_prop_p = NULL, *next_prop_p;
for ( ecma_property_t *cur_prop_p = ecma_get_pointer( obj_p->pProperties), *prev_prop_p = NULL, *next_prop_p;
cur_prop_p != NULL;
prev_prop_p = cur_prop_p, cur_prop_p = next_prop_p )
{
next_prop_p = ecma_GetPointer( cur_prop_p->pNextProperty);
next_prop_p = ecma_get_pointer( cur_prop_p->pNextProperty);
if ( cur_prop_p == prop_p )
{
ecma_FreeProperty( prop_p);
ecma_free_property( prop_p);
if ( prev_prop_p == NULL )
{
ecma_SetPointer( obj_p->pProperties, next_prop_p);
ecma_set_pointer( obj_p->pProperties, next_prop_p);
} else
{
ecma_SetPointer( prev_prop_p->pNextProperty, next_prop_p);
ecma_set_pointer( prev_prop_p->pNextProperty, next_prop_p);
}
return;
@@ -463,62 +463,62 @@ ecma_DeleteProperty(ecma_Object_t *obj_p, /**< object */
}
JERRY_UNREACHABLE();
} /* ecma_DeleteProperty */
} /* ecma_delete_property */
/**
* Allocate new ecma-string and fill it with characters from specified buffer
*
* @return Pointer to first chunk of an array, containing allocated string
*/
ecma_ArrayFirstChunk_t*
ecma_NewEcmaString(const ecma_Char_t *pString) /**< zero-terminated string of ecma-characters */
ecma_array_first_chunk_t*
ecma_new_ecma_string(const ecma_char_t *pString) /**< zero-terminated string of ecma-characters */
{
ecma_Length_t length = 0;
ecma_length_t length = 0;
/*
* TODO: Do not precalculate length.
*/
if ( pString != NULL )
{
const ecma_Char_t *iter_p = pString;
const ecma_char_t *iter_p = pString;
while ( *iter_p++ )
{
length++;
}
}
ecma_ArrayFirstChunk_t *pStringFirstChunk = ecma_AllocArrayFirstChunk();
ecma_array_first_chunk_t *pStringFirstChunk = ecma_alloc_array_first_chunk();
pStringFirstChunk->Header.UnitNumber = length;
uint8_t *copyPointer = (uint8_t*) pString;
size_t charsLeft = length;
size_t charsToCopy = JERRY_MIN( length, sizeof (pStringFirstChunk->Data) / sizeof (ecma_Char_t));
__memcpy(pStringFirstChunk->Data, copyPointer, charsToCopy * sizeof (ecma_Char_t));
size_t charsToCopy = JERRY_MIN( length, sizeof (pStringFirstChunk->Data) / sizeof (ecma_char_t));
__memcpy(pStringFirstChunk->Data, copyPointer, charsToCopy * sizeof (ecma_char_t));
charsLeft -= charsToCopy;
copyPointer += charsToCopy * sizeof (ecma_Char_t);
copyPointer += charsToCopy * sizeof (ecma_char_t);
ecma_ArrayNonFirstChunk_t *pStringNonFirstChunk;
ecma_array_non_first_chunk_t *pStringNonFirstChunk;
JERRY_STATIC_ASSERT( ECMA_POINTER_FIELD_WIDTH <= sizeof(uint16_t) * JERRY_BITSINBYTE );
uint16_t *pNextChunkCompressedPointer = &pStringFirstChunk->Header.pNextChunk;
while ( charsLeft > 0 )
{
pStringNonFirstChunk = ecma_AllocArrayNonFirstChunk();
pStringNonFirstChunk = ecma_alloc_array_non_first_chunk();
size_t charsToCopy = JERRY_MIN( charsLeft, sizeof (pStringNonFirstChunk->Data) / sizeof (ecma_Char_t));
__memcpy(pStringNonFirstChunk->Data, copyPointer, charsToCopy * sizeof (ecma_Char_t));
size_t charsToCopy = JERRY_MIN( charsLeft, sizeof (pStringNonFirstChunk->Data) / sizeof (ecma_char_t));
__memcpy(pStringNonFirstChunk->Data, copyPointer, charsToCopy * sizeof (ecma_char_t));
charsLeft -= charsToCopy;
copyPointer += charsToCopy * sizeof (ecma_Char_t);
copyPointer += charsToCopy * sizeof (ecma_char_t);
ecma_SetPointer( *pNextChunkCompressedPointer, pStringNonFirstChunk);
ecma_set_pointer( *pNextChunkCompressedPointer, pStringNonFirstChunk);
pNextChunkCompressedPointer = &pStringNonFirstChunk->pNextChunk;
}
*pNextChunkCompressedPointer = ECMA_NULL_POINTER;
return pStringFirstChunk;
} /* ecma_NewEcmaString */
} /* ecma_new_ecma_string */
/**
* Copy ecma-string's contents to a buffer.
@@ -530,78 +530,78 @@ ecma_NewEcmaString(const ecma_Char_t *pString) /**< zero-terminated string of ec
* to hold the string's content (in case size of buffer is insuficcient).
*/
ssize_t
ecma_CopyEcmaStringCharsToBuffer(ecma_ArrayFirstChunk_t *pFirstChunk, /**< first chunk of ecma-string */
ecma_copy_ecma_string_chars_to_buffer(ecma_array_first_chunk_t *pFirstChunk, /**< first chunk of ecma-string */
uint8_t *pBuffer, /**< destination buffer */
size_t bufferSize) /**< size of buffer */
{
ecma_Length_t stringLength = pFirstChunk->Header.UnitNumber;
size_t requiredBufferSize = sizeof (ecma_Length_t) + sizeof (ecma_Char_t) * stringLength;
ecma_length_t stringLength = pFirstChunk->Header.UnitNumber;
size_t requiredBufferSize = sizeof (ecma_length_t) + sizeof (ecma_char_t) * stringLength;
if ( requiredBufferSize < bufferSize )
{
return -(ssize_t) requiredBufferSize;
}
*(ecma_Length_t*) pBuffer = stringLength;
*(ecma_length_t*) pBuffer = stringLength;
size_t charsLeft = stringLength;
uint8_t *destPointer = pBuffer + sizeof (ecma_Length_t);
size_t copyChunkChars = JERRY_MIN(sizeof (pFirstChunk->Data) / sizeof (ecma_Char_t),
uint8_t *destPointer = pBuffer + sizeof (ecma_length_t);
size_t copyChunkChars = JERRY_MIN(sizeof (pFirstChunk->Data) / sizeof (ecma_char_t),
charsLeft);
__memcpy( destPointer, pFirstChunk->Data, copyChunkChars * sizeof (ecma_Char_t));
destPointer += copyChunkChars * sizeof (ecma_Char_t);
__memcpy( destPointer, pFirstChunk->Data, copyChunkChars * sizeof (ecma_char_t));
destPointer += copyChunkChars * sizeof (ecma_char_t);
charsLeft -= copyChunkChars;
ecma_ArrayNonFirstChunk_t *pNonFirstChunk = ecma_GetPointer( pFirstChunk->Header.pNextChunk);
ecma_array_non_first_chunk_t *pNonFirstChunk = ecma_get_pointer( pFirstChunk->Header.pNextChunk);
while ( charsLeft > 0 )
{
JERRY_ASSERT( charsLeft < stringLength );
copyChunkChars = JERRY_MIN(sizeof (pNonFirstChunk->Data) / sizeof (ecma_Char_t),
copyChunkChars = JERRY_MIN(sizeof (pNonFirstChunk->Data) / sizeof (ecma_char_t),
charsLeft);
__memcpy( destPointer, pNonFirstChunk->Data, copyChunkChars * sizeof (ecma_Char_t));
destPointer += copyChunkChars * sizeof (ecma_Char_t);
__memcpy( destPointer, pNonFirstChunk->Data, copyChunkChars * sizeof (ecma_char_t));
destPointer += copyChunkChars * sizeof (ecma_char_t);
charsLeft -= copyChunkChars;
pNonFirstChunk = ecma_GetPointer( pNonFirstChunk->pNextChunk);
pNonFirstChunk = ecma_get_pointer( pNonFirstChunk->pNextChunk);
}
return (ssize_t) requiredBufferSize;
} /* ecma_CopyEcmaStringCharsToBuffer */
} /* ecma_copy_ecma_string_chars_to_buffer */
/**
* Duplicate an ecma-string.
*
* @return pointer to new ecma-string's first chunk
*/
ecma_ArrayFirstChunk_t*
ecma_DuplicateEcmaString( ecma_ArrayFirstChunk_t *pFirstChunk) /**< first chunk of string to duplicate */
ecma_array_first_chunk_t*
ecma_duplicate_ecma_string( ecma_array_first_chunk_t *pFirstChunk) /**< first chunk of string to duplicate */
{
JERRY_ASSERT( pFirstChunk != NULL );
ecma_ArrayFirstChunk_t *pFirstChunkCopy = ecma_AllocArrayFirstChunk();
__memcpy( pFirstChunkCopy, pFirstChunk, sizeof (ecma_ArrayFirstChunk_t));
ecma_array_first_chunk_t *pFirstChunkCopy = ecma_alloc_array_first_chunk();
__memcpy( pFirstChunkCopy, pFirstChunk, sizeof (ecma_array_first_chunk_t));
ecma_ArrayNonFirstChunk_t *pNonFirstChunk, *pNonFirstChunkCopy;
pNonFirstChunk = ecma_GetPointer( pFirstChunk->Header.pNextChunk);
ecma_array_non_first_chunk_t *pNonFirstChunk, *pNonFirstChunkCopy;
pNonFirstChunk = ecma_get_pointer( pFirstChunk->Header.pNextChunk);
uint16_t *pNextPointer = &pFirstChunkCopy->Header.pNextChunk;
while ( pNonFirstChunk != NULL )
{
pNonFirstChunkCopy = ecma_AllocArrayNonFirstChunk();
ecma_SetPointer( *pNextPointer, pNonFirstChunkCopy);
pNonFirstChunkCopy = ecma_alloc_array_non_first_chunk();
ecma_set_pointer( *pNextPointer, pNonFirstChunkCopy);
pNextPointer = &pNonFirstChunkCopy->pNextChunk;
__memcpy( pNonFirstChunkCopy, pNonFirstChunk, sizeof (ecma_ArrayNonFirstChunk_t));
__memcpy( pNonFirstChunkCopy, pNonFirstChunk, sizeof (ecma_array_non_first_chunk_t));
pNonFirstChunk = ecma_GetPointer( pNonFirstChunk->pNextChunk);
pNonFirstChunk = ecma_get_pointer( pNonFirstChunk->pNextChunk);
}
*pNextPointer = ECMA_NULL_POINTER;
return pFirstChunkCopy;
} /* ecma_DuplicateEcmaString */
} /* ecma_duplicate_ecma_string */
/**
* Compare zero-terminated string to ecma-string
@@ -610,11 +610,11 @@ ecma_DuplicateEcmaString( ecma_ArrayFirstChunk_t *pFirstChunk) /**< first chunk
* false - otherwise.
*/
bool
ecma_CompareEcmaStringToEcmaString(const ecma_ArrayFirstChunk_t *string1_p, /* ecma-string */
const ecma_ArrayFirstChunk_t *string2_p) /* ecma-string */
ecma_compare_ecma_string_to_ecma_string(const ecma_array_first_chunk_t *string1_p, /* ecma-string */
const ecma_array_first_chunk_t *string2_p) /* ecma-string */
{
JERRY_UNIMPLEMENTED_REF_UNUSED_VARS( string1_p, string2_p);
} /* ecma_CompareEcmaStringToEcmaString */
} /* ecma_compare_ecma_string_to_ecma_string */
/**
* Compare zero-terminated string to ecma-string
@@ -623,22 +623,22 @@ ecma_CompareEcmaStringToEcmaString(const ecma_ArrayFirstChunk_t *string1_p, /* e
* false - otherwise.
*/
bool
ecma_CompareZtStringToEcmaString(const ecma_Char_t *pString, /**< zero-terminated string */
const ecma_ArrayFirstChunk_t *pEcmaString) /* ecma-string */
ecma_compare_zt_string_to_ecma_string(const ecma_char_t *pString, /**< zero-terminated string */
const ecma_array_first_chunk_t *pEcmaString) /* ecma-string */
{
JERRY_ASSERT( pString != NULL );
JERRY_ASSERT( pEcmaString != NULL );
const ecma_Char_t *str_iter_p = pString;
ecma_Length_t ecma_str_len = pEcmaString->Header.UnitNumber;
const ecma_Char_t *current_chunk_chars_cur = (ecma_Char_t*) pEcmaString->Data,
*current_chunk_chars_end = (ecma_Char_t*) (pEcmaString->Data
const ecma_char_t *str_iter_p = pString;
ecma_length_t ecma_str_len = pEcmaString->Header.UnitNumber;
const ecma_char_t *current_chunk_chars_cur = (ecma_char_t*) pEcmaString->Data,
*current_chunk_chars_end = (ecma_char_t*) (pEcmaString->Data
+ sizeof(pEcmaString->Data));
JERRY_STATIC_ASSERT( ECMA_POINTER_FIELD_WIDTH <= sizeof(uint16_t) * JERRY_BITSINBYTE );
const uint16_t *next_chunk_compressed_pointer_p = &pEcmaString->Header.pNextChunk;
for ( ecma_Length_t str_index = 0;
for ( ecma_length_t str_index = 0;
str_index < ecma_str_len;
str_index++, str_iter_p++, current_chunk_chars_cur++ )
{
@@ -647,12 +647,12 @@ ecma_CompareZtStringToEcmaString(const ecma_Char_t *pString, /**< zero-terminate
if ( current_chunk_chars_cur == current_chunk_chars_end )
{
/* switching to next chunk */
ecma_ArrayNonFirstChunk_t *next_chunk_p = ecma_GetPointer( *next_chunk_compressed_pointer_p);
ecma_array_non_first_chunk_t *next_chunk_p = ecma_get_pointer( *next_chunk_compressed_pointer_p);
JERRY_ASSERT( next_chunk_p != NULL );
current_chunk_chars_cur = (ecma_Char_t*) pEcmaString->Data;
current_chunk_chars_end = (ecma_Char_t*) (next_chunk_p->Data + sizeof(next_chunk_p->Data));
current_chunk_chars_cur = (ecma_char_t*) pEcmaString->Data;
current_chunk_chars_end = (ecma_char_t*) (next_chunk_p->Data + sizeof(next_chunk_p->Data));
next_chunk_compressed_pointer_p = &next_chunk_p->pNextChunk;
}
@@ -676,29 +676,29 @@ ecma_CompareZtStringToEcmaString(const ecma_Char_t *pString, /**< zero-terminate
* Otherwise zero-terminated string is longer.
*/
return ( *str_iter_p == 0 );
} /* ecma_CompareZtStringToEcmaString */
} /* ecma_compare_zt_string_to_ecma_string */
/**
* Free all chunks of an array
*/
void
ecma_FreeArray( ecma_ArrayFirstChunk_t *pFirstChunk) /**< first chunk of the array */
ecma_free_array( ecma_array_first_chunk_t *pFirstChunk) /**< first chunk of the array */
{
JERRY_ASSERT( pFirstChunk != NULL );
ecma_ArrayNonFirstChunk_t *pNonFirstChunk = ecma_GetPointer( pFirstChunk->Header.pNextChunk);
ecma_array_non_first_chunk_t *pNonFirstChunk = ecma_get_pointer( pFirstChunk->Header.pNextChunk);
ecma_DeallocArrayFirstChunk( pFirstChunk);
ecma_dealloc_array_first_chunk( pFirstChunk);
while ( pNonFirstChunk != NULL )
{
ecma_ArrayNonFirstChunk_t *pNextChunk = ecma_GetPointer( pNonFirstChunk->pNextChunk);
ecma_array_non_first_chunk_t *pNextChunk = ecma_get_pointer( pNonFirstChunk->pNextChunk);
ecma_DeallocArrayNonFirstChunk( pNonFirstChunk);
ecma_dealloc_array_non_first_chunk( pNonFirstChunk);
pNonFirstChunk = pNextChunk;
}
} /* ecma_FreeArray */
} /* ecma_free_array */
/**
* @}
src/libecmaobjects/ecma-helpers.h
+46 -46
View File
@@ -25,73 +25,73 @@
#include "ecma-globals.h"
extern uintptr_t ecma_CompressPointer(void *pointer);
extern void* ecma_DecompressPointer(uintptr_t compressedPointer);
extern uintptr_t ecma_compress_pointer(void *pointer);
extern void* ecma_decompress_pointer(uintptr_t compressedPointer);
/**
* Get value of pointer from specified compressed pointer field.
*/
#define ecma_GetPointer( field) \
ecma_DecompressPointer( field)
#define ecma_get_pointer( field) \
ecma_decompress_pointer( field)
/**
* Set value of compressed pointer field so that it will correspond
* to specified nonCompressedPointer.
*/
#define ecma_SetPointer( field, nonCompressedPointer) \
(field) = ecma_CompressPointer( nonCompressedPointer) & ( ( 1u << ECMA_POINTER_FIELD_WIDTH ) - 1)
#define ecma_set_pointer( field, nonCompressedPointer) \
(field) = ecma_compress_pointer( nonCompressedPointer) & ( ( 1u << ECMA_POINTER_FIELD_WIDTH ) - 1)
/* ecma-helpers-value.c */
extern bool ecma_IsValueUndefined( ecma_Value_t value);
extern bool ecma_IsValueNull( ecma_Value_t value);
extern bool ecma_IsValueBoolean( ecma_Value_t value);
extern bool ecma_IsValueTrue( ecma_Value_t value);
extern bool ecma_is_value_undefined( ecma_value_t value);
extern bool ecma_is_value_null( ecma_value_t value);
extern bool ecma_is_value_boolean( ecma_value_t value);
extern bool ecma_is_value_true( ecma_value_t value);
extern ecma_Value_t ecma_MakeSimpleValue( ecma_SimpleValue_t value);
extern ecma_Value_t ecma_MakeNumberValue( ecma_Number_t* num_p);
extern ecma_Value_t ecma_make_string_value( ecma_ArrayFirstChunk_t* ecma_string_p);
extern ecma_Value_t ecma_MakeObjectValue( ecma_Object_t* object_p);
extern ecma_Value_t ecma_CopyValue( const ecma_Value_t value);
extern void ecma_FreeValue( const ecma_Value_t value);
extern ecma_value_t ecma_make_simple_value( ecma_simple_value_t value);
extern ecma_value_t ecma_make_number_value( ecma_number_t* num_p);
extern ecma_value_t ecma_make_string_value( ecma_array_first_chunk_t* ecma_string_p);
extern ecma_value_t ecma_make_object_value( ecma_object_t* object_p);
extern ecma_value_t ecma_copy_value( const ecma_value_t value);
extern void ecma_free_value( const ecma_value_t value);
extern ecma_CompletionValue_t ecma_MakeCompletionValue( ecma_CompletionType_t type, ecma_Value_t value, uint8_t target);
extern ecma_CompletionValue_t ecma_MakeThrowValue( ecma_Object_t *exception_p);
extern ecma_CompletionValue_t ecma_make_empty_completion_value( void);
extern ecma_CompletionValue_t ecma_copy_completion_value( ecma_CompletionValue_t value);
extern void ecma_free_completion_value( ecma_CompletionValue_t completion_value);
extern ecma_completion_value_t ecma_make_completion_value( ecma_completion_type_t type, ecma_value_t value, uint8_t target);
extern ecma_completion_value_t ecma_make_throw_value( ecma_object_t *exception_p);
extern ecma_completion_value_t ecma_make_empty_completion_value( void);
extern ecma_completion_value_t ecma_copy_completion_value( ecma_completion_value_t value);
extern void ecma_free_completion_value( ecma_completion_value_t completion_value);
extern bool ecma_is_completion_value_normal( ecma_CompletionValue_t value);
extern bool ecma_is_completion_value_throw( ecma_CompletionValue_t value);
extern bool ecma_is_completion_value_normal_simple_value( ecma_CompletionValue_t value, ecma_SimpleValue_t simple_value);
extern bool ecma_IsCompletionValueNormalFalse( ecma_CompletionValue_t value);
extern bool ecma_IsCompletionValueNormalTrue( ecma_CompletionValue_t value);
extern bool ecma_is_completion_value_normal( ecma_completion_value_t value);
extern bool ecma_is_completion_value_throw( ecma_completion_value_t value);
extern bool ecma_is_completion_value_normal_simple_value( ecma_completion_value_t value, ecma_simple_value_t simple_value);
extern bool ecma_is_completion_value_normal_false( ecma_completion_value_t value);
extern bool ecma_is_completion_value_normal_true( ecma_completion_value_t value);
extern ecma_Object_t* ecma_CreateObject( ecma_Object_t *pPrototypeObject, bool isExtensible);
extern ecma_Object_t* ecma_CreateLexicalEnvironment( ecma_Object_t *pOuterLexicalEnvironment, ecma_LexicalEnvironmentType_t type);
extern ecma_object_t* ecma_create_object( ecma_object_t *pPrototypeObject, bool isExtensible);
extern ecma_object_t* ecma_create_lexical_environment( ecma_object_t *pOuterLexicalEnvironment, ecma_lexical_environment_type_t type);
/* ecma-helpers.c */
extern ecma_Property_t* ecma_CreateInternalProperty(ecma_Object_t *pObject, ecma_InternalPropertyId_t propertyId);
extern ecma_Property_t* ecma_FindInternalProperty(ecma_Object_t *pObject, ecma_InternalPropertyId_t propertyId);
extern ecma_Property_t* ecma_GetInternalProperty(ecma_Object_t *pObject, ecma_InternalPropertyId_t propertyId);
extern ecma_property_t* ecma_create_internal_property(ecma_object_t *pObject, ecma_internal_property_id_t propertyId);
extern ecma_property_t* ecma_find_internal_property(ecma_object_t *pObject, ecma_internal_property_id_t propertyId);
extern ecma_property_t* ecma_get_internal_property(ecma_object_t *pObject, ecma_internal_property_id_t propertyId);
extern ecma_Property_t *ecma_CreateNamedProperty(ecma_Object_t *obj_p, ecma_Char_t *name_p, ecma_PropertyWritableValue_t writable, ecma_PropertyEnumerableValue_t enumerable, ecma_PropertyConfigurableValue_t configurable);
extern ecma_Property_t *ecma_FindNamedProperty(ecma_Object_t *obj_p, ecma_Char_t *name_p);
extern ecma_Property_t *ecma_GetNamedProperty(ecma_Object_t *obj_p, ecma_Char_t *name_p);
extern ecma_Property_t *ecma_GetNamedDataProperty(ecma_Object_t *obj_p, ecma_Char_t *name_p);
extern ecma_property_t *ecma_create_named_property(ecma_object_t *obj_p, ecma_char_t *name_p, ecma_property_writable_value_t writable, ecma_property_enumerable_value_t enumerable, ecma_property_configurable_value_t configurable);
extern ecma_property_t *ecma_find_named_property(ecma_object_t *obj_p, ecma_char_t *name_p);
extern ecma_property_t *ecma_get_named_property(ecma_object_t *obj_p, ecma_char_t *name_p);
extern ecma_property_t *ecma_get_named_data_property(ecma_object_t *obj_p, ecma_char_t *name_p);
extern void ecma_FreeInternalProperty(ecma_Property_t *prop_p);
extern void ecma_FreeNamedDataProperty(ecma_Property_t *prop_p);
extern void ecma_FreeNamedAccessorProperty(ecma_Property_t *prop_p);
extern void ecma_FreeProperty(ecma_Property_t *prop_p);
extern void ecma_free_internal_property(ecma_property_t *prop_p);
extern void ecma_free_named_data_property(ecma_property_t *prop_p);
extern void ecma_free_named_accessor_property(ecma_property_t *prop_p);
extern void ecma_free_property(ecma_property_t *prop_p);
extern void ecma_DeleteProperty( ecma_Object_t *obj_p, ecma_Property_t *prop_p);
extern void ecma_delete_property( ecma_object_t *obj_p, ecma_property_t *prop_p);
extern ecma_ArrayFirstChunk_t* ecma_NewEcmaString( const ecma_Char_t *pString);
extern ssize_t ecma_CopyEcmaStringCharsToBuffer( ecma_ArrayFirstChunk_t *pFirstChunk, uint8_t *pBuffer, size_t bufferSize);
extern ecma_ArrayFirstChunk_t* ecma_DuplicateEcmaString( ecma_ArrayFirstChunk_t *pFirstChunk);
extern bool ecma_CompareZtStringToEcmaString( const ecma_Char_t *pString, const ecma_ArrayFirstChunk_t *pEcmaString);
extern bool ecma_CompareEcmaStringToEcmaString(const ecma_ArrayFirstChunk_t *string1_p, const ecma_ArrayFirstChunk_t *string2_p);
extern void ecma_FreeArray( ecma_ArrayFirstChunk_t *pFirstChunk);
extern ecma_array_first_chunk_t* ecma_new_ecma_string( const ecma_char_t *pString);
extern ssize_t ecma_copy_ecma_string_chars_to_buffer( ecma_array_first_chunk_t *pFirstChunk, uint8_t *pBuffer, size_t bufferSize);
extern ecma_array_first_chunk_t* ecma_duplicate_ecma_string( ecma_array_first_chunk_t *pFirstChunk);
extern bool ecma_compare_zt_string_to_ecma_string( const ecma_char_t *pString, const ecma_array_first_chunk_t *pEcmaString);
extern bool ecma_compare_ecma_string_to_ecma_string(const ecma_array_first_chunk_t *string1_p, const ecma_array_first_chunk_t *string2_p);
extern void ecma_free_array( ecma_array_first_chunk_t *pFirstChunk);
#endif /* !JERRY_ECMA_HELPERS_H */