diff --git a/src/liballocator/mem-allocator.c b/src/liballocator/mem-allocator.c index 50c38c4f7..7d9d795a1 100644 --- a/src/liballocator/mem-allocator.c +++ b/src/liballocator/mem-allocator.c @@ -21,7 +21,6 @@ #include "mem-allocator.h" #include "mem-heap.h" #include "mem-poolman.h" -#include "ctx-manager.h" /** * Area for heap diff --git a/src/libecmaobjects/ctx-manager.c b/src/libecmaobjects/ctx-manager.c deleted file mode 100644 index 488ec509d..000000000 --- a/src/libecmaobjects/ctx-manager.c +++ /dev/null @@ -1,560 +0,0 @@ -/* Copyright 2014 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#include "ctx-manager.h" -#include "ctx-reference.h" -#include "globals.h" -#include "ecma-alloc.h" -#include "ecma-globals.h" -#include "ecma-conversion.h" -#include "ecma-gc.h" -#include "ecma-helpers.h" -#include "jerry-libc.h" -#include "mem-poolman.h" - -/** \addtogroup ctxman Context manager - * @{ - */ - -/** - * Maximum depth of varibles' context nestings stack. - * - * TODO: Move to configuration header. - */ -#define CTX_MAX_NUMBER_OF_VARIABLES_CONTEXTS 32 - -/** - * JerryScript needs at least one variables' context nesting. - */ -JERRY_STATIC_ASSERT( CTX_MAX_NUMBER_OF_VARIABLES_CONTEXTS >= 1 ); - -/** - * Description of a variables' context - */ -typedef struct -{ - /** - * Pointer to object, associated with 'this' keyword. - */ - ecma_Object_t *pThisBinding; - - /** - * Chain of lexical environments - */ - ecma_Object_t *pLexicalEnvironment; -} ctx_VariablesContext_t; - -/** - * Stack of variables' contexts. - */ -static ctx_VariablesContext_t ctx_Stack[ CTX_MAX_NUMBER_OF_VARIABLES_CONTEXTS ]; - -/** - * Current nestings' stack depth. - */ -static size_t ctx_ContextsNumber = 0; - -/** - * Current variables' context (context on the top of stack) - */ -#define ctx_CurrentContext ( ctx_Stack[ ctx_ContextsNumber - 1 ]) - -/** - * The global object - */ -ecma_Object_t* ctx_pGlobalObject; - -/** - * Get ecma-value from variable - * - * @return value descriptor - */ -static ecma_Value_t -ctx_GetValueDescriptorFromVariable( ctx_SyntacticReference_t *pVar) /**< variable */ -{ - /* - * TODO: - */ - (void)pVar; - JERRY_UNIMPLEMENTED(); -} /* ctx_GetValueDescriptorFromVariable */ - -/** - * Get ecma-value from variable - * - * @return value descriptor - */ -static void -ctx_SetValueDescriptorToVariable(ctx_SyntacticReference_t *pVar, /**< variable */ - ecma_Value_t value) /**< value descriptor */ -{ - /* - * TODO: - */ - (void)pVar; - (void)value; - JERRY_UNIMPLEMENTED(); -} /* ctx_SetValueDescriptorToVariable */ - -/** - * Allocate a context. - */ -static void -ctx_AllocContext( void) -{ - JERRY_ASSERT( ctx_ContextsNumber < CTX_MAX_NUMBER_OF_VARIABLES_CONTEXTS ); - - ctx_ContextsNumber++; -} /* ctx_AllocContext */ - -/** - * Create new lexical environment using specified object as binding object, - * setting provideThis to specified value. - * The lexical environment is inherited from current context's lexical environment. - */ -static void -ctx_CreateLexicalEnvironmentFromObject(ecma_Object_t *pObject, /**< pointer to bindingObject */ - bool provideThis) /**< value of 'provideThis' attribute */ -{ - ecma_Object_t *pNewLexicalEnvironment = ecma_CreateLexicalEnvironment(ctx_CurrentContext.pLexicalEnvironment, - true); - /* We don't change reference counter of ctx_CurrentContext.pLexicalEnvironment here, - because we remove one reference from ctx_CurrentContext, - and add one reference from pNewLexicalEnvironment */ - ctx_CurrentContext.pLexicalEnvironment = pNewLexicalEnvironment; - - ecma_Property_t *pProvideThisProperty = ecma_CreateInternalProperty( pNewLexicalEnvironment, ECMA_INTERNAL_PROPERTY_PROVIDE_THIS); - pProvideThisProperty->u.m_InternalProperty.m_Value = provideThis; - - ecma_Property_t *pBindingObjectProperty = ecma_CreateInternalProperty( pNewLexicalEnvironment, ECMA_INTERNAL_PROPERTY_BINDING_OBJECT); - - ecma_RefObject( pObject); - ecma_SetPointer( pBindingObjectProperty->u.m_InternalProperty.m_Value, pObject); -} /* ctx_CreateLexicalEnvironmentFromObject */ - -/** - * Initialize the global object. - */ -static void -ctx_InitGlobalObject( void) -{ - ctx_pGlobalObject = ecma_CreateObject( NULL, true); -} /* ctx_InitGlobalObject */ - -/** - * \addtogroup interface Context manager's interface - * @{ - */ - -/** - * Initialize context manager and global execution context. - */ -void -ctx_Init(void) -{ - JERRY_ASSERT( ctx_ContextsNumber == 0 ); - -#ifndef JERRY_NDEBUG - __memset( ctx_Stack, 0, sizeof (ctx_Stack)); -#endif /* !JERRY_NDEBUG */ - - ctx_InitGlobalObject(); - ctx_NewContextFromGlobalObject(); -} /* ctx_Init */ - -/** - * Create new variables' context using global object - * for ThisBinding and lexical environment. - */ -void -ctx_NewContextFromGlobalObject(void) -{ - ctx_AllocContext(); - - ecma_RefObject( ctx_pGlobalObject); - ctx_CurrentContext.pThisBinding = ctx_pGlobalObject; - - ctx_CurrentContext.pLexicalEnvironment = NULL; - ctx_CreateLexicalEnvironmentFromObject( ctx_pGlobalObject, false); - - JERRY_ASSERT( ctx_CurrentContext.pLexicalEnvironment != NULL ); -} /* ctx_NewContextFromGlobalObject */ - -/** - * Create new variables' context inheriting lexical environment from specified - * function's [[Scope]], and setting ThisBinding from pThisVar parameter - * (see also ECMA-262 5.1, 10.4.3). - */ -void -ctx_NewContextFromFunctionScope(ctx_SyntacticReference_t *pThisVar, /**< object for ThisBinding */ - ctx_SyntacticReference_t *pFunctionVar) /**< Function object */ -{ - ctx_AllocContext(); - - ecma_Value_t thisArgValue = ctx_GetValueDescriptorFromVariable( pThisVar); - ecma_Value_t functionArgValue = ctx_GetValueDescriptorFromVariable( pFunctionVar); - - ecma_Object_t *pThisBindingObject; - if ( thisArgValue.m_ValueType == ECMA_TYPE_SIMPLE - && ( thisArgValue.m_Value == ECMA_SIMPLE_VALUE_NULL - || thisArgValue.m_Value == ECMA_SIMPLE_VALUE_UNDEFINED ) ) - { - pThisBindingObject = ctx_pGlobalObject; - } else - { - pThisBindingObject = ecma_ToObject( thisArgValue); - } - - ecma_RefObject( pThisBindingObject); - ctx_CurrentContext.pThisBinding = pThisBindingObject; - - JERRY_ASSERT( functionArgValue.m_ValueType == ECMA_TYPE_OBJECT ); - ecma_Object_t *pFunctionObject = ecma_GetPointer( functionArgValue.m_Value); - - ecma_Property_t *pScopeProperty = ecma_GetInternalProperty( pFunctionObject, ECMA_INTERNAL_PROPERTY_SCOPE); - - ecma_Object_t *pScopeObject = ecma_GetPointer( pScopeProperty->u.m_InternalProperty.m_Value); - - ecma_RefObject( pScopeObject); - ecma_Object_t *pLexicalEnvironment = ecma_CreateLexicalEnvironment(pScopeObject, false); - - /* We don't change reference counter of ctx_CurrentContext.pLexicalEnvironment here, - because we remove one reference from ctx_CurrentContext, - and add one reference from pNewLexicalEnvironment */ - ctx_CurrentContext.pLexicalEnvironment = pLexicalEnvironment; -} /* ctx_NewContextFromFunctionScope */ - -/** - * Create new lexical environment using specified object as binding object, - * setting provideThis to specified value. - * The lexical environment is inherited from current context's lexical environment. - */ -void -ctx_NewLexicalEnvironmentFromObject(ctx_SyntacticReference_t *pObjectVar, /**< binding object */ - bool provideThis) /**< 'provideThis' attribute */ -{ - ecma_Object_t *pObject = ecma_ToObject( ctx_GetValueDescriptorFromVariable( pObjectVar)); - - ctx_CreateLexicalEnvironmentFromObject( pObject, provideThis); -} /* ctx_NewLexicalEnvironmentFromObject */ - -/** - * Exit from levelsToExit lexical environments (i.e. choose lexical environment - * that is levelsToExit outward current lexical environment as new current context's - * lexical environment). - */ -void -ctx_ExitLexicalEnvironments(uint32_t levelsToExit) /**< number of lexical environments - * to exit from */ -{ - JERRY_ASSERT( levelsToExit > 0 ); - - for ( uint32_t count = 0; - count < levelsToExit; - count++ ) - { - JERRY_ASSERT( ctx_CurrentContext.pLexicalEnvironment != NULL ); - - ecma_Object_t *pOuterLexicalEnvironment = ecma_GetPointer( ctx_CurrentContext.pLexicalEnvironment->u_Attributes.m_LexicalEnvironment.m_pOuterReference); - - ecma_DerefObject( ctx_CurrentContext.pLexicalEnvironment); - - ctx_CurrentContext.pLexicalEnvironment = pOuterLexicalEnvironment; - } - - JERRY_ASSERT( ctx_CurrentContext.pLexicalEnvironment != NULL ); -} /* ctx_ExitLexicalEnvironments */ - -/** - * Exit from levelsToExit variables' contexts (i.e. choose context - * that is levelsToExit from current context as new current context). - */ -void -ctx_ExitContexts(uint32_t levelsToExit) /**< number of contexts to exit from */ -{ - JERRY_ASSERT( levelsToExit > 0 ); - - for ( uint32_t count = 0; - count < levelsToExit; - count++ ) - { - JERRY_ASSERT( ctx_ContextsNumber > 0 ); - - ecma_DerefObject( ctx_CurrentContext.pThisBinding); - - while ( ctx_CurrentContext.pLexicalEnvironment != NULL ) - { - ecma_Object_t *pOuterLexicalEnvironment = - ecma_GetPointer(ctx_CurrentContext.pLexicalEnvironment-> - u_Attributes.m_LexicalEnvironment. - m_pOuterReference); - - ecma_DerefObject( ctx_CurrentContext.pLexicalEnvironment); - - ctx_CurrentContext.pLexicalEnvironment = pOuterLexicalEnvironment; - } - - ctx_ContextsNumber--; - } - - JERRY_ASSERT( ctx_ContextsNumber > 0 ); -} /* ctx_ExitContexts */ - -/** - * Create new variable with undefined value in the current lexical environment. - */ -void -ctx_NewVariable( ctx_SyntacticReference_t *pVar) /**< variable id */ -{ - ecma_Object_t *lexicalEnvironment = ctx_CurrentContext.pLexicalEnvironment; - - /* - * TODO: - */ - (void) pVar; - JERRY_UNIMPLEMENTED(); - - switch ( (ecma_LexicalEnvironmentType_t) lexicalEnvironment->u_Attributes.m_LexicalEnvironment.m_Type ) - { - case ECMA_LEXICAL_ENVIRONMENT_OBJECTBOUND: - { - ecma_Property_t *pBindingObjectProperty = ecma_FindInternalProperty(lexicalEnvironment, - ECMA_INTERNAL_PROPERTY_BINDING_OBJECT); - JERRY_ASSERT( pBindingObjectProperty != NULL ); - - ecma_Object_t *pBindingObject = ecma_GetPointer( pBindingObjectProperty->u.m_InternalProperty.m_Value); - JERRY_ASSERT( pBindingObject != NULL ); - - break; - } - - case ECMA_LEXICAL_ENVIRONMENT_DECLARATIVE: - { - break; - } - } -} /* ctx_NewVariable */ - -/** - * Delete specified variable. - */ -void -ctx_DeleteVariable( ctx_SyntacticReference_t *pVar) /**< variable id */ -{ - /* - * TODO: - */ - (void) pVar; - JERRY_UNIMPLEMENTED(); -} /* ctx_DeleteVariable */ - -/** - * Copy variable's/property's/array's element's value. - */ -void -ctx_CopyVariable(ctx_SyntacticReference_t *pVarFrom, /**< source variable */ - ctx_SyntacticReference_t *pVarTo) /**< destination variable */ -{ - ecma_Value_t sourceVariableValue = ctx_GetValueDescriptorFromVariable( pVarFrom); - ecma_Value_t destinationVariableValue; - - destinationVariableValue.m_ValueType = sourceVariableValue.m_ValueType; - switch ( (ecma_Type_t) sourceVariableValue.m_ValueType ) - { - case ECMA_TYPE_SIMPLE: - { - destinationVariableValue.m_Value = sourceVariableValue.m_Value; - break; - } - - case ECMA_TYPE_NUMBER: - { - ecma_Number_t *pNumberCopy = ecma_AllocNumber(); - __memcpy( pNumberCopy, - ecma_GetPointer( sourceVariableValue.m_Value), - sizeof (ecma_Number_t)); - ecma_SetPointer( destinationVariableValue.m_Value, pNumberCopy); - break; - } - - case ECMA_TYPE_STRING: - { - ecma_SetPointer(destinationVariableValue.m_Value, - ecma_DuplicateEcmaString( ecma_GetPointer( sourceVariableValue.m_Value))); - break; - } - - case ECMA_TYPE_OBJECT: - { - ecma_RefObject( ecma_GetPointer( sourceVariableValue.m_Value)); - destinationVariableValue.m_Value = sourceVariableValue.m_Value; - break; - } - - case ECMA_TYPE__COUNT: - { - JERRY_UNREACHABLE(); - } - } - - ctx_SetValueDescriptorToVariable( pVarTo, destinationVariableValue); -} /* ctx_CopyVariable */ - -/** - * Get type of value of specified variable/property/array's element. - */ -ecma_Type_t -ctx_GetVariableType(ctx_SyntacticReference_t *pVar) /**< variable */ -{ - ecma_Value_t variableValue = ctx_GetValueDescriptorFromVariable( pVar); - - return variableValue.m_ValueType; -} /* ctx_GetVariableType */ - -/** - * Get specified variable's/property's/array's element's value. - * - * @return number of bytes, actually copied to the buffer, if variable value was copied successfully; - * negative number, which is calculated as negation of buffer size, that is required - * to hold the variable's value (in case size of buffer is insuficcient). - */ -ssize_t -ctx_GetVariableValue(ctx_SyntacticReference_t *pVar, /**< variable */ - uint8_t *pBuffer, /**< buffer */ - size_t bufferSize) /**< size of buffer */ -{ - ecma_Value_t variableValue = ctx_GetValueDescriptorFromVariable( pVar); - - switch ( (ecma_Type_t) variableValue.m_ValueType ) - { - case ECMA_TYPE_SIMPLE: - { - if ( bufferSize < sizeof (ecma_SimpleValue_t) ) - { - return -(ssize_t)sizeof (ecma_SimpleValue_t); - } else - { - *(ecma_SimpleValue_t*) pBuffer = variableValue.m_Value; - - return sizeof (ecma_SimpleValue_t); - } - break; - } - - case ECMA_TYPE_NUMBER: - { - if ( bufferSize < sizeof (ecma_Number_t) ) - { - return -(ssize_t)sizeof (ecma_Number_t); - } else - { - ecma_Number_t *pNumber = ecma_GetPointer(variableValue.m_Value); - *(ecma_Number_t*) pBuffer = *pNumber; - - return sizeof (ecma_Number_t); - } - break; - } - - case ECMA_TYPE_STRING: - { - ecma_ArrayFirstChunk_t *pStringFirstChunk = ecma_GetPointer(variableValue.m_Value); - - return ecma_CopyEcmaStringCharsToBuffer( pStringFirstChunk, pBuffer, bufferSize); - } - - case ECMA_TYPE_OBJECT: /* cannot return object itself (only value of a property or of an array's element */ - case ECMA_TYPE__COUNT: - { - /* will trap below */ - } - } - - JERRY_UNREACHABLE(); -} /* ctx_GetVariableValue */ - -/** - * Set variable's/property's/array's element's value to one of simple values. - */ -void -ctx_SetVariableToSimpleValue(ctx_SyntacticReference_t *pVar, /**< variable */ - ecma_SimpleValue_t value) /**< value */ -{ - ecma_Value_t valueToSet; - - valueToSet.m_ValueType = ECMA_TYPE_SIMPLE; - valueToSet.m_Value = value; - - ctx_SetValueDescriptorToVariable( pVar, valueToSet); -} /* ctx_SetVariableToSimpleValue */ - -/** - * Set variable's/property's/array's element's value to a Number. - */ -void -ctx_SetVariableToNumber(ctx_SyntacticReference_t *pVar, /**< variable */ - ecma_Number_t value) /**< value */ -{ - ecma_Number_t *pNumber = ecma_AllocNumber(); - *pNumber = value; - - ecma_Value_t valueToSet; - valueToSet.m_ValueType = ECMA_TYPE_NUMBER; - ecma_SetPointer( valueToSet.m_Value, pNumber); - - ctx_SetValueDescriptorToVariable( pVar, valueToSet); -} /* ctx_SetVariableToNumber */ - -/** - * Set variable's/property's/array's element's value to a String. - */ -void -ctx_SetVariableToString(ctx_SyntacticReference_t *pVar, /**< variable */ - ecma_Char_t *value, /**< string's characters */ - ecma_Length_t length) /**< string's length, in characters */ -{ - ecma_Value_t valueToSet; - valueToSet.m_ValueType = ECMA_TYPE_STRING; - ecma_SetPointer( valueToSet.m_Value, ecma_NewEcmaString( value, length)); - - ctx_SetValueDescriptorToVariable( pVar, valueToSet); -} /* ctx_SetVariableToString */ - -/** - * @} - */ - -/** - * Static checks that ecma types fit size requirements. - * - * Warning: - * must not be called - */ -static void __unused -ctx_EcmaTypesSizeCheckers( void) -{ - 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_UNREACHABLE(); -} /* ctx_EcmaTypesSizeCheckers */ - -/** - * @} - */ \ No newline at end of file diff --git a/src/libecmaobjects/ctx-manager.h b/src/libecmaobjects/ctx-manager.h deleted file mode 100644 index ade9a1f5a..000000000 --- a/src/libecmaobjects/ctx-manager.h +++ /dev/null @@ -1,124 +0,0 @@ -/* Copyright 2014 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef JERRY_CTX_MANAGER_H -#define JERRY_CTX_MANAGER_H - -#include "ctx-reference.h" -#include "globals.h" -#include "ecma-globals.h" - -/** \addtogroup ctxman Context manager - * @{ - * \addtogroup interface Context manager's interface - * @{ - */ - -/** - * Initialize context manager and global execution context. - */ -extern void ctx_Init(void); - -/** - * Create new variables' context using global object - * for ThisBinding and lexical environments. - */ -extern void ctx_NewContextFromGlobalObject(void); - -/** - * Create new variables' context inheriting lexical environment from specified - * function's [[Scope]], and setting ThisBinding from pThisVar parameter - * (see also ECMA-262 5.1, 10.4.3). - */ -extern void ctx_NewContextFromFunctionScope(ctx_SyntacticReference_t *pThisVar, ctx_SyntacticReference_t *pFunctionVar); - -/** - * Create new lexical environment using specified object as binding object, - * setting provideThis to specified value. - * The lexical environment is inherited from current context's lexical environment. - */ -extern void ctx_NewLexicalEnvironmentFromObject(ctx_SyntacticReference_t *pObjectVar, bool provideThis); - -/** - * Exit from levelsToExit lexical environments (i.e. choose lexical environment - * that is levelsToExit outward current lexical environment as new current context's - * lexical environment). - */ -extern void ctx_ExitLexicalEnvironments(uint32_t levelsToExit); - -/** - * Exit from levelsToExit variables' contexts (i.e. choose context - * that is levelsToExit from current context as new current context). - */ -extern void ctx_ExitContexts(uint32_t levelsToExit); - -/** - * Create new variable with undefined value. - */ -extern void ctx_NewVariable(ctx_SyntacticReference_t *pVar); - -/** - * Delete specified variable. - */ -extern void ctx_DeleteVariable(ctx_SyntacticReference_t *pVar); - -/** - * Check if specified variable exists - * - * @return true, if exists; - * false - otherwise. - */ -extern bool ctx_DoesVariableExist(ctx_SyntacticReference_t *pVar); - -/** - * Copy variable's/property's/array's element's value. - */ -extern void ctx_CopyVariable(ctx_SyntacticReference_t *pVarFrom, ctx_SyntacticReference_t *pVarTo); - -/** - * Get type of specified of variable/property/array's element. - */ -extern ecma_Type_t ctx_GetVariableType(ctx_SyntacticReference_t *pVar); - -/** - * Get specified variable's/property's/array's element's value. - * - * @return number of bytes, actually copied to the buffer, if variable value was copied successfully; - * negative number, which is calculated as negation of buffer size, that is required - * to hold the variable's value (in case size of buffer is insuficcient). - */ -extern ssize_t ctx_GetVariableValue(ctx_SyntacticReference_t *pVar, uint8_t *pBuffer, size_t bufferSize); - -/** - * Set variable's/property's/array's element's value to one of simple values. - */ -extern void ctx_SetVariableToSimpleValue(ctx_SyntacticReference_t *pVar, ecma_SimpleValue_t value); - -/** - * Set variable's/property's/array's element's value to a Number. - */ -extern void ctx_SetVariableToNumber(ctx_SyntacticReference_t *pVar, ecma_Number_t value); - -/** - * Set variable's/property's/array's element's value to a String. - */ -extern void ctx_SetVariableToString(ctx_SyntacticReference_t *pVar, ecma_Char_t *value, ecma_Length_t length); - -#endif /* !JERRY_CTX_MANAGER_H */ - -/** - * @} - * @} - */ \ No newline at end of file diff --git a/src/libecmaobjects/ctx-reference.c b/src/libecmaobjects/ctx-reference.c deleted file mode 100644 index 1d2f37240..000000000 --- a/src/libecmaobjects/ctx-reference.c +++ /dev/null @@ -1,224 +0,0 @@ -/* Copyright 2014 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -/** \addtogroup ctxman Context manager - * @{ - * - * \addtogroup resolvedreference Resolved reference type - * @{ - */ - -/** - * Implementation of Reference's operations - */ - -#include "globals.h" -#include "ecma-globals.h" -#include "ecma-helpers.h" -#include "ctx-reference.h" - -/** - * GetBase operation of Reference. - * - * @return base value component of reference - */ -ecma_Object_t* -ctx_reference_get_base( ctx_Reference_t *reference_p) /**< reference */ -{ - return reference_p->m_Base; -} /* ctx_reference_get_base */ - -/** - * GetReferencedName operation of Reference. - * - * @return pointer to first chunk of ecma-array containing the referenced name - */ -const ecma_ArrayFirstChunk_t* -ctx_reference_get_referenced_name( ctx_Reference_t *reference_p) /**< reference */ -{ - const ecma_Property_t *property_p = reference_p->m_ReferencedProperty; - - switch ( (ecma_PropertyType_t) property_p->m_Type ) - { - case ECMA_PROPERTY_NAMEDDATA: - return ecma_GetPointer( property_p->u.m_NamedDataProperty.m_pName); - - case ECMA_PROPERTY_NAMEDACCESSOR: - return ecma_GetPointer( property_p->u.m_NamedAccessorProperty.m_pName); - - case ECMA_PROPERTY_INTERNAL: - /* will trap below */ - break; - } - - JERRY_UNREACHABLE(); -} /* ctx_reference_get_referenced_name */ - -/** - * IsStrictReference operation of Reference. - * - * @return strict component of reference: - * true - if reference is strict, - * false - otherwise. - */ -bool -ctx_reference_is_strict_reference( ctx_Reference_t *reference_p) /**< reference */ -{ - return reference_p->m_Strict; -} /* ctx_reference_is_strict_reference */ - -/** - * IsPropertyReference operation of Reference. - * - * @return true - if either the base value is an object or HasPrimitiveBase returns true; - * false - otherwise. - */ -bool -ctx_reference_is_property_reference( ctx_Reference_t * reference_p) /**< reference */ -{ - - return (reference_p->m_Base != NULL - && !reference_p->m_Base->m_IsLexicalEnvironment ); -} /* ctx_reference_is_property_reference */ - -/** - * IsUnresolvableReference operation of Reference. - * - * @return true - if the base value is undefined; - * false - otherwise. - */ -bool -ctx_reference_is_unresolvable_reference( ctx_Reference_t * reference_p) /**< reference */ -{ - return ( reference_p->m_Base == NULL ); -} /* ctx_reference_is_unresolvable_reference */ - -/** - * Get referenced property. - * - * @return pointer to ecma-property - * (which describes object's property or a lexical environment's binding). - */ -ecma_Property_t* -ctx_reference_get_referenced_component( ctx_Reference_t *reference_p) /**< reference */ -{ - return reference_p->m_ReferencedProperty; -} /* ctx_reference_get_referenced_component */ - -/** - * Resolve syntactic reference - * - * Note: - * Returned value must be freed using ctx_free_resolved_reference - * - * @return pointer to resolved reference description - */ -ctx_Reference_t* -ctx_resolve_syntactic_reference(ecma_Object_t *lex_env_p, /**< lexical environment of current context */ - ctx_SyntacticReference_t *syntactic_reference_p) /** syntactic reference - * to resolve */ -{ - JERRY_ASSERT(lex_env_p != NULL - && lex_env_p->m_GCInfo.m_IsObjectValid - && lex_env_p->m_IsLexicalEnvironment ); - JERRY_ASSERT(syntactic_reference_p != NULL - && syntactic_reference_p->m_Name != NULL - && ( !syntactic_reference_p->m_IsPropertyReference - || syntactic_reference_p->m_PropertyName != NULL ) ); - - ctx_Reference_t *reference_p = (ctx_Reference_t*) mem_HeapAllocBlock(sizeof (ctx_Reference_t), MEM_HEAP_ALLOC_LONG_TERM); - - bool is_variable_resolved = false; - ecma_Property_t *resolved_variable_p = NULL; - - /* resolving variable name */ - while ( !is_variable_resolved && lex_env_p != NULL ) - { - for ( ecma_Property_t *property_p = ecma_GetPointer( lex_env_p->m_pProperties); - property_p != NULL; - property_p = ecma_GetPointer( property_p->m_pNextProperty) ) - { - ecma_ArrayFirstChunk_t *property_name_p = NULL; - - /* - * TODO: make corresponding helper - */ - switch ( (ecma_PropertyType_t) property_p->m_Type ) - { - case ECMA_PROPERTY_NAMEDDATA: - property_name_p = ecma_GetPointer( property_p->u.m_NamedDataProperty.m_pName); - break; - - case ECMA_PROPERTY_NAMEDACCESSOR: - property_name_p = ecma_GetPointer( property_p->u.m_NamedAccessorProperty.m_pName); - break; - - case ECMA_PROPERTY_INTERNAL: - continue; - } - - if ( ecma_CompareCharBufferToEcmaString(syntactic_reference_p->m_Name, - property_name_p) ) - { - resolved_variable_p = property_p; - is_variable_resolved = true; - - break; - } - } - - lex_env_p = ecma_GetPointer( lex_env_p->u_Attributes.m_LexicalEnvironment.m_pOuterReference); - } - - if ( !is_variable_resolved ) - { - *reference_p = (ctx_Reference_t){ - .m_IsValid = true, - .m_Base = NULL, - .m_ReferencedProperty = NULL, - .m_Strict = syntactic_reference_p->m_StrictReference - }; - } else - { - if ( !syntactic_reference_p->m_IsPropertyReference ) - { - *reference_p = (ctx_Reference_t){ - .m_IsValid = true, - .m_Base = lex_env_p, - .m_ReferencedProperty = resolved_variable_p, - .m_Strict = syntactic_reference_p->m_StrictReference - }; - - } else - { - JERRY_UNIMPLEMENTED(); - } - } - - return reference_p; -} /* ctx_resolve_syntactic_reference */ - -void -ctx_free_resolved_reference( ctx_Reference_t *reference_p) -{ - (void)reference_p; - - JERRY_UNIMPLEMENTED(); -} /* ctx_free_resolved_reference */ - -/** - * @} - * @} - */ diff --git a/src/libecmaobjects/ctx-reference.h b/src/libecmaobjects/ctx-reference.h deleted file mode 100644 index 9a481df31..000000000 --- a/src/libecmaobjects/ctx-reference.h +++ /dev/null @@ -1,133 +0,0 @@ -/* Copyright 2014 Samsung Electronics Co., Ltd. - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -#ifndef CTX_REFERENCE_H -#define CTX_REFERENCE_H - -#include "ctx-reference.h" -#include "globals.h" -#include "ecma-globals.h" - -/** \addtogroup ctxman Context manager - * @{ - */ - -/** - * \addtogroup syntacticreference Textual reference to variable/property - * @{ - */ - -/** - * Syntactic (textual/unresolved) reference to a variable/object's property. - */ -typedef struct { - /** - * Flag indicating that this is reference to a property. - * - * Note: - * m_PropertyName is valid only if m_IsPropertyReference is true. - */ - uint32_t m_IsPropertyReference : 1; - - /** - * Flag indicating that this reference is strict (see also: ECMA-262 v5, 8.7). - */ - uint32_t m_StrictReference : 1; - - /** - * Name of variable (Null-terminated string). - */ - ecma_Char_t* m_Name; - - /** - * Name of object's property (Null-terminated string). - */ - ecma_Char_t* m_PropertyName; -} ctx_SyntacticReference_t; - -/** - * @} - */ - -/** - * \addtogroup resolvedreference Resolved reference type - * @{ - */ - -/** - * Description of resolved reference. - * - * Implementation details: - * 1. In contrast to Reference specification type the referenced name - * is not stored as string, but is resolved and stored as pointer - * to ecma-property. - * - * If the referenced element is deleted, the m_IsValid must be set to false. - * - * 2. Is base is Boolean, String, Number, then it is converted to Object via - * ecma_ToObject and then is stored in the reference. - * - * See also: ECMA-262 v5, 8.7. - */ -typedef struct -{ - /** - * Flag indicating whether the reference is valid. - * - * The flag is initially set to true. - * - */ - bool m_IsValid; - - /** - * Base value - * - * May be undefined (NULL), Object or Lexical Environment - */ - ecma_Object_t* m_Base; - - /** - * Referenced property. - * - * Note: - * in case base is lexical environment this is reference to variable. - */ - ecma_Property_t* m_ReferencedProperty; - - /** - * Strict reference flag. - */ - bool m_Strict; -} ctx_Reference_t; - -/* - * ctx-reference.c - */ -extern ecma_Object_t* ctx_reference_get_base( ctx_Reference_t *reference_p); -extern const ecma_ArrayFirstChunk_t* ctx_reference_get_referenced_name( ctx_Reference_t *reference_p); -extern bool ctx_reference_is_strict_reference( ctx_Reference_t *reference_p); -extern bool ctx_reference_is_property_reference( ctx_Reference_t *reference_p); -extern bool ctx_reference_is_unresolvable_reference( ctx_Reference_t *reference_p); -extern ecma_Property_t *ctx_reference_get_referenced_component( ctx_Reference_t *reference_p); - -extern ctx_Reference_t* ctx_resolve_syntactic_reference( ecma_Object_t *lex_env_p, ctx_SyntacticReference_t *syntactic_reference_p); -extern void ctx_free_resolved_reference( ctx_Reference_t *reference_p); - -/** - * @} - * @} - */ - -#endif /* !CTX_REFERENCE_H */ \ No newline at end of file diff --git a/src/libecmaobjects/ecma-reference.h b/src/libecmaobjects/ecma-reference.h new file mode 100644 index 000000000..cfdb33bb6 --- /dev/null +++ b/src/libecmaobjects/ecma-reference.h @@ -0,0 +1,61 @@ +/* Copyright 2014 Samsung Electronics Co., Ltd. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ECMA_REFERENCE_H +#define ECMA_REFERENCE_H + +/** \addtogroup ecma ---TODO--- + * @{ + */ + +/** + * \addtogroup syntacticreference Textual reference to variable/property + * @{ + */ + +/** + * Syntactic (textual/unresolved) reference to a variable/object's property. + */ +typedef struct { + /** + * Flag indicating that this is reference to a property. + * + * Note: + * m_PropertyName is valid only if m_IsPropertyReference is true. + */ + uint32_t m_IsPropertyReference : 1; + + /** + * Flag indicating that this reference is strict (see also: ECMA-262 v5, 8.7). + */ + uint32_t m_StrictReference : 1; + + /** + * Name of variable (Null-terminated string). + */ + ecma_Char_t* m_Name; + + /** + * Name of object's property (Null-terminated string). + */ + ecma_Char_t* m_PropertyName; +} ecma_SyntacticReference_t; + +/** + * @} + * @} + */ + +#endif /* !ECMA_REFERENCE_H */ diff --git a/src/main.c b/src/main.c index c8c9c5da6..93022d66b 100644 --- a/src/main.c +++ b/src/main.c @@ -32,7 +32,6 @@ #include "error.h" -#include "ctx-manager.h" #include "mem-allocator.h" #include "interpreter.h" @@ -103,7 +102,6 @@ main (int argc, char **argv) #endif mem_Init (); - ctx_Init (); if (argc > 0) for (int i = 1; i < argc; i++)