JavaScriptCore:
authordarin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 16 Nov 2008 04:40:06 +0000 (04:40 +0000)
committerdarin@apple.com <darin@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Sun, 16 Nov 2008 04:40:06 +0000 (04:40 +0000)
2008-11-15  Darin Adler  <darin@apple.com>

        Rubber stamped by Geoff Garen.

        - do the long-planned StructureID -> Structure rename

        * API/JSCallbackConstructor.cpp:
        (JSC::JSCallbackConstructor::JSCallbackConstructor):
        * API/JSCallbackConstructor.h:
        (JSC::JSCallbackConstructor::createStructure):
        * API/JSCallbackFunction.h:
        (JSC::JSCallbackFunction::createStructure):
        * API/JSCallbackObject.h:
        (JSC::JSCallbackObject::createStructure):
        * API/JSCallbackObjectFunctions.h:
        (JSC::::JSCallbackObject):
        * API/JSValueRef.cpp:
        (JSValueIsInstanceOfConstructor):
        * GNUmakefile.am:
        * JavaScriptCore.exp:
        * JavaScriptCore.pri:
        * JavaScriptCore.scons:
        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
        * JavaScriptCore.xcodeproj/project.pbxproj:
        * JavaScriptCoreSources.bkl:
        * VM/CTI.cpp:
        (JSC::CTI::compileBinaryArithOp):
        (JSC::CTI::privateCompileMainPass):
        (JSC::CTI::privateCompileGetByIdSelf):
        (JSC::CTI::privateCompileGetByIdProto):
        (JSC::CTI::privateCompileGetByIdChain):
        (JSC::CTI::privateCompilePutByIdReplace):
        (JSC::transitionWillNeedStorageRealloc):
        (JSC::CTI::privateCompilePutByIdTransition):
        (JSC::CTI::patchGetByIdSelf):
        (JSC::CTI::patchPutByIdReplace):
        * VM/CTI.h:
        (JSC::CTI::compileGetByIdSelf):
        (JSC::CTI::compileGetByIdProto):
        (JSC::CTI::compileGetByIdChain):
        (JSC::CTI::compilePutByIdReplace):
        (JSC::CTI::compilePutByIdTransition):
        * VM/CodeBlock.cpp:
        (JSC::CodeBlock::printStructure):
        (JSC::CodeBlock::printStructures):
        (JSC::CodeBlock::dump):
        (JSC::CodeBlock::~CodeBlock):
        (JSC::CodeBlock::derefStructures):
        (JSC::CodeBlock::refStructures):
        * VM/CodeBlock.h:
        * VM/Instruction.h:
        (JSC::Instruction::Instruction):
        (JSC::Instruction::):
        * VM/Machine.cpp:
        (JSC::jsTypeStringForValue):
        (JSC::jsIsObjectType):
        (JSC::BytecodeInterpreter::resolveGlobal):
        (JSC::BytecodeInterpreter::BytecodeInterpreter):
        (JSC::cachePrototypeChain):
        (JSC::BytecodeInterpreter::tryCachePutByID):
        (JSC::BytecodeInterpreter::uncachePutByID):
        (JSC::BytecodeInterpreter::tryCacheGetByID):
        (JSC::BytecodeInterpreter::uncacheGetByID):
        (JSC::BytecodeInterpreter::privateExecute):
        (JSC::BytecodeInterpreter::tryCTICachePutByID):
        (JSC::BytecodeInterpreter::tryCTICacheGetByID):
        (JSC::BytecodeInterpreter::cti_op_instanceof):
        (JSC::BytecodeInterpreter::cti_op_construct_JSConstruct):
        (JSC::BytecodeInterpreter::cti_op_resolve_global):
        (JSC::BytecodeInterpreter::cti_op_is_undefined):
        * runtime/Arguments.h:
        (JSC::Arguments::createStructure):
        * runtime/ArrayConstructor.cpp:
        (JSC::ArrayConstructor::ArrayConstructor):
        * runtime/ArrayConstructor.h:
        * runtime/ArrayPrototype.cpp:
        (JSC::ArrayPrototype::ArrayPrototype):
        * runtime/ArrayPrototype.h:
        * runtime/BatchedTransitionOptimizer.h:
        (JSC::BatchedTransitionOptimizer::BatchedTransitionOptimizer):
        (JSC::BatchedTransitionOptimizer::~BatchedTransitionOptimizer):
        * runtime/BooleanConstructor.cpp:
        (JSC::BooleanConstructor::BooleanConstructor):
        * runtime/BooleanConstructor.h:
        * runtime/BooleanObject.cpp:
        (JSC::BooleanObject::BooleanObject):
        * runtime/BooleanObject.h:
        * runtime/BooleanPrototype.cpp:
        (JSC::BooleanPrototype::BooleanPrototype):
        * runtime/BooleanPrototype.h:
        * runtime/DateConstructor.cpp:
        (JSC::DateConstructor::DateConstructor):
        * runtime/DateConstructor.h:
        * runtime/DateInstance.cpp:
        (JSC::DateInstance::DateInstance):
        * runtime/DateInstance.h:
        * runtime/DatePrototype.cpp:
        (JSC::DatePrototype::DatePrototype):
        * runtime/DatePrototype.h:
        (JSC::DatePrototype::createStructure):
        * runtime/ErrorConstructor.cpp:
        (JSC::ErrorConstructor::ErrorConstructor):
        * runtime/ErrorConstructor.h:
        * runtime/ErrorInstance.cpp:
        (JSC::ErrorInstance::ErrorInstance):
        * runtime/ErrorInstance.h:
        * runtime/ErrorPrototype.cpp:
        (JSC::ErrorPrototype::ErrorPrototype):
        * runtime/ErrorPrototype.h:
        * runtime/FunctionConstructor.cpp:
        (JSC::FunctionConstructor::FunctionConstructor):
        * runtime/FunctionConstructor.h:
        * runtime/FunctionPrototype.cpp:
        (JSC::FunctionPrototype::FunctionPrototype):
        (JSC::FunctionPrototype::addFunctionProperties):
        * runtime/FunctionPrototype.h:
        (JSC::FunctionPrototype::createStructure):
        * runtime/GlobalEvalFunction.cpp:
        (JSC::GlobalEvalFunction::GlobalEvalFunction):
        * runtime/GlobalEvalFunction.h:
        * runtime/Identifier.h:
        * runtime/InternalFunction.cpp:
        (JSC::InternalFunction::InternalFunction):
        * runtime/InternalFunction.h:
        (JSC::InternalFunction::createStructure):
        (JSC::InternalFunction::InternalFunction):
        * runtime/JSActivation.cpp:
        (JSC::JSActivation::JSActivation):
        * runtime/JSActivation.h:
        (JSC::JSActivation::createStructure):
        * runtime/JSArray.cpp:
        (JSC::JSArray::JSArray):
        * runtime/JSArray.h:
        (JSC::JSArray::createStructure):
        * runtime/JSCell.h:
        (JSC::JSCell::JSCell):
        (JSC::JSCell::isObject):
        (JSC::JSCell::isString):
        (JSC::JSCell::structure):
        (JSC::JSValue::needsThisConversion):
        * runtime/JSFunction.cpp:
        (JSC::JSFunction::construct):
        * runtime/JSFunction.h:
        (JSC::JSFunction::JSFunction):
        (JSC::JSFunction::createStructure):
        * runtime/JSGlobalData.cpp:
        (JSC::JSGlobalData::JSGlobalData):
        (JSC::JSGlobalData::createLeaked):
        * runtime/JSGlobalData.h:
        * runtime/JSGlobalObject.cpp:
        (JSC::markIfNeeded):
        (JSC::JSGlobalObject::reset):
        * runtime/JSGlobalObject.h:
        (JSC::JSGlobalObject::JSGlobalObject):
        (JSC::JSGlobalObject::argumentsStructure):
        (JSC::JSGlobalObject::arrayStructure):
        (JSC::JSGlobalObject::booleanObjectStructure):
        (JSC::JSGlobalObject::callbackConstructorStructure):
        (JSC::JSGlobalObject::callbackFunctionStructure):
        (JSC::JSGlobalObject::callbackObjectStructure):
        (JSC::JSGlobalObject::dateStructure):
        (JSC::JSGlobalObject::emptyObjectStructure):
        (JSC::JSGlobalObject::errorStructure):
        (JSC::JSGlobalObject::functionStructure):
        (JSC::JSGlobalObject::numberObjectStructure):
        (JSC::JSGlobalObject::prototypeFunctionStructure):
        (JSC::JSGlobalObject::regExpMatchesArrayStructure):
        (JSC::JSGlobalObject::regExpStructure):
        (JSC::JSGlobalObject::stringObjectStructure):
        (JSC::JSGlobalObject::createStructure):
        (JSC::Structure::prototypeForLookup):
        * runtime/JSNotAnObject.h:
        (JSC::JSNotAnObject::createStructure):
        * runtime/JSNumberCell.h:
        (JSC::JSNumberCell::createStructure):
        (JSC::JSNumberCell::JSNumberCell):
        * runtime/JSObject.cpp:
        (JSC::JSObject::mark):
        (JSC::JSObject::put):
        (JSC::JSObject::deleteProperty):
        (JSC::JSObject::defineGetter):
        (JSC::JSObject::defineSetter):
        (JSC::JSObject::getPropertyAttributes):
        (JSC::JSObject::getPropertyNames):
        (JSC::JSObject::removeDirect):
        (JSC::JSObject::createInheritorID):
        * runtime/JSObject.h:
        (JSC::JSObject::getDirect):
        (JSC::JSObject::getDirectLocation):
        (JSC::JSObject::hasCustomProperties):
        (JSC::JSObject::hasGetterSetterProperties):
        (JSC::JSObject::createStructure):
        (JSC::JSObject::JSObject):
        (JSC::JSObject::~JSObject):
        (JSC::JSObject::prototype):
        (JSC::JSObject::setPrototype):
        (JSC::JSObject::setStructure):
        (JSC::JSObject::inheritorID):
        (JSC::JSObject::inlineGetOwnPropertySlot):
        (JSC::JSObject::getOwnPropertySlotForWrite):
        (JSC::JSCell::fastGetOwnPropertySlot):
        (JSC::JSObject::putDirect):
        (JSC::JSObject::putDirectWithoutTransition):
        (JSC::JSObject::transitionTo):
        * runtime/JSPropertyNameIterator.h:
        (JSC::JSPropertyNameIterator::next):
        * runtime/JSStaticScopeObject.h:
        (JSC::JSStaticScopeObject::JSStaticScopeObject):
        (JSC::JSStaticScopeObject::createStructure):
        * runtime/JSString.h:
        (JSC::JSString::JSString):
        (JSC::JSString::createStructure):
        * runtime/JSVariableObject.h:
        (JSC::JSVariableObject::JSVariableObject):
        * runtime/JSWrapperObject.h:
        (JSC::JSWrapperObject::JSWrapperObject):
        * runtime/MathObject.cpp:
        (JSC::MathObject::MathObject):
        * runtime/MathObject.h:
        (JSC::MathObject::createStructure):
        * runtime/NativeErrorConstructor.cpp:
        (JSC::NativeErrorConstructor::NativeErrorConstructor):
        * runtime/NativeErrorConstructor.h:
        * runtime/NativeErrorPrototype.cpp:
        (JSC::NativeErrorPrototype::NativeErrorPrototype):
        * runtime/NativeErrorPrototype.h:
        * runtime/NumberConstructor.cpp:
        (JSC::NumberConstructor::NumberConstructor):
        * runtime/NumberConstructor.h:
        (JSC::NumberConstructor::createStructure):
        * runtime/NumberObject.cpp:
        (JSC::NumberObject::NumberObject):
        * runtime/NumberObject.h:
        * runtime/NumberPrototype.cpp:
        (JSC::NumberPrototype::NumberPrototype):
        * runtime/NumberPrototype.h:
        * runtime/ObjectConstructor.cpp:
        (JSC::ObjectConstructor::ObjectConstructor):
        * runtime/ObjectConstructor.h:
        * runtime/ObjectPrototype.cpp:
        (JSC::ObjectPrototype::ObjectPrototype):
        * runtime/ObjectPrototype.h:
        * runtime/Operations.h:
        (JSC::equalSlowCaseInline):
        * runtime/PropertyNameArray.h:
        (JSC::PropertyNameArrayData::setCachedStructure):
        (JSC::PropertyNameArrayData::cachedStructure):
        (JSC::PropertyNameArrayData::setCachedPrototypeChain):
        (JSC::PropertyNameArrayData::cachedPrototypeChain):
        (JSC::PropertyNameArrayData::PropertyNameArrayData):
        * runtime/PrototypeFunction.cpp:
        (JSC::PrototypeFunction::PrototypeFunction):
        * runtime/PrototypeFunction.h:
        * runtime/RegExpConstructor.cpp:
        (JSC::RegExpConstructor::RegExpConstructor):
        * runtime/RegExpConstructor.h:
        (JSC::RegExpConstructor::createStructure):
        * runtime/RegExpObject.cpp:
        (JSC::RegExpObject::RegExpObject):
        * runtime/RegExpObject.h:
        (JSC::RegExpObject::createStructure):
        * runtime/RegExpPrototype.cpp:
        (JSC::RegExpPrototype::RegExpPrototype):
        * runtime/RegExpPrototype.h:
        * runtime/StringConstructor.cpp:
        (JSC::StringConstructor::StringConstructor):
        * runtime/StringConstructor.h:
        * runtime/StringObject.cpp:
        (JSC::StringObject::StringObject):
        * runtime/StringObject.h:
        (JSC::StringObject::createStructure):
        * runtime/StringObjectThatMasqueradesAsUndefined.h:
        (JSC::StringObjectThatMasqueradesAsUndefined::create):
        (JSC::StringObjectThatMasqueradesAsUndefined::StringObjectThatMasqueradesAsUndefined):
        (JSC::StringObjectThatMasqueradesAsUndefined::createStructure):
        * runtime/StringPrototype.cpp:
        (JSC::StringPrototype::StringPrototype):
        * runtime/StringPrototype.h:
        * runtime/Structure.cpp: Copied from JavaScriptCore/runtime/StructureID.cpp.
        (JSC::Structure::dumpStatistics):
        (JSC::Structure::Structure):
        (JSC::Structure::~Structure):
        (JSC::Structure::startIgnoringLeaks):
        (JSC::Structure::stopIgnoringLeaks):
        (JSC::Structure::materializePropertyMap):
        (JSC::Structure::getEnumerablePropertyNames):
        (JSC::Structure::clearEnumerationCache):
        (JSC::Structure::growPropertyStorageCapacity):
        (JSC::Structure::addPropertyTransitionToExistingStructure):
        (JSC::Structure::addPropertyTransition):
        (JSC::Structure::removePropertyTransition):
        (JSC::Structure::changePrototypeTransition):
        (JSC::Structure::getterSetterTransition):
        (JSC::Structure::toDictionaryTransition):
        (JSC::Structure::fromDictionaryTransition):
        (JSC::Structure::addPropertyWithoutTransition):
        (JSC::Structure::removePropertyWithoutTransition):
        (JSC::Structure::createCachedPrototypeChain):
        (JSC::Structure::checkConsistency):
        (JSC::Structure::copyPropertyTable):
        (JSC::Structure::get):
        (JSC::Structure::put):
        (JSC::Structure::remove):
        (JSC::Structure::insertIntoPropertyMapHashTable):
        (JSC::Structure::createPropertyMapHashTable):
        (JSC::Structure::expandPropertyMapHashTable):
        (JSC::Structure::rehashPropertyMapHashTable):
        (JSC::Structure::getEnumerablePropertyNamesInternal):
        * runtime/Structure.h: Copied from JavaScriptCore/runtime/StructureID.h.
        (JSC::Structure::create):
        (JSC::Structure::previousID):
        (JSC::Structure::setCachedPrototypeChain):
        (JSC::Structure::cachedPrototypeChain):
        (JSC::Structure::):
        (JSC::Structure::get):
        * runtime/StructureChain.cpp: Copied from JavaScriptCore/runtime/StructureIDChain.cpp.
        (JSC::StructureChain::StructureChain):
        (JSC::structureChainsAreEqual):
        * runtime/StructureChain.h: Copied from JavaScriptCore/runtime/StructureIDChain.h.
        (JSC::StructureChain::create):
        (JSC::StructureChain::head):
        * runtime/StructureID.cpp: Removed.
        * runtime/StructureID.h: Removed.
        * runtime/StructureIDChain.cpp: Removed.
        * runtime/StructureIDChain.h: Removed.
        * runtime/StructureIDTransitionTable.h: Removed.
        * runtime/StructureTransitionTable.h: Copied from JavaScriptCore/runtime/StructureIDTransitionTable.h.

JavaScriptGlue:

2008-11-15  Darin Adler  <darin@apple.com>

        Rubber stamped by Geoff Garen.

        - do the long-planned StructureID -> Structure rename

        * JSRun.cpp:
        (JSGlueGlobalObject::JSGlueGlobalObject):
        (JSRun::JSRun):
        * JSRun.h:
        (JSGlueGlobalObject::userObjectStructure):
        * JSUtils.cpp:
        (getThreadGlobalObject):
        * UserObjectImp.cpp:
        (UserObjectImp::UserObjectImp):
        * UserObjectImp.h:
        (UserObjectImp::createStructure):

WebCore:

2008-11-15  Darin Adler  <darin@apple.com>

        Rubber stamped by Geoff Garen.

        - do the long-planned StructureID -> Structure rename

        * ForwardingHeaders/runtime/Structure.h: Copied from WebCore/ForwardingHeaders/runtime/StructureID.h.
        * ForwardingHeaders/runtime/StructureID.h: Removed.
        * bindings/js/JSAudioConstructor.cpp:
        (WebCore::JSAudioConstructor::JSAudioConstructor):
        * bindings/js/JSDOMBinding.cpp:
        (WebCore::getCachedDOMStructure):
        (WebCore::cacheDOMStructure):
        * bindings/js/JSDOMBinding.h:
        (WebCore::DOMObject::DOMObject):
        (WebCore::getDOMStructure):
        * bindings/js/JSDOMGlobalObject.cpp:
        (WebCore::JSDOMGlobalObject::JSDOMGlobalObject):
        * bindings/js/JSDOMGlobalObject.h:
        * bindings/js/JSDOMWindowBase.cpp:
        (WebCore::JSDOMWindowBase::JSDOMWindowBase):
        * bindings/js/JSDOMWindowBase.h:
        * bindings/js/JSDOMWindowShell.cpp:
        (WebCore::JSDOMWindowShell::JSDOMWindowShell):
        (WebCore::JSDOMWindowShell::setWindow):
        * bindings/js/JSDOMWindowShell.h:
        (WebCore::JSDOMWindowShell::createStructure):
        * bindings/js/JSDedicatedWorkerConstructor.cpp:
        (WebCore::JSDedicatedWorkerConstructor::JSDedicatedWorkerConstructor):
        * bindings/js/JSHTMLAllCollection.h:
        (WebCore::JSHTMLAllCollection::JSHTMLAllCollection):
        (WebCore::JSHTMLAllCollection::createStructure):
        * bindings/js/JSImageConstructor.cpp:
        (WebCore::JSImageConstructor::JSImageConstructor):
        * bindings/js/JSInspectedObjectWrapper.cpp:
        (WebCore::JSInspectedObjectWrapper::wrap):
        (WebCore::JSInspectedObjectWrapper::JSInspectedObjectWrapper):
        * bindings/js/JSInspectedObjectWrapper.h:
        * bindings/js/JSInspectorCallbackWrapper.cpp:
        (WebCore::leakInspectorCallbackWrapperStructure):
        (WebCore::JSInspectorCallbackWrapper::wrap):
        (WebCore::JSInspectorCallbackWrapper::JSInspectorCallbackWrapper):
        * bindings/js/JSInspectorCallbackWrapper.h:
        * bindings/js/JSMessageChannelConstructor.cpp:
        (WebCore::JSMessageChannelConstructor::JSMessageChannelConstructor):
        * bindings/js/JSNamedNodesCollection.h:
        (WebCore::JSNamedNodesCollection::createStructure):
        * bindings/js/JSOptionConstructor.cpp:
        (WebCore::JSOptionConstructor::JSOptionConstructor):
        * bindings/js/JSQuarantinedObjectWrapper.cpp:
        (WebCore::JSQuarantinedObjectWrapper::JSQuarantinedObjectWrapper):
        * bindings/js/JSQuarantinedObjectWrapper.h:
        (WebCore::JSQuarantinedObjectWrapper::createStructure):
        * bindings/js/JSRGBColor.h:
        (WebCore::JSRGBColor::createStructure):
        * bindings/js/JSWorkerContext.cpp:
        (WebCore::createJSWorkerContextStructure):
        (WebCore::JSWorkerContext::JSWorkerContext):
        (WebCore::JSWorkerContext::createPrototype):
        * bindings/js/JSWorkerContext.h:
        (WebCore::JSWorkerContext::createStructure):
        (WebCore::JSWorkerContextPrototype::JSWorkerContextPrototype):
        (WebCore::JSWorkerContextPrototype::createStructure):
        * bindings/js/JSXMLHttpRequestConstructor.cpp:
        (WebCore::JSXMLHttpRequestConstructor::JSXMLHttpRequestConstructor):
        * bindings/js/JSXSLTProcessorConstructor.cpp:
        (WebCore::JSXSLTProcessorConstructor::JSXSLTProcessorConstructor):
        * bindings/scripts/CodeGeneratorJS.pm:
        * bridge/objc/objc_runtime.h:
        (JSC::Bindings::ObjcFallbackObjectImp::createStructure):
        * bridge/qt/qt_runtime.cpp:
        (JSC::Bindings::QtConnectionObject::execute):
        * bridge/qt/qt_runtime.h:
        (JSC::Bindings::QtRuntimeMethod::createStructure):
        * bridge/runtime_array.h:
        (JSC::RuntimeArray::createStructure):
        * bridge/runtime_method.h:
        (JSC::RuntimeMethod::createStructure):
        * bridge/runtime_object.cpp:
        (JSC::RuntimeObjectImp::RuntimeObjectImp):
        * bridge/runtime_object.h:
        (JSC::RuntimeObjectImp::createStructure):

WebKitTools:

2008-11-15  Darin Adler  <darin@apple.com>

        Rubber stamped by Geoff Garen.

        - do the long-planned StructureID -> Structure rename

        * Scripts/check-for-global-initializers: Update name of StructureID.o.
        * Scripts/do-webcore-rename: Renaming script that I used.

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@38440 268f45cc-cd09-0410-ab3c-d52691b4dbfc

157 files changed:
JavaScriptCore/API/JSCallbackConstructor.cpp
JavaScriptCore/API/JSCallbackConstructor.h
JavaScriptCore/API/JSCallbackFunction.h
JavaScriptCore/API/JSCallbackObject.h
JavaScriptCore/API/JSCallbackObjectFunctions.h
JavaScriptCore/API/JSValueRef.cpp
JavaScriptCore/ChangeLog
JavaScriptCore/GNUmakefile.am
JavaScriptCore/JavaScriptCore.exp
JavaScriptCore/JavaScriptCore.pri
JavaScriptCore/JavaScriptCore.scons
JavaScriptCore/JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj
JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj
JavaScriptCore/JavaScriptCoreSources.bkl
JavaScriptCore/VM/CTI.cpp
JavaScriptCore/VM/CTI.h
JavaScriptCore/VM/CodeBlock.cpp
JavaScriptCore/VM/CodeBlock.h
JavaScriptCore/VM/Instruction.h
JavaScriptCore/VM/Machine.cpp
JavaScriptCore/runtime/Arguments.h
JavaScriptCore/runtime/ArrayConstructor.cpp
JavaScriptCore/runtime/ArrayConstructor.h
JavaScriptCore/runtime/ArrayPrototype.cpp
JavaScriptCore/runtime/ArrayPrototype.h
JavaScriptCore/runtime/BatchedTransitionOptimizer.h
JavaScriptCore/runtime/BooleanConstructor.cpp
JavaScriptCore/runtime/BooleanConstructor.h
JavaScriptCore/runtime/BooleanObject.cpp
JavaScriptCore/runtime/BooleanObject.h
JavaScriptCore/runtime/BooleanPrototype.cpp
JavaScriptCore/runtime/BooleanPrototype.h
JavaScriptCore/runtime/DateConstructor.cpp
JavaScriptCore/runtime/DateConstructor.h
JavaScriptCore/runtime/DateInstance.cpp
JavaScriptCore/runtime/DateInstance.h
JavaScriptCore/runtime/DatePrototype.cpp
JavaScriptCore/runtime/DatePrototype.h
JavaScriptCore/runtime/ErrorConstructor.cpp
JavaScriptCore/runtime/ErrorConstructor.h
JavaScriptCore/runtime/ErrorInstance.cpp
JavaScriptCore/runtime/ErrorInstance.h
JavaScriptCore/runtime/ErrorPrototype.cpp
JavaScriptCore/runtime/ErrorPrototype.h
JavaScriptCore/runtime/FunctionConstructor.cpp
JavaScriptCore/runtime/FunctionConstructor.h
JavaScriptCore/runtime/FunctionPrototype.cpp
JavaScriptCore/runtime/FunctionPrototype.h
JavaScriptCore/runtime/GlobalEvalFunction.cpp
JavaScriptCore/runtime/GlobalEvalFunction.h
JavaScriptCore/runtime/Identifier.h
JavaScriptCore/runtime/InternalFunction.cpp
JavaScriptCore/runtime/InternalFunction.h
JavaScriptCore/runtime/JSActivation.cpp
JavaScriptCore/runtime/JSActivation.h
JavaScriptCore/runtime/JSArray.cpp
JavaScriptCore/runtime/JSArray.h
JavaScriptCore/runtime/JSCell.h
JavaScriptCore/runtime/JSFunction.cpp
JavaScriptCore/runtime/JSFunction.h
JavaScriptCore/runtime/JSGlobalData.cpp
JavaScriptCore/runtime/JSGlobalData.h
JavaScriptCore/runtime/JSGlobalObject.cpp
JavaScriptCore/runtime/JSGlobalObject.h
JavaScriptCore/runtime/JSNotAnObject.h
JavaScriptCore/runtime/JSNumberCell.h
JavaScriptCore/runtime/JSObject.cpp
JavaScriptCore/runtime/JSObject.h
JavaScriptCore/runtime/JSPropertyNameIterator.h
JavaScriptCore/runtime/JSStaticScopeObject.h
JavaScriptCore/runtime/JSString.h
JavaScriptCore/runtime/JSVariableObject.h
JavaScriptCore/runtime/JSWrapperObject.h
JavaScriptCore/runtime/MathObject.cpp
JavaScriptCore/runtime/MathObject.h
JavaScriptCore/runtime/NativeErrorConstructor.cpp
JavaScriptCore/runtime/NativeErrorConstructor.h
JavaScriptCore/runtime/NativeErrorPrototype.cpp
JavaScriptCore/runtime/NativeErrorPrototype.h
JavaScriptCore/runtime/NumberConstructor.cpp
JavaScriptCore/runtime/NumberConstructor.h
JavaScriptCore/runtime/NumberObject.cpp
JavaScriptCore/runtime/NumberObject.h
JavaScriptCore/runtime/NumberPrototype.cpp
JavaScriptCore/runtime/NumberPrototype.h
JavaScriptCore/runtime/ObjectConstructor.cpp
JavaScriptCore/runtime/ObjectConstructor.h
JavaScriptCore/runtime/ObjectPrototype.cpp
JavaScriptCore/runtime/ObjectPrototype.h
JavaScriptCore/runtime/Operations.h
JavaScriptCore/runtime/PropertyNameArray.h
JavaScriptCore/runtime/PrototypeFunction.cpp
JavaScriptCore/runtime/PrototypeFunction.h
JavaScriptCore/runtime/RegExpConstructor.cpp
JavaScriptCore/runtime/RegExpConstructor.h
JavaScriptCore/runtime/RegExpObject.cpp
JavaScriptCore/runtime/RegExpObject.h
JavaScriptCore/runtime/RegExpPrototype.cpp
JavaScriptCore/runtime/RegExpPrototype.h
JavaScriptCore/runtime/StringConstructor.cpp
JavaScriptCore/runtime/StringConstructor.h
JavaScriptCore/runtime/StringObject.cpp
JavaScriptCore/runtime/StringObject.h
JavaScriptCore/runtime/StringObjectThatMasqueradesAsUndefined.h
JavaScriptCore/runtime/StringPrototype.cpp
JavaScriptCore/runtime/StringPrototype.h
JavaScriptCore/runtime/Structure.cpp [moved from JavaScriptCore/runtime/StructureID.cpp with 74% similarity]
JavaScriptCore/runtime/Structure.h [moved from JavaScriptCore/runtime/StructureID.h with 78% similarity]
JavaScriptCore/runtime/StructureChain.cpp [moved from JavaScriptCore/runtime/StructureIDChain.cpp with 75% similarity]
JavaScriptCore/runtime/StructureChain.h [moved from JavaScriptCore/runtime/StructureIDChain.h with 73% similarity]
JavaScriptCore/runtime/StructureTransitionTable.h [moved from JavaScriptCore/runtime/StructureIDTransitionTable.h with 86% similarity]
JavaScriptGlue/ChangeLog
JavaScriptGlue/JSRun.cpp
JavaScriptGlue/JSRun.h
JavaScriptGlue/JSUtils.cpp
JavaScriptGlue/UserObjectImp.cpp
JavaScriptGlue/UserObjectImp.h
WebCore/ChangeLog
WebCore/ForwardingHeaders/runtime/Structure.h [new file with mode: 0644]
WebCore/ForwardingHeaders/runtime/StructureID.h [deleted file]
WebCore/bindings/js/JSAudioConstructor.cpp
WebCore/bindings/js/JSDOMBinding.cpp
WebCore/bindings/js/JSDOMBinding.h
WebCore/bindings/js/JSDOMGlobalObject.cpp
WebCore/bindings/js/JSDOMGlobalObject.h
WebCore/bindings/js/JSDOMWindowBase.cpp
WebCore/bindings/js/JSDOMWindowBase.h
WebCore/bindings/js/JSDOMWindowShell.cpp
WebCore/bindings/js/JSDOMWindowShell.h
WebCore/bindings/js/JSDedicatedWorkerConstructor.cpp
WebCore/bindings/js/JSHTMLAllCollection.h
WebCore/bindings/js/JSImageConstructor.cpp
WebCore/bindings/js/JSInspectedObjectWrapper.cpp
WebCore/bindings/js/JSInspectedObjectWrapper.h
WebCore/bindings/js/JSInspectorCallbackWrapper.cpp
WebCore/bindings/js/JSInspectorCallbackWrapper.h
WebCore/bindings/js/JSMessageChannelConstructor.cpp
WebCore/bindings/js/JSNamedNodesCollection.h
WebCore/bindings/js/JSOptionConstructor.cpp
WebCore/bindings/js/JSQuarantinedObjectWrapper.cpp
WebCore/bindings/js/JSQuarantinedObjectWrapper.h
WebCore/bindings/js/JSRGBColor.h
WebCore/bindings/js/JSWorkerContext.cpp
WebCore/bindings/js/JSWorkerContext.h
WebCore/bindings/js/JSXMLHttpRequestConstructor.cpp
WebCore/bindings/js/JSXSLTProcessorConstructor.cpp
WebCore/bindings/scripts/CodeGeneratorJS.pm
WebCore/bridge/objc/objc_runtime.h
WebCore/bridge/qt/qt_runtime.cpp
WebCore/bridge/qt/qt_runtime.h
WebCore/bridge/runtime_array.h
WebCore/bridge/runtime_method.h
WebCore/bridge/runtime_object.cpp
WebCore/bridge/runtime_object.h
WebKitTools/ChangeLog
WebKitTools/Scripts/check-for-global-initializers
WebKitTools/Scripts/do-webcore-rename

index 29c26ea..e10733e 100644 (file)
@@ -36,7 +36,7 @@ namespace JSC {
 
 const ClassInfo JSCallbackConstructor::info = { "CallbackConstructor", 0, 0, 0 };
 
-JSCallbackConstructor::JSCallbackConstructor(PassRefPtr<StructureID> structure, JSClassRef jsClass, JSObjectCallAsConstructorCallback callback)
+JSCallbackConstructor::JSCallbackConstructor(PassRefPtr<Structure> structure, JSClassRef jsClass, JSObjectCallAsConstructorCallback callback)
     : JSObject(structure)
     , m_class(jsClass)
     , m_callback(callback)
index 01f15a8..9e80509 100644 (file)
@@ -33,15 +33,15 @@ namespace JSC {
 
 class JSCallbackConstructor : public JSObject {
 public:
-    JSCallbackConstructor(PassRefPtr<StructureID>, JSClassRef, JSObjectCallAsConstructorCallback);
+    JSCallbackConstructor(PassRefPtr<Structure>, JSClassRef, JSObjectCallAsConstructorCallback);
     virtual ~JSCallbackConstructor();
     JSClassRef classRef() const { return m_class; }
     JSObjectCallAsConstructorCallback callback() const { return m_callback; }
     static const ClassInfo info;
     
-    static PassRefPtr<StructureID> createStructureID(JSValue* proto) 
+    static PassRefPtr<Structure> createStructure(JSValue* proto) 
     { 
-        return StructureID::create(proto, TypeInfo(ObjectType, ImplementsHasInstance | HasStandardGetOwnPropertySlot)); 
+        return Structure::create(proto, TypeInfo(ObjectType, ImplementsHasInstance | HasStandardGetOwnPropertySlot)); 
     }
 
 private:
index 806a992..1ad122f 100644 (file)
@@ -39,9 +39,9 @@ public:
     
     // InternalFunction mish-mashes constructor and function behavior -- we should 
     // refactor the code so this override isn't necessary
-    static PassRefPtr<StructureID> createStructureID(JSValue* proto) 
+    static PassRefPtr<Structure> createStructure(JSValue* proto) 
     { 
-        return StructureID::create(proto, TypeInfo(ObjectType, HasStandardGetOwnPropertySlot)); 
+        return Structure::create(proto, TypeInfo(ObjectType, HasStandardGetOwnPropertySlot)); 
     }
 
 private:
index ffb02d9..4f3571e 100644 (file)
@@ -36,7 +36,7 @@ namespace JSC {
 template <class Base>
 class JSCallbackObject : public Base {
 public:
-    JSCallbackObject(ExecState*, PassRefPtr<StructureID>, JSClassRef, void* data);
+    JSCallbackObject(ExecState*, PassRefPtr<Structure>, JSClassRef, void* data);
     JSCallbackObject(JSClassRef);
     virtual ~JSCallbackObject();
 
@@ -48,9 +48,9 @@ public:
     JSClassRef classRef() const { return m_callbackObjectData->jsClass; }
     bool inherits(JSClassRef) const;
 
-    static PassRefPtr<StructureID> createStructureID(JSValue* proto) 
+    static PassRefPtr<Structure> createStructure(JSValue* proto) 
     { 
-        return StructureID::create(proto, TypeInfo(ObjectType, ImplementsHasInstance | OverridesHasInstance)); 
+        return Structure::create(proto, TypeInfo(ObjectType, ImplementsHasInstance | OverridesHasInstance)); 
     }
 
 private:
index 12af446..9aa5c06 100644 (file)
@@ -47,7 +47,7 @@ inline JSCallbackObject<Base>* JSCallbackObject<Base>::asCallbackObject(JSValue*
 }
 
 template <class Base>
-JSCallbackObject<Base>::JSCallbackObject(ExecState* exec, PassRefPtr<StructureID> structure, JSClassRef jsClass, void* data)
+JSCallbackObject<Base>::JSCallbackObject(ExecState* exec, PassRefPtr<Structure> structure, JSClassRef jsClass, void* data)
     : Base(structure)
     , m_callbackObjectData(new JSCallbackObjectData(data, jsClass))
 {
index 3d45b5d..4c57553 100644 (file)
@@ -144,7 +144,7 @@ bool JSValueIsInstanceOfConstructor(JSContextRef ctx, JSValueRef value, JSObject
 
     JSValue* jsValue = toJS(value);
     JSObject* jsConstructor = toJS(constructor);
-    if (!jsConstructor->structureID()->typeInfo().implementsHasInstance())
+    if (!jsConstructor->structure()->typeInfo().implementsHasInstance())
         return false;
     bool result = jsConstructor->hasInstance(exec, jsValue, jsConstructor->get(exec, exec->propertyNames().prototype)); // false if an exception is thrown
     if (exec->hadException()) {
index c10a680..9a6a6b7 100644 (file)
@@ -1,5 +1,333 @@
 2008-11-15  Darin Adler  <darin@apple.com>
 
+        Rubber stamped by Geoff Garen.
+
+        - do the long-planned StructureID -> Structure rename
+
+        * API/JSCallbackConstructor.cpp:
+        (JSC::JSCallbackConstructor::JSCallbackConstructor):
+        * API/JSCallbackConstructor.h:
+        (JSC::JSCallbackConstructor::createStructure):
+        * API/JSCallbackFunction.h:
+        (JSC::JSCallbackFunction::createStructure):
+        * API/JSCallbackObject.h:
+        (JSC::JSCallbackObject::createStructure):
+        * API/JSCallbackObjectFunctions.h:
+        (JSC::::JSCallbackObject):
+        * API/JSValueRef.cpp:
+        (JSValueIsInstanceOfConstructor):
+        * GNUmakefile.am:
+        * JavaScriptCore.exp:
+        * JavaScriptCore.pri:
+        * JavaScriptCore.scons:
+        * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj:
+        * JavaScriptCore.xcodeproj/project.pbxproj:
+        * JavaScriptCoreSources.bkl:
+        * VM/CTI.cpp:
+        (JSC::CTI::compileBinaryArithOp):
+        (JSC::CTI::privateCompileMainPass):
+        (JSC::CTI::privateCompileGetByIdSelf):
+        (JSC::CTI::privateCompileGetByIdProto):
+        (JSC::CTI::privateCompileGetByIdChain):
+        (JSC::CTI::privateCompilePutByIdReplace):
+        (JSC::transitionWillNeedStorageRealloc):
+        (JSC::CTI::privateCompilePutByIdTransition):
+        (JSC::CTI::patchGetByIdSelf):
+        (JSC::CTI::patchPutByIdReplace):
+        * VM/CTI.h:
+        (JSC::CTI::compileGetByIdSelf):
+        (JSC::CTI::compileGetByIdProto):
+        (JSC::CTI::compileGetByIdChain):
+        (JSC::CTI::compilePutByIdReplace):
+        (JSC::CTI::compilePutByIdTransition):
+        * VM/CodeBlock.cpp:
+        (JSC::CodeBlock::printStructure):
+        (JSC::CodeBlock::printStructures):
+        (JSC::CodeBlock::dump):
+        (JSC::CodeBlock::~CodeBlock):
+        (JSC::CodeBlock::derefStructures):
+        (JSC::CodeBlock::refStructures):
+        * VM/CodeBlock.h:
+        * VM/Instruction.h:
+        (JSC::Instruction::Instruction):
+        (JSC::Instruction::):
+        * VM/Machine.cpp:
+        (JSC::jsTypeStringForValue):
+        (JSC::jsIsObjectType):
+        (JSC::BytecodeInterpreter::resolveGlobal):
+        (JSC::BytecodeInterpreter::BytecodeInterpreter):
+        (JSC::cachePrototypeChain):
+        (JSC::BytecodeInterpreter::tryCachePutByID):
+        (JSC::BytecodeInterpreter::uncachePutByID):
+        (JSC::BytecodeInterpreter::tryCacheGetByID):
+        (JSC::BytecodeInterpreter::uncacheGetByID):
+        (JSC::BytecodeInterpreter::privateExecute):
+        (JSC::BytecodeInterpreter::tryCTICachePutByID):
+        (JSC::BytecodeInterpreter::tryCTICacheGetByID):
+        (JSC::BytecodeInterpreter::cti_op_instanceof):
+        (JSC::BytecodeInterpreter::cti_op_construct_JSConstruct):
+        (JSC::BytecodeInterpreter::cti_op_resolve_global):
+        (JSC::BytecodeInterpreter::cti_op_is_undefined):
+        * runtime/Arguments.h:
+        (JSC::Arguments::createStructure):
+        * runtime/ArrayConstructor.cpp:
+        (JSC::ArrayConstructor::ArrayConstructor):
+        * runtime/ArrayConstructor.h:
+        * runtime/ArrayPrototype.cpp:
+        (JSC::ArrayPrototype::ArrayPrototype):
+        * runtime/ArrayPrototype.h:
+        * runtime/BatchedTransitionOptimizer.h:
+        (JSC::BatchedTransitionOptimizer::BatchedTransitionOptimizer):
+        (JSC::BatchedTransitionOptimizer::~BatchedTransitionOptimizer):
+        * runtime/BooleanConstructor.cpp:
+        (JSC::BooleanConstructor::BooleanConstructor):
+        * runtime/BooleanConstructor.h:
+        * runtime/BooleanObject.cpp:
+        (JSC::BooleanObject::BooleanObject):
+        * runtime/BooleanObject.h:
+        * runtime/BooleanPrototype.cpp:
+        (JSC::BooleanPrototype::BooleanPrototype):
+        * runtime/BooleanPrototype.h:
+        * runtime/DateConstructor.cpp:
+        (JSC::DateConstructor::DateConstructor):
+        * runtime/DateConstructor.h:
+        * runtime/DateInstance.cpp:
+        (JSC::DateInstance::DateInstance):
+        * runtime/DateInstance.h:
+        * runtime/DatePrototype.cpp:
+        (JSC::DatePrototype::DatePrototype):
+        * runtime/DatePrototype.h:
+        (JSC::DatePrototype::createStructure):
+        * runtime/ErrorConstructor.cpp:
+        (JSC::ErrorConstructor::ErrorConstructor):
+        * runtime/ErrorConstructor.h:
+        * runtime/ErrorInstance.cpp:
+        (JSC::ErrorInstance::ErrorInstance):
+        * runtime/ErrorInstance.h:
+        * runtime/ErrorPrototype.cpp:
+        (JSC::ErrorPrototype::ErrorPrototype):
+        * runtime/ErrorPrototype.h:
+        * runtime/FunctionConstructor.cpp:
+        (JSC::FunctionConstructor::FunctionConstructor):
+        * runtime/FunctionConstructor.h:
+        * runtime/FunctionPrototype.cpp:
+        (JSC::FunctionPrototype::FunctionPrototype):
+        (JSC::FunctionPrototype::addFunctionProperties):
+        * runtime/FunctionPrototype.h:
+        (JSC::FunctionPrototype::createStructure):
+        * runtime/GlobalEvalFunction.cpp:
+        (JSC::GlobalEvalFunction::GlobalEvalFunction):
+        * runtime/GlobalEvalFunction.h:
+        * runtime/Identifier.h:
+        * runtime/InternalFunction.cpp:
+        (JSC::InternalFunction::InternalFunction):
+        * runtime/InternalFunction.h:
+        (JSC::InternalFunction::createStructure):
+        (JSC::InternalFunction::InternalFunction):
+        * runtime/JSActivation.cpp:
+        (JSC::JSActivation::JSActivation):
+        * runtime/JSActivation.h:
+        (JSC::JSActivation::createStructure):
+        * runtime/JSArray.cpp:
+        (JSC::JSArray::JSArray):
+        * runtime/JSArray.h:
+        (JSC::JSArray::createStructure):
+        * runtime/JSCell.h:
+        (JSC::JSCell::JSCell):
+        (JSC::JSCell::isObject):
+        (JSC::JSCell::isString):
+        (JSC::JSCell::structure):
+        (JSC::JSValue::needsThisConversion):
+        * runtime/JSFunction.cpp:
+        (JSC::JSFunction::construct):
+        * runtime/JSFunction.h:
+        (JSC::JSFunction::JSFunction):
+        (JSC::JSFunction::createStructure):
+        * runtime/JSGlobalData.cpp:
+        (JSC::JSGlobalData::JSGlobalData):
+        (JSC::JSGlobalData::createLeaked):
+        * runtime/JSGlobalData.h:
+        * runtime/JSGlobalObject.cpp:
+        (JSC::markIfNeeded):
+        (JSC::JSGlobalObject::reset):
+        * runtime/JSGlobalObject.h:
+        (JSC::JSGlobalObject::JSGlobalObject):
+        (JSC::JSGlobalObject::argumentsStructure):
+        (JSC::JSGlobalObject::arrayStructure):
+        (JSC::JSGlobalObject::booleanObjectStructure):
+        (JSC::JSGlobalObject::callbackConstructorStructure):
+        (JSC::JSGlobalObject::callbackFunctionStructure):
+        (JSC::JSGlobalObject::callbackObjectStructure):
+        (JSC::JSGlobalObject::dateStructure):
+        (JSC::JSGlobalObject::emptyObjectStructure):
+        (JSC::JSGlobalObject::errorStructure):
+        (JSC::JSGlobalObject::functionStructure):
+        (JSC::JSGlobalObject::numberObjectStructure):
+        (JSC::JSGlobalObject::prototypeFunctionStructure):
+        (JSC::JSGlobalObject::regExpMatchesArrayStructure):
+        (JSC::JSGlobalObject::regExpStructure):
+        (JSC::JSGlobalObject::stringObjectStructure):
+        (JSC::JSGlobalObject::createStructure):
+        (JSC::Structure::prototypeForLookup):
+        * runtime/JSNotAnObject.h:
+        (JSC::JSNotAnObject::createStructure):
+        * runtime/JSNumberCell.h:
+        (JSC::JSNumberCell::createStructure):
+        (JSC::JSNumberCell::JSNumberCell):
+        * runtime/JSObject.cpp:
+        (JSC::JSObject::mark):
+        (JSC::JSObject::put):
+        (JSC::JSObject::deleteProperty):
+        (JSC::JSObject::defineGetter):
+        (JSC::JSObject::defineSetter):
+        (JSC::JSObject::getPropertyAttributes):
+        (JSC::JSObject::getPropertyNames):
+        (JSC::JSObject::removeDirect):
+        (JSC::JSObject::createInheritorID):
+        * runtime/JSObject.h:
+        (JSC::JSObject::getDirect):
+        (JSC::JSObject::getDirectLocation):
+        (JSC::JSObject::hasCustomProperties):
+        (JSC::JSObject::hasGetterSetterProperties):
+        (JSC::JSObject::createStructure):
+        (JSC::JSObject::JSObject):
+        (JSC::JSObject::~JSObject):
+        (JSC::JSObject::prototype):
+        (JSC::JSObject::setPrototype):
+        (JSC::JSObject::setStructure):
+        (JSC::JSObject::inheritorID):
+        (JSC::JSObject::inlineGetOwnPropertySlot):
+        (JSC::JSObject::getOwnPropertySlotForWrite):
+        (JSC::JSCell::fastGetOwnPropertySlot):
+        (JSC::JSObject::putDirect):
+        (JSC::JSObject::putDirectWithoutTransition):
+        (JSC::JSObject::transitionTo):
+        * runtime/JSPropertyNameIterator.h:
+        (JSC::JSPropertyNameIterator::next):
+        * runtime/JSStaticScopeObject.h:
+        (JSC::JSStaticScopeObject::JSStaticScopeObject):
+        (JSC::JSStaticScopeObject::createStructure):
+        * runtime/JSString.h:
+        (JSC::JSString::JSString):
+        (JSC::JSString::createStructure):
+        * runtime/JSVariableObject.h:
+        (JSC::JSVariableObject::JSVariableObject):
+        * runtime/JSWrapperObject.h:
+        (JSC::JSWrapperObject::JSWrapperObject):
+        * runtime/MathObject.cpp:
+        (JSC::MathObject::MathObject):
+        * runtime/MathObject.h:
+        (JSC::MathObject::createStructure):
+        * runtime/NativeErrorConstructor.cpp:
+        (JSC::NativeErrorConstructor::NativeErrorConstructor):
+        * runtime/NativeErrorConstructor.h:
+        * runtime/NativeErrorPrototype.cpp:
+        (JSC::NativeErrorPrototype::NativeErrorPrototype):
+        * runtime/NativeErrorPrototype.h:
+        * runtime/NumberConstructor.cpp:
+        (JSC::NumberConstructor::NumberConstructor):
+        * runtime/NumberConstructor.h:
+        (JSC::NumberConstructor::createStructure):
+        * runtime/NumberObject.cpp:
+        (JSC::NumberObject::NumberObject):
+        * runtime/NumberObject.h:
+        * runtime/NumberPrototype.cpp:
+        (JSC::NumberPrototype::NumberPrototype):
+        * runtime/NumberPrototype.h:
+        * runtime/ObjectConstructor.cpp:
+        (JSC::ObjectConstructor::ObjectConstructor):
+        * runtime/ObjectConstructor.h:
+        * runtime/ObjectPrototype.cpp:
+        (JSC::ObjectPrototype::ObjectPrototype):
+        * runtime/ObjectPrototype.h:
+        * runtime/Operations.h:
+        (JSC::equalSlowCaseInline):
+        * runtime/PropertyNameArray.h:
+        (JSC::PropertyNameArrayData::setCachedStructure):
+        (JSC::PropertyNameArrayData::cachedStructure):
+        (JSC::PropertyNameArrayData::setCachedPrototypeChain):
+        (JSC::PropertyNameArrayData::cachedPrototypeChain):
+        (JSC::PropertyNameArrayData::PropertyNameArrayData):
+        * runtime/PrototypeFunction.cpp:
+        (JSC::PrototypeFunction::PrototypeFunction):
+        * runtime/PrototypeFunction.h:
+        * runtime/RegExpConstructor.cpp:
+        (JSC::RegExpConstructor::RegExpConstructor):
+        * runtime/RegExpConstructor.h:
+        (JSC::RegExpConstructor::createStructure):
+        * runtime/RegExpObject.cpp:
+        (JSC::RegExpObject::RegExpObject):
+        * runtime/RegExpObject.h:
+        (JSC::RegExpObject::createStructure):
+        * runtime/RegExpPrototype.cpp:
+        (JSC::RegExpPrototype::RegExpPrototype):
+        * runtime/RegExpPrototype.h:
+        * runtime/StringConstructor.cpp:
+        (JSC::StringConstructor::StringConstructor):
+        * runtime/StringConstructor.h:
+        * runtime/StringObject.cpp:
+        (JSC::StringObject::StringObject):
+        * runtime/StringObject.h:
+        (JSC::StringObject::createStructure):
+        * runtime/StringObjectThatMasqueradesAsUndefined.h:
+        (JSC::StringObjectThatMasqueradesAsUndefined::create):
+        (JSC::StringObjectThatMasqueradesAsUndefined::StringObjectThatMasqueradesAsUndefined):
+        (JSC::StringObjectThatMasqueradesAsUndefined::createStructure):
+        * runtime/StringPrototype.cpp:
+        (JSC::StringPrototype::StringPrototype):
+        * runtime/StringPrototype.h:
+        * runtime/Structure.cpp: Copied from JavaScriptCore/runtime/StructureID.cpp.
+        (JSC::Structure::dumpStatistics):
+        (JSC::Structure::Structure):
+        (JSC::Structure::~Structure):
+        (JSC::Structure::startIgnoringLeaks):
+        (JSC::Structure::stopIgnoringLeaks):
+        (JSC::Structure::materializePropertyMap):
+        (JSC::Structure::getEnumerablePropertyNames):
+        (JSC::Structure::clearEnumerationCache):
+        (JSC::Structure::growPropertyStorageCapacity):
+        (JSC::Structure::addPropertyTransitionToExistingStructure):
+        (JSC::Structure::addPropertyTransition):
+        (JSC::Structure::removePropertyTransition):
+        (JSC::Structure::changePrototypeTransition):
+        (JSC::Structure::getterSetterTransition):
+        (JSC::Structure::toDictionaryTransition):
+        (JSC::Structure::fromDictionaryTransition):
+        (JSC::Structure::addPropertyWithoutTransition):
+        (JSC::Structure::removePropertyWithoutTransition):
+        (JSC::Structure::createCachedPrototypeChain):
+        (JSC::Structure::checkConsistency):
+        (JSC::Structure::copyPropertyTable):
+        (JSC::Structure::get):
+        (JSC::Structure::put):
+        (JSC::Structure::remove):
+        (JSC::Structure::insertIntoPropertyMapHashTable):
+        (JSC::Structure::createPropertyMapHashTable):
+        (JSC::Structure::expandPropertyMapHashTable):
+        (JSC::Structure::rehashPropertyMapHashTable):
+        (JSC::Structure::getEnumerablePropertyNamesInternal):
+        * runtime/Structure.h: Copied from JavaScriptCore/runtime/StructureID.h.
+        (JSC::Structure::create):
+        (JSC::Structure::previousID):
+        (JSC::Structure::setCachedPrototypeChain):
+        (JSC::Structure::cachedPrototypeChain):
+        (JSC::Structure::):
+        (JSC::Structure::get):
+        * runtime/StructureChain.cpp: Copied from JavaScriptCore/runtime/StructureIDChain.cpp.
+        (JSC::StructureChain::StructureChain):
+        (JSC::structureChainsAreEqual):
+        * runtime/StructureChain.h: Copied from JavaScriptCore/runtime/StructureIDChain.h.
+        (JSC::StructureChain::create):
+        (JSC::StructureChain::head):
+        * runtime/StructureID.cpp: Removed.
+        * runtime/StructureID.h: Removed.
+        * runtime/StructureIDChain.cpp: Removed.
+        * runtime/StructureIDChain.h: Removed.
+        * runtime/StructureIDTransitionTable.h: Removed.
+        * runtime/StructureTransitionTable.h: Copied from JavaScriptCore/runtime/StructureIDTransitionTable.h.
+
+2008-11-15  Darin Adler  <darin@apple.com>
+
         - fix non-WREC build
 
         * runtime/RegExp.cpp: Put "using namespace WREC" inside #if ENABLE(WREC).
index 93daa89..fa9eebd 100644 (file)
@@ -149,11 +149,11 @@ javascriptcore_sources += \
        JavaScriptCore/runtime/JSPropertyNameIterator.h \
        JavaScriptCore/runtime/SmallStrings.cpp \
        JavaScriptCore/runtime/SmallStrings.h \
-       JavaScriptCore/runtime/StructureID.cpp \
-       JavaScriptCore/runtime/StructureID.h \
-       JavaScriptCore/runtime/StructureIDChain.cpp \
-       JavaScriptCore/runtime/StructureIDChain.h \
-       JavaScriptCore/runtime/StructureIDTransitionTable.h \
+       JavaScriptCore/runtime/Structure.cpp \
+       JavaScriptCore/runtime/Structure.h \
+       JavaScriptCore/runtime/StructureChain.cpp \
+       JavaScriptCore/runtime/StructureChain.h \
+       JavaScriptCore/runtime/StructureTransitionTable.h \
        JavaScriptCore/runtime/TypeInfo.h \
        JavaScriptCore/wrec/CharacterClassConstructor.cpp \
        JavaScriptCore/wrec/CharacterClassConstructor.h \
index c31c90a..4e06621 100644 (file)
@@ -104,19 +104,6 @@ __ZN3JSC11JSImmediate8toObjectEPNS_7JSValueEPNS_9ExecStateE
 __ZN3JSC11JSImmediate8toStringEPNS_7JSValueE
 __ZN3JSC11JSImmediate9prototypeEPNS_7JSValueEPNS_9ExecStateE
 __ZN3JSC11ProfileNode4sortEPFbRKN3WTF6RefPtrIS0_EES5_E
-__ZN3JSC11StructureID17stopIgnoringLeaksEv
-__ZN3JSC11StructureID18startIgnoringLeaksEv
-__ZN3JSC11StructureID21addPropertyTransitionEPS0_RKNS_10IdentifierEjRm
-__ZN3JSC11StructureID21clearEnumerationCacheEv
-__ZN3JSC11StructureID22materializePropertyMapEv
-__ZN3JSC11StructureID24fromDictionaryTransitionEPS0_
-__ZN3JSC11StructureID25changePrototypeTransitionEPS0_PNS_7JSValueE
-__ZN3JSC11StructureID27growPropertyStorageCapacityEv
-__ZN3JSC11StructureID28addPropertyWithoutTransitionERKNS_10IdentifierEj
-__ZN3JSC11StructureID3getERKNS_10IdentifierERj
-__ZN3JSC11StructureID40addPropertyTransitionToExistingStructureEPS0_RKNS_10IdentifierEjRm
-__ZN3JSC11StructureIDC1EPNS_7JSValueERKNS_8TypeInfoE
-__ZN3JSC11StructureIDD1Ev
 __ZN3JSC11checkSyntaxEPNS_9ExecStateERKNS_10SourceCodeE
 __ZN3JSC12DateInstance4infoE
 __ZN3JSC12JSGlobalData10ClientDataD2Ev
@@ -135,7 +122,7 @@ __ZN3JSC12StringObject18getOwnPropertySlotEPNS_9ExecStateERKNS_10IdentifierERNS_
 __ZN3JSC12StringObject18getOwnPropertySlotEPNS_9ExecStateEjRNS_12PropertySlotE
 __ZN3JSC12StringObject3putEPNS_9ExecStateERKNS_10IdentifierEPNS_7JSValueERNS_15PutPropertySlotE
 __ZN3JSC12StringObject4infoE
-__ZN3JSC12StringObjectC2EPNS_9ExecStateEN3WTF10PassRefPtrINS_11StructureIDEEERKNS_7UStringE
+__ZN3JSC12StringObjectC2EPNS_9ExecStateEN3WTF10PassRefPtrINS_9StructureEEERKNS_7UStringE
 __ZN3JSC12jsNumberCellEPNS_9ExecStateEd
 __ZN3JSC13StatementNode6setLocEii
 __ZN3JSC13jsOwnedStringEPNS_12JSGlobalDataERKNS_7UStringE
@@ -158,14 +145,14 @@ __ZN3JSC16FunctionBodyNode13finishParsingEPNS_10IdentifierEm
 __ZN3JSC16FunctionBodyNode14copyParametersEv
 __ZN3JSC16FunctionBodyNode6createEPNS_12JSGlobalDataEPNS_14SourceElementsEPN3WTF6VectorISt4pairINS_10IdentifierEjELm0EEEPNS6_INS5_6RefPtrINS_12FuncDeclNodeEEELm0EEERKNS_10SourceCodeEji
 __ZN3JSC16InternalFunction4infoE
-__ZN3JSC16InternalFunctionC2EPNS_12JSGlobalDataEN3WTF10PassRefPtrINS_11StructureIDEEERKNS_10IdentifierE
+__ZN3JSC16InternalFunctionC2EPNS_12JSGlobalDataEN3WTF10PassRefPtrINS_9StructureEEERKNS_10IdentifierE
 __ZN3JSC16JSVariableObject14deletePropertyEPNS_9ExecStateERKNS_10IdentifierE
 __ZN3JSC16JSVariableObject16getPropertyNamesEPNS_9ExecStateERNS_17PropertyNameArrayE
 __ZN3JSC16ParserRefCounted3refEv
 __ZN3JSC16ParserRefCounted5derefEv
 __ZN3JSC17BytecodeGenerator21setDumpsGeneratedCodeEb
 __ZN3JSC17PropertyNameArray3addEPNS_7UString3RepE
-__ZN3JSC17PrototypeFunctionC1EPNS_9ExecStateEN3WTF10PassRefPtrINS_11StructureIDEEEiRKNS_10IdentifierEPFPNS_7JSValueES2_PNS_8JSObjectESB_RKNS_7ArgListEE
+__ZN3JSC17PrototypeFunctionC1EPNS_9ExecStateEN3WTF10PassRefPtrINS_9StructureEEEiRKNS_10IdentifierEPFPNS_7JSValueES2_PNS_8JSObjectESB_RKNS_7ArgListEE
 __ZN3JSC17PrototypeFunctionC1EPNS_9ExecStateEiRKNS_10IdentifierEPFPNS_7JSValueES2_PNS_8JSObjectES7_RKNS_7ArgListEE
 __ZN3JSC17constructFunctionEPNS_9ExecStateERKNS_7ArgListERKNS_10IdentifierERKNS_7UStringEi
 __ZN3JSC19constructEmptyArrayEPNS_9ExecStateE
@@ -260,6 +247,16 @@ __ZN3JSC8evaluateEPNS_9ExecStateERNS_10ScopeChainERKNS_10SourceCodeEPNS_7JSValue
 __ZN3JSC8jsStringEPNS_12JSGlobalDataERKNS_7UStringE
 __ZN3JSC9CodeBlockD1Ev
 __ZN3JSC9CodeBlockD2Ev
+__ZN3JSC9Structure17stopIgnoringLeaksEv
+__ZN3JSC9Structure18startIgnoringLeaksEv
+__ZN3JSC9Structure21addPropertyTransitionEPS0_RKNS_10IdentifierEjRm
+__ZN3JSC9Structure22materializePropertyMapEv
+__ZN3JSC9Structure25changePrototypeTransitionEPS0_PNS_7JSValueE
+__ZN3JSC9Structure28addPropertyWithoutTransitionERKNS_10IdentifierEj
+__ZN3JSC9Structure3getERKNS_10IdentifierERj
+__ZN3JSC9Structure40addPropertyTransitionToExistingStructureEPS0_RKNS_10IdentifierEjRm
+__ZN3JSC9StructureC1EPNS_7JSValueERKNS_8TypeInfoE
+__ZN3JSC9StructureD1Ev
 __ZN3JSC9constructEPNS_9ExecStateEPNS_7JSValueENS_13ConstructTypeERKNS_13ConstructDataERKNS_7ArgListE
 __ZN3JSCeqERKNS_7UStringEPKc
 __ZN3JSCgtERKNS_7UStringES2_
@@ -350,7 +347,6 @@ __ZNK3JSC8JSObject8toObjectEPNS_9ExecStateE
 __ZNK3JSC8JSObject8toStringEPNS_9ExecStateE
 __ZNK3JSC8JSObject9classNameEv
 __ZNK3JSC8JSObject9toBooleanEPNS_9ExecStateE
-__ZNK3JSC9CodeBlock17derefStructureIDsEPNS_11InstructionE
 __ZNK3JSC9HashTable11createTableEPNS_12JSGlobalDataE
 __ZNK3JSC9HashTable11deleteTableEv
 __ZNK3WTF8Collator7collateEPKtmS2_m
index 1744453..46749f1 100644 (file)
@@ -132,8 +132,8 @@ SOURCES += \
     runtime/StringConstructor.cpp \
     runtime/StringObject.cpp \
     runtime/StringPrototype.cpp \
-    runtime/StructureID.cpp \
-    runtime/StructureIDChain.cpp \
+    runtime/Structure.cpp \
+    runtime/StructureChain.cpp \
     runtime/UString.cpp \
     profiler/HeavyProfile.cpp \
     profiler/Profile.cpp \
index 06e4a5a..b5b82cc 100644 (file)
@@ -114,8 +114,8 @@ sources['runtime'] = [
     'runtime/StringConstructor.cpp',
     'runtime/StringObject.cpp',
     'runtime/StringPrototype.cpp',
-    'runtime/StructureID.cpp',
-    'runtime/StructureIDChain.cpp',
+    'runtime/Structure.cpp',
+    'runtime/StructureChain.cpp',
     'runtime/UString.cpp',
 ]
 sources['VM'] = [
index 9a22a72..cba5c06 100644 (file)
                                >\r
                        </File>\r
                        <File\r
-                               RelativePath="..\..\runtime\StructureID.cpp"\r
+                               RelativePath="..\..\runtime\Structure.cpp"\r
                                >\r
                        </File>\r
                        <File\r
-                               RelativePath="..\..\runtime\StructureID.h"\r
+                               RelativePath="..\..\runtime\Structure.h"\r
                                >\r
                        </File>\r
                        <File\r
-                               RelativePath="..\..\runtime\StructureIDChain.cpp"\r
+                               RelativePath="..\..\runtime\StructureChain.cpp"\r
                                >\r
                        </File>\r
                        <File\r
-                               RelativePath="..\..\runtime\StructureIDChain.h"\r
+                               RelativePath="..\..\runtime\StructureChain.h"\r
                                >\r
                        </File>\r
                        <File\r
-                               RelativePath="..\..\runtime\StructureIDTransitionTable.h"\r
+                               RelativePath="..\..\runtime\StructureTransitionTable.h"\r
                                >\r
                        </File>\r
                        <File\r
index f37eca1..501c61c 100644 (file)
@@ -83,8 +83,8 @@
                7E2ADD8E0E79AAD500D50C51 /* CharacterClassConstructor.h in Headers */ = {isa = PBXBuildFile; fileRef = 7E2ADD8D0E79AAD500D50C51 /* CharacterClassConstructor.h */; };
                7E2ADD900E79AC1100D50C51 /* CharacterClassConstructor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7E2ADD8F0E79AC1100D50C51 /* CharacterClassConstructor.cpp */; };
                7E4C89140ECA0F9A00DBEEEC /* EvalCodeCache.h in Headers */ = {isa = PBXBuildFile; fileRef = 7E4C89130ECA0F9A00DBEEEC /* EvalCodeCache.h */; };
-               7E4EE7090EBB7963005934AA /* StructureIDChain.h in Headers */ = {isa = PBXBuildFile; fileRef = 7E4EE7080EBB7963005934AA /* StructureIDChain.h */; settings = {ATTRIBUTES = (Private, ); }; };
-               7E4EE70F0EBB7A5B005934AA /* StructureIDChain.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7E4EE70E0EBB7A5B005934AA /* StructureIDChain.cpp */; };
+               7E4EE7090EBB7963005934AA /* StructureChain.h in Headers */ = {isa = PBXBuildFile; fileRef = 7E4EE7080EBB7963005934AA /* StructureChain.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               7E4EE70F0EBB7A5B005934AA /* StructureChain.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 7E4EE70E0EBB7A5B005934AA /* StructureChain.cpp */; };
                7EFF00640EC05A9A00AA7C93 /* NodeInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = 7EFF00630EC05A9A00AA7C93 /* NodeInfo.h */; };
                8613F45A0E3A433E00C948FD /* SamplingTool.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8613F4580E3A433E00C948FD /* SamplingTool.cpp */; };
                8613F45B0E3A433E00C948FD /* SamplingTool.h in Headers */ = {isa = PBXBuildFile; fileRef = 8613F4590E3A433E00C948FD /* SamplingTool.h */; };
                BC6AAAE50E1F426500AD87D8 /* ClassInfo.h in Headers */ = {isa = PBXBuildFile; fileRef = BC6AAAE40E1F426500AD87D8 /* ClassInfo.h */; settings = {ATTRIBUTES = (Private, ); }; };
                BC756FC90E2031B200DE7D12 /* JSGlobalObjectFunctions.h in Headers */ = {isa = PBXBuildFile; fileRef = BC756FC70E2031B200DE7D12 /* JSGlobalObjectFunctions.h */; };
                BC7F8FB90E19D1C3008632C0 /* JSNumberCell.h in Headers */ = {isa = PBXBuildFile; fileRef = BC7F8FB80E19D1C3008632C0 /* JSNumberCell.h */; settings = {ATTRIBUTES = (Private, ); }; };
-               BC9041480EB9250900FE26FA /* StructureIDTransitionTable.h in Headers */ = {isa = PBXBuildFile; fileRef = BC9041470EB9250900FE26FA /* StructureIDTransitionTable.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               BC9041480EB9250900FE26FA /* StructureTransitionTable.h in Headers */ = {isa = PBXBuildFile; fileRef = BC9041470EB9250900FE26FA /* StructureTransitionTable.h */; settings = {ATTRIBUTES = (Private, ); }; };
                BC95437D0EBA70FD0072B6D3 /* PropertyMapHashTable.h in Headers */ = {isa = PBXBuildFile; fileRef = BC95437C0EBA70FD0072B6D3 /* PropertyMapHashTable.h */; settings = {ATTRIBUTES = (Private, ); }; };
                BCD202C20E1706A7002C7E82 /* RegExpConstructor.h in Headers */ = {isa = PBXBuildFile; fileRef = BCD202BE0E1706A7002C7E82 /* RegExpConstructor.h */; };
                BCD202C40E1706A7002C7E82 /* RegExpPrototype.h in Headers */ = {isa = PBXBuildFile; fileRef = BCD202C00E1706A7002C7E82 /* RegExpPrototype.h */; };
                BCD2034A0E17135E002C7E82 /* DateConstructor.h in Headers */ = {isa = PBXBuildFile; fileRef = BCD203460E17135E002C7E82 /* DateConstructor.h */; };
                BCD2034C0E17135E002C7E82 /* DatePrototype.h in Headers */ = {isa = PBXBuildFile; fileRef = BCD203480E17135E002C7E82 /* DatePrototype.h */; };
                BCD203E80E1718F4002C7E82 /* DatePrototype.lut.h in Headers */ = {isa = PBXBuildFile; fileRef = BCD203E70E1718F4002C7E82 /* DatePrototype.lut.h */; };
-               BCDE3AB80E6C82F5001453A7 /* StructureID.h in Headers */ = {isa = PBXBuildFile; fileRef = BCDE3AB10E6C82CF001453A7 /* StructureID.h */; settings = {ATTRIBUTES = (Private, ); }; };
-               BCDE3B430E6C832D001453A7 /* StructureID.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCDE3AB00E6C82CF001453A7 /* StructureID.cpp */; };
+               BCDE3AB80E6C82F5001453A7 /* Structure.h in Headers */ = {isa = PBXBuildFile; fileRef = BCDE3AB10E6C82CF001453A7 /* Structure.h */; settings = {ATTRIBUTES = (Private, ); }; };
+               BCDE3B430E6C832D001453A7 /* Structure.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCDE3AB00E6C82CF001453A7 /* Structure.cpp */; };
                BCF605140E203EF800B9A64D /* ArgList.h in Headers */ = {isa = PBXBuildFile; fileRef = BCF605120E203EF800B9A64D /* ArgList.h */; settings = {ATTRIBUTES = (Private, ); }; };
                C0A272630E50A06300E96E15 /* NotFound.h in Headers */ = {isa = PBXBuildFile; fileRef = C0A2723F0E509F1E00E96E15 /* NotFound.h */; settings = {ATTRIBUTES = (Private, ); }; };
                E124A8F70E555775003091F1 /* OpaqueJSString.h in Headers */ = {isa = PBXBuildFile; fileRef = E124A8F50E555775003091F1 /* OpaqueJSString.h */; settings = {ATTRIBUTES = (Private, ); }; };
                7E2ADD8F0E79AC1100D50C51 /* CharacterClassConstructor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CharacterClassConstructor.cpp; sourceTree = "<group>"; };
                7E2C6C980D31C6B6002D44E2 /* ScopeChainMark.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ScopeChainMark.h; sourceTree = "<group>"; };
                7E4C89130ECA0F9A00DBEEEC /* EvalCodeCache.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = EvalCodeCache.h; path = VM/EvalCodeCache.h; sourceTree = "<group>"; };
-               7E4EE7080EBB7963005934AA /* StructureIDChain.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StructureIDChain.h; sourceTree = "<group>"; };
-               7E4EE70E0EBB7A5B005934AA /* StructureIDChain.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StructureIDChain.cpp; sourceTree = "<group>"; };
+               7E4EE7080EBB7963005934AA /* StructureChain.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StructureChain.h; sourceTree = "<group>"; };
+               7E4EE70E0EBB7A5B005934AA /* StructureChain.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StructureChain.cpp; sourceTree = "<group>"; };
                7EFF00630EC05A9A00AA7C93 /* NodeInfo.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = NodeInfo.h; sourceTree = "<group>"; };
                8613F4580E3A433E00C948FD /* SamplingTool.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = SamplingTool.cpp; path = VM/SamplingTool.cpp; sourceTree = "<group>"; };
                8613F4590E3A433E00C948FD /* SamplingTool.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = SamplingTool.h; path = VM/SamplingTool.h; sourceTree = "<group>"; };
                BC7F8FB80E19D1C3008632C0 /* JSNumberCell.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSNumberCell.h; sourceTree = "<group>"; };
                BC7F8FBA0E19D1EF008632C0 /* JSCell.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSCell.cpp; sourceTree = "<group>"; };
                BC8F3CCF0DAF17BA00577A80 /* ConstructData.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ConstructData.h; sourceTree = "<group>"; };
-               BC9041470EB9250900FE26FA /* StructureIDTransitionTable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StructureIDTransitionTable.h; sourceTree = "<group>"; };
+               BC9041470EB9250900FE26FA /* StructureTransitionTable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StructureTransitionTable.h; sourceTree = "<group>"; };
                BC95437C0EBA70FD0072B6D3 /* PropertyMapHashTable.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = PropertyMapHashTable.h; sourceTree = "<group>"; };
                BC9BB95B0E19680600DF8855 /* InternalFunction.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = InternalFunction.cpp; sourceTree = "<group>"; };
                BCA62DFE0E2826230004F30D /* CallData.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = CallData.cpp; sourceTree = "<group>"; };
                BCD203470E17135E002C7E82 /* DatePrototype.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = DatePrototype.cpp; sourceTree = "<group>"; };
                BCD203480E17135E002C7E82 /* DatePrototype.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DatePrototype.h; sourceTree = "<group>"; };
                BCD203E70E1718F4002C7E82 /* DatePrototype.lut.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = DatePrototype.lut.h; sourceTree = "<group>"; };
-               BCDE3AB00E6C82CF001453A7 /* StructureID.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = StructureID.cpp; sourceTree = "<group>"; };
-               BCDE3AB10E6C82CF001453A7 /* StructureID.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = StructureID.h; sourceTree = "<group>"; };
+               BCDE3AB00E6C82CF001453A7 /* Structure.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = Structure.cpp; sourceTree = "<group>"; };
+               BCDE3AB10E6C82CF001453A7 /* Structure.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = Structure.h; sourceTree = "<group>"; };
                BCF605110E203EF800B9A64D /* ArgList.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ArgList.cpp; sourceTree = "<group>"; };
                BCF605120E203EF800B9A64D /* ArgList.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ArgList.h; sourceTree = "<group>"; };
                BCF6553B0A2048DE0038A194 /* MathExtras.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = MathExtras.h; sourceTree = "<group>"; };
                                BC18C3C40E16EE3300B34460 /* StringObjectThatMasqueradesAsUndefined.h */,
                                BC18C3C50E16EE3300B34460 /* StringPrototype.cpp */,
                                BC18C3C60E16EE3300B34460 /* StringPrototype.h */,
-                               BCDE3AB00E6C82CF001453A7 /* StructureID.cpp */,
-                               BCDE3AB10E6C82CF001453A7 /* StructureID.h */,
-                               7E4EE70E0EBB7A5B005934AA /* StructureIDChain.cpp */,
-                               7E4EE7080EBB7963005934AA /* StructureIDChain.h */,
-                               BC9041470EB9250900FE26FA /* StructureIDTransitionTable.h */,
+                               BCDE3AB00E6C82CF001453A7 /* Structure.cpp */,
+                               BCDE3AB10E6C82CF001453A7 /* Structure.h */,
+                               7E4EE70E0EBB7A5B005934AA /* StructureChain.cpp */,
+                               7E4EE7080EBB7963005934AA /* StructureChain.h */,
+                               BC9041470EB9250900FE26FA /* StructureTransitionTable.h */,
                                14A396A60CD2933100B5B4FF /* SymbolTable.h */,
                                5D53726D0E1C546B0021E549 /* Tracing.d */,
                                5D53726E0E1C54880021E549 /* Tracing.h */,
                                869081410E640C89000D36ED /* X86Assembler.h in Headers */,
                                869083160E6518D7000D36ED /* WREC.h in Headers */,
                                933040040E6A749400786E6A /* SmallStrings.h in Headers */,
-                               BCDE3AB80E6C82F5001453A7 /* StructureID.h in Headers */,
+                               BCDE3AB80E6C82F5001453A7 /* Structure.h in Headers */,
                                147B83AC0E6DB8C9004775A4 /* BatchedTransitionOptimizer.h in Headers */,
                                147B84630E6DE6B1004775A4 /* PutPropertySlot.h in Headers */,
                                7E2ADD8E0E79AAD500D50C51 /* CharacterClassConstructor.h in Headers */,
                                140D17D70E8AD4A9000CD17D /* JSBasePrivate.h in Headers */,
                                869EBCB70E8C6D4A008722CC /* ResultType.h in Headers */,
                                14F3488F0E95EF8A003648BC /* CollectorHeapIterator.h in Headers */,
-                               BC9041480EB9250900FE26FA /* StructureIDTransitionTable.h in Headers */,
+                               BC9041480EB9250900FE26FA /* StructureTransitionTable.h in Headers */,
                                960097A60EBABB58007A7297 /* LabelScope.h in Headers */,
                                BC95437D0EBA70FD0072B6D3 /* PropertyMapHashTable.h in Headers */,
                                1C61516D0EBAC7A00031376F /* ProfilerServer.h in Headers */,
-                               7E4EE7090EBB7963005934AA /* StructureIDChain.h in Headers */,
+                               7E4EE7090EBB7963005934AA /* StructureChain.h in Headers */,
                                7EFF00640EC05A9A00AA7C93 /* NodeInfo.h in Headers */,
                                7E4C89140ECA0F9A00DBEEEC /* EvalCodeCache.h in Headers */,
                                FE1B447A0ECCD73B004F4DD1 /* StdLibExtras.h in Headers */,
                                8683B02E0E636482004C19EE /* CTI.cpp in Sources */,
                                869083150E6518D7000D36ED /* WREC.cpp in Sources */,
                                9330402C0E6A764000786E6A /* SmallStrings.cpp in Sources */,
-                               BCDE3B430E6C832D001453A7 /* StructureID.cpp in Sources */,
+                               BCDE3B430E6C832D001453A7 /* Structure.cpp in Sources */,
                                7E2ADD900E79AC1100D50C51 /* CharacterClassConstructor.cpp in Sources */,
                                1C61516C0EBAC7A00031376F /* ProfilerServer.mm in Sources */,
-                               7E4EE70F0EBB7A5B005934AA /* StructureIDChain.cpp in Sources */,
+                               7E4EE70F0EBB7A5B005934AA /* StructureChain.cpp in Sources */,
                        );
                        runOnlyForDeploymentPostprocessing = 0;
                };
index 94f3416..eb5f293 100644 (file)
@@ -141,8 +141,8 @@ Source files for JSCore.
         runtime/StringConstructor.cpp
         runtime/StringObject.cpp
         runtime/StringPrototype.cpp
-        runtime/StructureID.cpp
-        runtime/StructureIDChain.cpp
+        runtime/Structure.cpp
+        runtime/StructureChain.cpp
         runtime/UString.cpp
     </set>
     <set append="1" var="JSCORE_VM_SOURCES">
index 59d84d8..221ab14 100644 (file)
@@ -882,7 +882,7 @@ void CTI::putDoubleResultToJSNumberCellOrJSImmediate(X86::XMMRegisterID xmmSourc
 
 void CTI::compileBinaryArithOp(OpcodeID opcodeID, unsigned dst, unsigned src1, unsigned src2, OperandTypes types, unsigned i)
 {
-    StructureID* numberStructureID = m_globalData->numberStructureID.get();
+    Structure* numberStructure = m_globalData->numberStructure.get();
     X86Assembler::JmpSrc wasJSNumberCell1;
     X86Assembler::JmpSrc wasJSNumberCell1b;
     X86Assembler::JmpSrc wasJSNumberCell2;
@@ -898,7 +898,7 @@ void CTI::compileBinaryArithOp(OpcodeID opcodeID, unsigned dst, unsigned src1, u
         X86Assembler::JmpSrc op2imm = __ emitUnlinkedJne();
         if (!types.second().definitelyIsNumber()) {
             emitJumpSlowCaseIfNotJSCell(X86::edx, i, src2);
-            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructureID), OBJECT_OFFSET(JSCell, m_structureID), X86::edx);
+            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), OBJECT_OFFSET(JSCell, m_structure), X86::edx);
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
         }
 
@@ -908,7 +908,7 @@ void CTI::compileBinaryArithOp(OpcodeID opcodeID, unsigned dst, unsigned src1, u
         X86Assembler::JmpSrc op1imm = __ emitUnlinkedJne();
         if (!types.first().definitelyIsNumber()) {
             emitJumpSlowCaseIfNotJSCell(X86::eax, i, src1);
-            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructureID), OBJECT_OFFSET(JSCell, m_structureID), X86::eax);
+            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
         }
 
@@ -945,7 +945,7 @@ void CTI::compileBinaryArithOp(OpcodeID opcodeID, unsigned dst, unsigned src1, u
         X86Assembler::JmpSrc op1imm = __ emitUnlinkedJne();
         if (!types.first().definitelyIsNumber()) {
             emitJumpSlowCaseIfNotJSCell(X86::eax, i, src1);
-            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructureID), OBJECT_OFFSET(JSCell, m_structureID), X86::eax);
+            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
         }
 
@@ -955,7 +955,7 @@ void CTI::compileBinaryArithOp(OpcodeID opcodeID, unsigned dst, unsigned src1, u
         X86Assembler::JmpSrc op2imm = __ emitUnlinkedJne();
         if (!types.second().definitelyIsNumber()) {
             emitJumpSlowCaseIfNotJSCell(X86::edx, i, src2);
-            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructureID), OBJECT_OFFSET(JSCell, m_structureID), X86::edx);
+            __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), OBJECT_OFFSET(JSCell, m_structure), X86::edx);
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
         }
 
@@ -1218,16 +1218,16 @@ void CTI::privateCompileMainPass()
             break;
         }
         case op_put_by_id: {
-            // In order to be able to repatch both the StructureID, and the object offset, we store one pointer,
+            // In order to be able to repatch both the Structure, and the object offset, we store one pointer,
             // to just after the arguments have been loaded into registers 'hotPathBegin', and we generate code
-            // such that the StructureID & offset are always at the same distance from this.
+            // such that the Structure & offset are always at the same distance from this.
 
             int baseVReg = instruction[i + 1].u.operand;
             emitGetVirtualRegisters(baseVReg, X86::eax, instruction[i + 3].u.operand, X86::edx, i);
 
             ASSERT(m_codeBlock->propertyAccessInstructions[propertyAccessInstructionIndex].bytecodeIndex == i);
 
-            // Jump to a slow case if either the base object is an immediate, or if the StructureID does not match.
+            // Jump to a slow case if either the base object is an immediate, or if the Structure does not match.
             emitJumpSlowCaseIfNotJSCell(X86::eax, i, baseVReg);
 
             X86Assembler::JmpDst hotPathBegin = __ label();
@@ -1235,8 +1235,8 @@ void CTI::privateCompileMainPass()
             ++propertyAccessInstructionIndex;
 
             // It is important that the following instruction plants a 32bit immediate, in order that it can be patched over.
-            __ cmpl_i32m(repatchGetByIdDefaultStructureID, OBJECT_OFFSET(JSCell, m_structureID), X86::eax);
-            ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetPutByIdStructureID);
+            __ cmpl_i32m(repatchGetByIdDefaultStructure, OBJECT_OFFSET(JSCell, m_structure), X86::eax);
+            ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetPutByIdStructure);
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
 
             // Plant a load from a bogus ofset in the object's property map; we will patch this later, if it is to be used.
@@ -1248,7 +1248,7 @@ void CTI::privateCompileMainPass()
             break;
         }
         case op_get_by_id: {
-            // As for put_by_id, get_by_id requires the offset of the StructureID and the offset of the access to be repatched.
+            // As for put_by_id, get_by_id requires the offset of the Structure and the offset of the access to be repatched.
             // Additionally, for get_by_id we need repatch the offset of the branch to the slow case (we repatch this to jump
             // to array-length / prototype access tranpolines, and finally we also the the property-map access offset as a label
             // to jump back to if one of these trampolies finds a match.
@@ -1264,8 +1264,8 @@ void CTI::privateCompileMainPass()
             m_propertyAccessCompilationInfo[propertyAccessInstructionIndex].hotPathBegin = hotPathBegin;
             ++propertyAccessInstructionIndex;
 
-            __ cmpl_i32m(repatchGetByIdDefaultStructureID, OBJECT_OFFSET(JSCell, m_structureID), X86::eax);
-            ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetGetByIdStructureID);
+            __ cmpl_i32m(repatchGetByIdDefaultStructure, OBJECT_OFFSET(JSCell, m_structure), X86::eax);
+            ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetGetByIdStructure);
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
             ASSERT(X86Assembler::getDifferenceBetweenLabels(hotPathBegin, __ label()) == repatchOffsetGetByIdBranchToSlowCase);
 
@@ -1290,21 +1290,21 @@ void CTI::privateCompileMainPass()
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJnz(), i));
 
             // check that all are object type - this is a bit of a bithack to avoid excess branching;
-            // we check that the sum of the three type codes from StructureIDs is exactly 3 * ObjectType,
+            // we check that the sum of the three type codes from Structures is exactly 3 * ObjectType,
             // this works because NumberType and StringType are smaller
             __ movl_i32r(3 * ObjectType, X86::ecx);
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structureID), X86::eax, X86::eax);
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structureID), X86::edx, X86::edx);
-            __ subl_mr(OBJECT_OFFSET(StructureID, m_typeInfo.m_type), X86::eax, X86::ecx);
-            __ subl_mr(OBJECT_OFFSET(StructureID, m_typeInfo.m_type), X86::edx, X86::ecx);
+            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::eax);
+            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::edx, X86::edx);
+            __ subl_mr(OBJECT_OFFSET(Structure, m_typeInfo.m_type), X86::eax, X86::ecx);
+            __ subl_mr(OBJECT_OFFSET(Structure, m_typeInfo.m_type), X86::edx, X86::ecx);
             emitGetVirtualRegister(instruction[i + 3].u.operand, X86::edx, i); // reload baseVal
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structureID), X86::edx, X86::edx);
-            __ cmpl_rm(X86::ecx, OBJECT_OFFSET(StructureID, m_typeInfo.m_type), X86::edx);
+            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::edx, X86::edx);
+            __ cmpl_rm(X86::ecx, OBJECT_OFFSET(Structure, m_typeInfo.m_type), X86::edx);
 
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
 
             // check that baseVal's flags include ImplementsHasInstance but not OverridesHasInstance
-            __ movl_mr(OBJECT_OFFSET(StructureID, m_typeInfo.m_flags), X86::edx, X86::ecx);
+            __ movl_mr(OBJECT_OFFSET(Structure, m_typeInfo.m_flags), X86::edx, X86::ecx);
             __ andl_i32r(ImplementsHasInstance | OverridesHasInstance, X86::ecx);
             __ cmpl_i32r(ImplementsHasInstance, X86::ecx);
 
@@ -1319,8 +1319,8 @@ void CTI::privateCompileMainPass()
             X86Assembler::JmpDst loop = __ label();
 
             // load value's prototype
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structureID), X86::ecx, X86::ecx);
-            __ movl_mr(OBJECT_OFFSET(StructureID, m_prototype), X86::ecx, X86::ecx);
+            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::ecx, X86::ecx);
+            __ movl_mr(OBJECT_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
             
             __ cmpl_rr(X86::ecx, X86::edx);
             X86Assembler::JmpSrc exit = __ emitUnlinkedJe();
@@ -1489,8 +1489,8 @@ void CTI::privateCompileMainPass()
 
             __ testl_i32r(JSImmediate::TagMask, X86::eax);
             X86Assembler::JmpSrc isImmediate = __ emitUnlinkedJne();
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structureID), X86::eax, X86::ecx);
-            __ cmpl_i32m(ObjectType, OBJECT_OFFSET(StructureID, m_typeInfo) + OBJECT_OFFSET(TypeInfo, m_type), X86::ecx);
+            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+            __ cmpl_i32m(ObjectType, OBJECT_OFFSET(Structure, m_typeInfo) + OBJECT_OFFSET(TypeInfo, m_type), X86::ecx);
             X86Assembler::JmpSrc isObject = __ emitUnlinkedJe();
 
             __ link(isImmediate, __ label());
@@ -1623,8 +1623,8 @@ void CTI::privateCompileMainPass()
                 ResultType resultType(instruction[i + 3].u.resultType);
                 if (!resultType.definitelyIsNumber()) {
                     emitJumpSlowCaseIfNotJSCell(X86::eax, i, srcVReg);
-                    StructureID* numberStructureID = m_globalData->numberStructureID.get();
-                    __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructureID), OBJECT_OFFSET(JSCell, m_structureID), X86::eax);
+                    Structure* numberStructure = m_globalData->numberStructure.get();
+                    __ cmpl_i32m(reinterpret_cast<unsigned>(numberStructure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
                     m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
                 }
                 __ movsd_mr(OBJECT_OFFSET(JSNumberCell, m_value), X86::eax, X86::xmm0);
@@ -1656,14 +1656,14 @@ void CTI::privateCompileMainPass()
             // Fast case
             unsigned globalObject = asInteger(instruction[i + 2].u.jsCell);
             Identifier* ident = &(m_codeBlock->identifiers[instruction[i + 3].u.operand]);
-            void* structureIDAddr = reinterpret_cast<void*>(instruction + i + 4);
+            void* structureAddress = reinterpret_cast<void*>(instruction + i + 4);
             void* offsetAddr = reinterpret_cast<void*>(instruction + i + 5);
 
-            // Check StructureID of global object
+            // Check Structure of global object
             __ movl_i32r(globalObject, X86::eax);
-            __ movl_mr(structureIDAddr, X86::edx);
-            __ cmpl_rm(X86::edx, OBJECT_OFFSET(JSCell, m_structureID), X86::eax);
-            X86Assembler::JmpSrc noMatch = __ emitUnlinkedJne(); // StructureIDs don't match
+            __ movl_mr(structureAddress, X86::edx);
+            __ cmpl_rm(X86::edx, OBJECT_OFFSET(JSCell, m_structure), X86::eax);
+            X86Assembler::JmpSrc noMatch = __ emitUnlinkedJne(); // Structures don't match
 
             // Load cached property
             __ movl_mr(OBJECT_OFFSET(JSGlobalObject, m_propertyStorage), X86::eax, X86::eax);
@@ -1748,8 +1748,8 @@ void CTI::privateCompileMainPass()
             __ testl_i32r(JSImmediate::TagMask, X86::eax);
             X86Assembler::JmpSrc isImmediate = __ emitUnlinkedJnz();
 
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structureID), X86::eax, X86::ecx);
-            __ testl_i32m(MasqueradesAsUndefined, OBJECT_OFFSET(StructureID, m_typeInfo.m_flags), X86::ecx);
+            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+            __ testl_i32m(MasqueradesAsUndefined, OBJECT_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
             __ setnz_r(X86::eax);
 
             X86Assembler::JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
@@ -1778,8 +1778,8 @@ void CTI::privateCompileMainPass()
             __ testl_i32r(JSImmediate::TagMask, X86::eax);
             X86Assembler::JmpSrc isImmediate = __ emitUnlinkedJnz();
 
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structureID), X86::eax, X86::ecx);
-            __ testl_i32m(MasqueradesAsUndefined, OBJECT_OFFSET(StructureID, m_typeInfo.m_flags), X86::ecx);
+            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+            __ testl_i32m(MasqueradesAsUndefined, OBJECT_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
             __ setz_r(X86::eax);
 
             X86Assembler::JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
@@ -2069,8 +2069,8 @@ void CTI::privateCompileMainPass()
 
             emitJumpSlowCaseIfNotJSCell(X86::eax, i, srcVReg);
 
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structureID), X86::eax, X86::ecx);
-            __ cmpl_i32m(NumberType, OBJECT_OFFSET(StructureID, m_typeInfo.m_type), X86::ecx);
+            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+            __ cmpl_i32m(NumberType, OBJECT_OFFSET(Structure, m_typeInfo.m_type), X86::ecx);
             
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJne(), i));
             
@@ -2222,8 +2222,8 @@ void CTI::privateCompileMainPass()
             __ testl_i32r(JSImmediate::TagMask, X86::eax);
             X86Assembler::JmpSrc isImmediate = __ emitUnlinkedJnz();
 
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structureID), X86::eax, X86::ecx);
-            __ testl_i32m(MasqueradesAsUndefined, OBJECT_OFFSET(StructureID, m_typeInfo.m_flags), X86::ecx);
+            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+            __ testl_i32m(MasqueradesAsUndefined, OBJECT_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
             __ setnz_r(X86::eax);
 
             X86Assembler::JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
@@ -2252,8 +2252,8 @@ void CTI::privateCompileMainPass()
             __ testl_i32r(JSImmediate::TagMask, X86::eax);
             X86Assembler::JmpSrc isImmediate = __ emitUnlinkedJnz();
 
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structureID), X86::eax, X86::ecx);
-            __ testl_i32m(MasqueradesAsUndefined, OBJECT_OFFSET(StructureID, m_typeInfo.m_flags), X86::ecx);
+            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+            __ testl_i32m(MasqueradesAsUndefined, OBJECT_OFFSET(Structure, m_typeInfo.m_flags), X86::ecx);
             __ setz_r(X86::eax);
 
             X86Assembler::JmpSrc wasNotImmediate = __ emitUnlinkedJmp();
@@ -2308,8 +2308,8 @@ void CTI::privateCompileMainPass()
             emitGetVirtualRegister(instruction[i + 1].u.operand, X86::eax, i);
 
             emitJumpSlowCaseIfNotJSCell(X86::eax, i);
-            __ movl_mr(OBJECT_OFFSET(JSCell, m_structureID), X86::eax, X86::edx);
-            __ testl_i32m(NeedsThisConversion, OBJECT_OFFSET(StructureID, m_typeInfo.m_flags), X86::edx);
+            __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::edx);
+            __ testl_i32m(NeedsThisConversion, OBJECT_OFFSET(Structure, m_typeInfo.m_flags), X86::edx);
             m_slowCases.append(SlowCaseEntry(__ emitUnlinkedJnz(), i));
 
             i += 2;
@@ -3101,12 +3101,12 @@ void CTI::privateCompile()
     m_codeBlock->ctiCode = code;
 }
 
-void CTI::privateCompileGetByIdSelf(StructureID* structureID, size_t cachedOffset, void* returnAddress)
+void CTI::privateCompileGetByIdSelf(Structure* structure, size_t cachedOffset, void* returnAddress)
 {
-    // Check eax is an object of the right StructureID.
+    // Check eax is an object of the right Structure.
     __ testl_i32r(JSImmediate::TagMask, X86::eax);
     X86Assembler::JmpSrc failureCases1 = __ emitUnlinkedJne();
-    __ cmpl_i32m(reinterpret_cast<uint32_t>(structureID), OBJECT_OFFSET(JSCell, m_structureID), X86::eax);
+    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
     X86Assembler::JmpSrc failureCases2 = __ emitUnlinkedJne();
 
     // Checks out okay! - getDirectOffset
@@ -3125,7 +3125,7 @@ void CTI::privateCompileGetByIdSelf(StructureID* structureID, size_t cachedOffse
     ctiRepatchCallByReturnAddress(returnAddress, code);
 }
 
-void CTI::privateCompileGetByIdProto(StructureID* structureID, StructureID* prototypeStructureID, size_t cachedOffset, void* returnAddress, CallFrame* callFrame)
+void CTI::privateCompileGetByIdProto(Structure* structure, Structure* prototypeStructure, size_t cachedOffset, void* returnAddress, CallFrame* callFrame)
 {
 #if USE(CTI_REPATCH_PIC)
     StructureStubInfo& info = m_codeBlock->getStubInfo(returnAddress);
@@ -3133,21 +3133,21 @@ void CTI::privateCompileGetByIdProto(StructureID* structureID, StructureID* prot
     // We don't want to repatch more than once - in future go to cti_op_put_by_id_generic.
     ctiRepatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_get_by_id_fail));
 
-    // The prototype object definitely exists (if this stub exists the CodeBlock is referencing a StructureID that is
+    // The prototype object definitely exists (if this stub exists the CodeBlock is referencing a Structure that is
     // referencing the prototype object - let's speculatively load it's table nice and early!)
-    JSObject* protoObject = asObject(structureID->prototypeForLookup(callFrame));
+    JSObject* protoObject = asObject(structure->prototypeForLookup(callFrame));
     PropertyStorage* protoPropertyStorage = &protoObject->m_propertyStorage;
     __ movl_mr(static_cast<void*>(protoPropertyStorage), X86::edx);
 
-    // check eax is an object of the right StructureID.
+    // check eax is an object of the right Structure.
     __ testl_i32r(JSImmediate::TagMask, X86::eax);
     X86Assembler::JmpSrc failureCases1 = __ emitUnlinkedJne();
-    __ cmpl_i32m(reinterpret_cast<uint32_t>(structureID), OBJECT_OFFSET(JSCell, m_structureID), X86::eax);
+    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
     X86Assembler::JmpSrc failureCases2 = __ emitUnlinkedJne();
 
-    // Check the prototype object's StructureID had not changed.
-    StructureID** protoStructureIDAddress = &(protoObject->m_structureID);
-    __ cmpl_i32m(reinterpret_cast<uint32_t>(prototypeStructureID), static_cast<void*>(protoStructureIDAddress));
+    // Check the prototype object's Structure had not changed.
+    Structure** prototypeStructureAddress = &(protoObject->m_structure);
+    __ cmpl_i32m(reinterpret_cast<uint32_t>(prototypeStructure), static_cast<void*>(prototypeStructureAddress));
     X86Assembler::JmpSrc failureCases3 = __ emitUnlinkedJne();
 
     // Checks out okay! - getDirectOffset
@@ -3176,21 +3176,21 @@ void CTI::privateCompileGetByIdProto(StructureID* structureID, StructureID* prot
     intptr_t jmpLocation = reinterpret_cast<intptr_t>(info.hotPathBegin) + repatchOffsetGetByIdBranchToSlowCase;
     X86Assembler::repatchBranchOffset(jmpLocation, code);
 #else
-    // The prototype object definitely exists (if this stub exists the CodeBlock is referencing a StructureID that is
+    // The prototype object definitely exists (if this stub exists the CodeBlock is referencing a Structure that is
     // referencing the prototype object - let's speculatively load it's table nice and early!)
-    JSObject* protoObject = asObject(structureID->prototypeForLookup(callFrame));
+    JSObject* protoObject = asObject(structure->prototypeForLookup(callFrame));
     PropertyStorage* protoPropertyStorage = &protoObject->m_propertyStorage;
     __ movl_mr(static_cast<void*>(protoPropertyStorage), X86::edx);
 
-    // check eax is an object of the right StructureID.
+    // check eax is an object of the right Structure.
     __ testl_i32r(JSImmediate::TagMask, X86::eax);
     X86Assembler::JmpSrc failureCases1 = __ emitUnlinkedJne();
-    __ cmpl_i32m(reinterpret_cast<uint32_t>(structureID), OBJECT_OFFSET(JSCell, m_structureID), X86::eax);
+    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
     X86Assembler::JmpSrc failureCases2 = __ emitUnlinkedJne();
 
-    // Check the prototype object's StructureID had not changed.
-    StructureID** protoStructureIDAddress = &(protoObject->m_structureID);
-    __ cmpl_i32m(reinterpret_cast<uint32_t>(prototypeStructureID), static_cast<void*>(protoStructureIDAddress));
+    // Check the prototype object's Structure had not changed.
+    Structure** prototypeStructureAddress = &(protoObject->m_structure);
+    __ cmpl_i32m(reinterpret_cast<uint32_t>(prototypeStructure), static_cast<void*>(prototypeStructureAddress));
     X86Assembler::JmpSrc failureCases3 = __ emitUnlinkedJne();
 
     // Checks out okay! - getDirectOffset
@@ -3211,28 +3211,28 @@ void CTI::privateCompileGetByIdProto(StructureID* structureID, StructureID* prot
 #endif
 }
 
-void CTI::privateCompileGetByIdChain(StructureID* structureID, StructureIDChain* chain, size_t count, size_t cachedOffset, void* returnAddress, CallFrame* callFrame)
+void CTI::privateCompileGetByIdChain(Structure* structure, StructureChain* chain, size_t count, size_t cachedOffset, void* returnAddress, CallFrame* callFrame)
 {
     ASSERT(count);
     
     Vector<X86Assembler::JmpSrc> bucketsOfFail;
 
-    // Check eax is an object of the right StructureID.
+    // Check eax is an object of the right Structure.
     __ testl_i32r(JSImmediate::TagMask, X86::eax);
     bucketsOfFail.append(__ emitUnlinkedJne());
-    __ cmpl_i32m(reinterpret_cast<uint32_t>(structureID), OBJECT_OFFSET(JSCell, m_structureID), X86::eax);
+    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
     bucketsOfFail.append(__ emitUnlinkedJne());
 
-    StructureID* currStructureID = structureID;
-    RefPtr<StructureID>* chainEntries = chain->head();
+    Structure* currStructure = structure;
+    RefPtr<Structure>* chainEntries = chain->head();
     JSObject* protoObject = 0;
     for (unsigned i = 0; i<count; ++i) {
-        protoObject = asObject(currStructureID->prototypeForLookup(callFrame));
-        currStructureID = chainEntries[i].get();
+        protoObject = asObject(currStructure->prototypeForLookup(callFrame));
+        currStructure = chainEntries[i].get();
 
-        // Check the prototype object's StructureID had not changed.
-        StructureID** protoStructureIDAddress = &(protoObject->m_structureID);
-        __ cmpl_i32m(reinterpret_cast<uint32_t>(currStructureID), static_cast<void*>(protoStructureIDAddress));
+        // Check the prototype object's Structure had not changed.
+        Structure** prototypeStructureAddress = &(protoObject->m_structure);
+        __ cmpl_i32m(reinterpret_cast<uint32_t>(currStructure), static_cast<void*>(prototypeStructureAddress));
         bucketsOfFail.append(__ emitUnlinkedJne());
     }
     ASSERT(protoObject);
@@ -3255,12 +3255,12 @@ void CTI::privateCompileGetByIdChain(StructureID* structureID, StructureIDChain*
     ctiRepatchCallByReturnAddress(returnAddress, code);
 }
 
-void CTI::privateCompilePutByIdReplace(StructureID* structureID, size_t cachedOffset, void* returnAddress)
+void CTI::privateCompilePutByIdReplace(Structure* structure, size_t cachedOffset, void* returnAddress)
 {
-    // check eax is an object of the right StructureID.
+    // check eax is an object of the right Structure.
     __ testl_i32r(JSImmediate::TagMask, X86::eax);
     X86Assembler::JmpSrc failureCases1 = __ emitUnlinkedJne();
-    __ cmpl_i32m(reinterpret_cast<uint32_t>(structureID), OBJECT_OFFSET(JSCell, m_structureID), X86::eax);
+    __ cmpl_i32m(reinterpret_cast<uint32_t>(structure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
     X86Assembler::JmpSrc failureCases2 = __ emitUnlinkedJne();
 
     // checks out okay! - putDirectOffset
@@ -3289,42 +3289,42 @@ extern "C" {
 
 }
 
-static inline bool transitionWillNeedStorageRealloc(StructureID* oldStructureID, StructureID* newStructureID)
+static inline bool transitionWillNeedStorageRealloc(Structure* oldStructure, Structure* newStructure)
 {
-    return oldStructureID->propertyStorageCapacity() != newStructureID->propertyStorageCapacity();
+    return oldStructure->propertyStorageCapacity() != newStructure->propertyStorageCapacity();
 }
 
-void CTI::privateCompilePutByIdTransition(StructureID* oldStructureID, StructureID* newStructureID, size_t cachedOffset, StructureIDChain* sIDC, void* returnAddress)
+void CTI::privateCompilePutByIdTransition(Structure* oldStructure, Structure* newStructure, size_t cachedOffset, StructureChain* chain, void* returnAddress)
 {
     Vector<X86Assembler::JmpSrc, 16> failureCases;
-    // check eax is an object of the right StructureID.
+    // check eax is an object of the right Structure.
     __ testl_i32r(JSImmediate::TagMask, X86::eax);
     failureCases.append(__ emitUnlinkedJne());
-    __ cmpl_i32m(reinterpret_cast<uint32_t>(oldStructureID), OBJECT_OFFSET(JSCell, m_structureID), X86::eax);
+    __ cmpl_i32m(reinterpret_cast<uint32_t>(oldStructure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
     failureCases.append(__ emitUnlinkedJne());
     Vector<X86Assembler::JmpSrc> successCases;
 
     //  ecx = baseObject
-    __ movl_mr(OBJECT_OFFSET(JSCell, m_structureID), X86::eax, X86::ecx);
-    // proto(ecx) = baseObject->structureID()->prototype()
-    __ cmpl_i32m(ObjectType, OBJECT_OFFSET(StructureID, m_typeInfo) + OBJECT_OFFSET(TypeInfo, m_type), X86::ecx);
+    __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::eax, X86::ecx);
+    // proto(ecx) = baseObject->structure()->prototype()
+    __ cmpl_i32m(ObjectType, OBJECT_OFFSET(Structure, m_typeInfo) + OBJECT_OFFSET(TypeInfo, m_type), X86::ecx);
     failureCases.append(__ emitUnlinkedJne());
-    __ movl_mr(OBJECT_OFFSET(StructureID, m_prototype), X86::ecx, X86::ecx);
+    __ movl_mr(OBJECT_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
     
-    // ecx = baseObject->m_structureID
-    for (RefPtr<StructureID>* it = sIDC->head(); *it; ++it) {
+    // ecx = baseObject->m_structure
+    for (RefPtr<Structure>* it = chain->head(); *it; ++it) {
         // null check the prototype
         __ cmpl_i32r(asInteger(jsNull()), X86::ecx);
         successCases.append(__ emitUnlinkedJe());
 
         // Check the structure id
-        __ cmpl_i32m(reinterpret_cast<uint32_t>(it->get()), OBJECT_OFFSET(JSCell, m_structureID), X86::ecx);
+        __ cmpl_i32m(reinterpret_cast<uint32_t>(it->get()), OBJECT_OFFSET(JSCell, m_structure), X86::ecx);
         failureCases.append(__ emitUnlinkedJne());
         
-        __ movl_mr(OBJECT_OFFSET(JSCell, m_structureID), X86::ecx, X86::ecx);
-        __ cmpl_i32m(ObjectType, OBJECT_OFFSET(StructureID, m_typeInfo) + OBJECT_OFFSET(TypeInfo, m_type), X86::ecx);
+        __ movl_mr(OBJECT_OFFSET(JSCell, m_structure), X86::ecx, X86::ecx);
+        __ cmpl_i32m(ObjectType, OBJECT_OFFSET(Structure, m_typeInfo) + OBJECT_OFFSET(TypeInfo, m_type), X86::ecx);
         failureCases.append(__ emitUnlinkedJne());
-        __ movl_mr(OBJECT_OFFSET(StructureID, m_prototype), X86::ecx, X86::ecx);
+        __ movl_mr(OBJECT_OFFSET(Structure, m_prototype), X86::ecx, X86::ecx);
     }
 
     failureCases.append(__ emitUnlinkedJne());
@@ -3334,10 +3334,10 @@ void CTI::privateCompilePutByIdTransition(StructureID* oldStructureID, Structure
     X86Assembler::JmpSrc callTarget;
 
     // emit a call only if storage realloc is needed
-    if (transitionWillNeedStorageRealloc(oldStructureID, newStructureID)) {
+    if (transitionWillNeedStorageRealloc(oldStructure, newStructure)) {
         __ pushl_r(X86::edx);
-        __ pushl_i32(newStructureID->propertyStorageCapacity());
-        __ pushl_i32(oldStructureID->propertyStorageCapacity());
+        __ pushl_i32(newStructure->propertyStorageCapacity());
+        __ pushl_i32(oldStructure->propertyStorageCapacity());
         __ pushl_r(X86::eax);
         callTarget = __ emitCall();
         __ addl_i32r(3 * sizeof(void*), X86::esp);
@@ -3345,10 +3345,10 @@ void CTI::privateCompilePutByIdTransition(StructureID* oldStructureID, Structure
     }
 
     // Assumes m_refCount can be decremented easily, refcount decrement is safe as 
-    // codeblock should ensure oldStructureID->m_refCount > 0
-    __ subl_i8m(1, reinterpret_cast<void*>(oldStructureID));
-    __ addl_i8m(1, reinterpret_cast<void*>(newStructureID));
-    __ movl_i32m(reinterpret_cast<uint32_t>(newStructureID), OBJECT_OFFSET(JSCell, m_structureID), X86::eax);
+    // codeblock should ensure oldStructure->m_refCount > 0
+    __ subl_i8m(1, reinterpret_cast<void*>(oldStructure));
+    __ addl_i8m(1, reinterpret_cast<void*>(newStructure));
+    __ movl_i32m(reinterpret_cast<uint32_t>(newStructure), OBJECT_OFFSET(JSCell, m_structure), X86::eax);
 
     // write the value
     __ movl_mr(OBJECT_OFFSET(JSObject, m_propertyStorage), X86::eax, X86::eax);
@@ -3370,7 +3370,7 @@ void CTI::privateCompilePutByIdTransition(StructureID* oldStructureID, Structure
     if (failureCases.size())
         X86Assembler::link(code, failureJump, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_put_by_id_fail));
 
-    if (transitionWillNeedStorageRealloc(oldStructureID, newStructureID))
+    if (transitionWillNeedStorageRealloc(oldStructure, newStructure))
         X86Assembler::link(code, callTarget, reinterpret_cast<void*>(resizePropertyStorage));
     
     m_codeBlock->getStubInfo(returnAddress).stubRoutine = code;
@@ -3599,7 +3599,7 @@ void CTI::freeCTIMachineTrampolines(BytecodeInterpreter* interpreter)
     WTF::fastFreeExecutable(interpreter->m_ctiArrayLengthTrampoline);
 }
 
-void CTI::patchGetByIdSelf(CodeBlock* codeBlock, StructureID* structureID, size_t cachedOffset, void* returnAddress)
+void CTI::patchGetByIdSelf(CodeBlock* codeBlock, Structure* structure, size_t cachedOffset, void* returnAddress)
 {
     StructureStubInfo& info = codeBlock->getStubInfo(returnAddress);
 
@@ -3607,12 +3607,12 @@ void CTI::patchGetByIdSelf(CodeBlock* codeBlock, StructureID* structureID, size_
     // Should probably go to BytecodeInterpreter::cti_op_get_by_id_fail, but that doesn't do anything interesting right now.
     ctiRepatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_get_by_id_generic));
 
-    // Repatch the offset into the propoerty map to load from, then repatch the StructureID to look for.
+    // Repatch the offset into the propoerty map to load from, then repatch the Structure to look for.
     X86Assembler::repatchDisplacement(reinterpret_cast<intptr_t>(info.hotPathBegin) + repatchOffsetGetByIdPropertyMapOffset, cachedOffset * sizeof(JSValue*));
-    X86Assembler::repatchImmediate(reinterpret_cast<intptr_t>(info.hotPathBegin) + repatchOffsetGetByIdStructureID, reinterpret_cast<uint32_t>(structureID));
+    X86Assembler::repatchImmediate(reinterpret_cast<intptr_t>(info.hotPathBegin) + repatchOffsetGetByIdStructure, reinterpret_cast<uint32_t>(structure));
 }
 
-void CTI::patchPutByIdReplace(CodeBlock* codeBlock, StructureID* structureID, size_t cachedOffset, void* returnAddress)
+void CTI::patchPutByIdReplace(CodeBlock* codeBlock, Structure* structure, size_t cachedOffset, void* returnAddress)
 {
     StructureStubInfo& info = codeBlock->getStubInfo(returnAddress);
     
@@ -3620,9 +3620,9 @@ void CTI::patchPutByIdReplace(CodeBlock* codeBlock, StructureID* structureID, si
     // Should probably go to BytecodeInterpreter::cti_op_put_by_id_fail, but that doesn't do anything interesting right now.
     ctiRepatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(BytecodeInterpreter::cti_op_put_by_id_generic));
 
-    // Repatch the offset into the propoerty map to load from, then repatch the StructureID to look for.
+    // Repatch the offset into the propoerty map to load from, then repatch the Structure to look for.
     X86Assembler::repatchDisplacement(reinterpret_cast<intptr_t>(info.hotPathBegin) + repatchOffsetPutByIdPropertyMapOffset, cachedOffset * sizeof(JSValue*));
-    X86Assembler::repatchImmediate(reinterpret_cast<intptr_t>(info.hotPathBegin) + repatchOffsetPutByIdStructureID, reinterpret_cast<uint32_t>(structureID));
+    X86Assembler::repatchImmediate(reinterpret_cast<intptr_t>(info.hotPathBegin) + repatchOffsetPutByIdStructure, reinterpret_cast<uint32_t>(structure));
 }
 
 void CTI::privateCompilePatchGetArrayLength(void* returnAddress)
index 1cac114..a1d979d 100644 (file)
@@ -102,7 +102,7 @@ namespace JSC {
     class ScopeChainNode;
     class SimpleJumpTable;
     class StringJumpTable;
-    class StructureIDChain;
+    class StructureChain;
 
     struct CallLinkInfo;
     struct Instruction;
@@ -256,7 +256,7 @@ namespace JSC {
     void ctiRepatchCallByReturnAddress(void* where, void* what);
 
     class CTI {
-        static const int repatchGetByIdDefaultStructureID = -1;
+        static const int repatchGetByIdDefaultStructure = -1;
         // Magic number - initial offset cannot be representable as a signed 8bit value, or the X86Assembler
         // will compress the displacement, and we may not be able to fit a repatched offset.
         static const int repatchGetByIdDefaultOffset = 256;
@@ -269,10 +269,10 @@ namespace JSC {
         static const int ctiArgumentInitSize = 0;
 #endif
         // These architecture specific value are used to enable repatching - see comment on op_put_by_id.
-        static const int repatchOffsetPutByIdStructureID = 7;
+        static const int repatchOffsetPutByIdStructure = 7;
         static const int repatchOffsetPutByIdPropertyMapOffset = 22;
         // These architecture specific value are used to enable repatching - see comment on op_get_by_id.
-        static const int repatchOffsetGetByIdStructureID = 7;
+        static const int repatchOffsetGetByIdStructure = 7;
         static const int repatchOffsetGetByIdBranchToSlowCase = 13;
         static const int repatchOffsetGetByIdPropertyMapOffset = 22;
 #if ENABLE(OPCODE_SAMPLING)
@@ -289,34 +289,34 @@ namespace JSC {
             cti.privateCompile();
         }
 
-        static void compileGetByIdSelf(JSGlobalData* globalData, CodeBlock* codeBlock, StructureID* structureID, size_t cachedOffset, void* returnAddress)
+        static void compileGetByIdSelf(JSGlobalData* globalData, CodeBlock* codeBlock, Structure* structure, size_t cachedOffset, void* returnAddress)
         {
             CTI cti(globalData, codeBlock);
-            cti.privateCompileGetByIdSelf(structureID, cachedOffset, returnAddress);
+            cti.privateCompileGetByIdSelf(structure, cachedOffset, returnAddress);
         }
 
-        static void compileGetByIdProto(JSGlobalData* globalData, CallFrame* callFrame, CodeBlock* codeBlock, StructureID* structureID, StructureID* prototypeStructureID, size_t cachedOffset, void* returnAddress)
+        static void compileGetByIdProto(JSGlobalData* globalData, CallFrame* callFrame, CodeBlock* codeBlock, Structure* structure, Structure* prototypeStructure, size_t cachedOffset, void* returnAddress)
         {
             CTI cti(globalData, codeBlock);
-            cti.privateCompileGetByIdProto(structureID, prototypeStructureID, cachedOffset, returnAddress, callFrame);
+            cti.privateCompileGetByIdProto(structure, prototypeStructure, cachedOffset, returnAddress, callFrame);
         }
 
-        static void compileGetByIdChain(JSGlobalData* globalData, CallFrame* callFrame, CodeBlock* codeBlock, StructureID* structureID, StructureIDChain* chain, size_t count, size_t cachedOffset, void* returnAddress)
+        static void compileGetByIdChain(JSGlobalData* globalData, CallFrame* callFrame, CodeBlock* codeBlock, Structure* structure, StructureChain* chain, size_t count, size_t cachedOffset, void* returnAddress)
         {
             CTI cti(globalData, codeBlock);
-            cti.privateCompileGetByIdChain(structureID, chain, count, cachedOffset, returnAddress, callFrame);
+            cti.privateCompileGetByIdChain(structure, chain, count, cachedOffset, returnAddress, callFrame);
         }
 
-        static void compilePutByIdReplace(JSGlobalData* globalData, CodeBlock* codeBlock, StructureID* structureID, size_t cachedOffset, void* returnAddress)
+        static void compilePutByIdReplace(JSGlobalData* globalData, CodeBlock* codeBlock, Structure* structure, size_t cachedOffset, void* returnAddress)
         {
             CTI cti(globalData, codeBlock);
-            cti.privateCompilePutByIdReplace(structureID, cachedOffset, returnAddress);
+            cti.privateCompilePutByIdReplace(structure, cachedOffset, returnAddress);
         }
         
-        static void compilePutByIdTransition(JSGlobalData* globalData, CodeBlock* codeBlock, StructureID* oldStructureID, StructureID* newStructureID, size_t cachedOffset, StructureIDChain* sIDC, void* returnAddress)
+        static void compilePutByIdTransition(JSGlobalData* globalData, CodeBlock* codeBlock, Structure* oldStructure, Structure* newStructure, size_t cachedOffset, StructureChain* chain, void* returnAddress)
         {
             CTI cti(globalData, codeBlock);
-            cti.privateCompilePutByIdTransition(oldStructureID, newStructureID, cachedOffset, sIDC, returnAddress);
+            cti.privateCompilePutByIdTransition(oldStructure, newStructure, cachedOffset, chain, returnAddress);
         }
 
         static void compileCTIMachineTrampolines(JSGlobalData* globalData)
@@ -326,8 +326,8 @@ namespace JSC {
         }
         static void freeCTIMachineTrampolines(BytecodeInterpreter*);
 
-        static void patchGetByIdSelf(CodeBlock* codeBlock, StructureID* structureID, size_t cachedOffset, void* returnAddress);
-        static void patchPutByIdReplace(CodeBlock* codeBlock, StructureID* structureID, size_t cachedOffset, void* returnAddress);
+        static void patchGetByIdSelf(CodeBlock* codeBlock, Structure* structure, size_t cachedOffset, void* returnAddress);
+        static void patchPutByIdReplace(CodeBlock* codeBlock, Structure* structure, size_t cachedOffset, void* returnAddress);
 
         static void compilePatchGetArrayLength(JSGlobalData* globalData, CodeBlock* codeBlock, void* returnAddress)
         {
@@ -350,11 +350,11 @@ namespace JSC {
         void privateCompileLinkPass();
         void privateCompileSlowCases();
         void privateCompile();
-        void privateCompileGetByIdSelf(StructureID*, size_t cachedOffset, void* returnAddress);
-        void privateCompileGetByIdProto(StructureID*, StructureID* prototypeStructureID, size_t cachedOffset, void* returnAddress, CallFrame* callFrame);
-        void privateCompileGetByIdChain(StructureID*, StructureIDChain*, size_t count, size_t cachedOffset, void* returnAddress, CallFrame* callFrame);
-        void privateCompilePutByIdReplace(StructureID*, size_t cachedOffset, void* returnAddress);
-        void privateCompilePutByIdTransition(StructureID*, StructureID*, size_t cachedOffset, StructureIDChain*, void* returnAddress);
+        void privateCompileGetByIdSelf(Structure*, size_t cachedOffset, void* returnAddress);
+        void privateCompileGetByIdProto(Structure*, Structure* prototypeStructure, size_t cachedOffset, void* returnAddress, CallFrame* callFrame);
+        void privateCompileGetByIdChain(Structure*, StructureChain*, size_t count, size_t cachedOffset, void* returnAddress, CallFrame* callFrame);
+        void privateCompilePutByIdReplace(Structure*, size_t cachedOffset, void* returnAddress);
+        void privateCompilePutByIdTransition(Structure*, Structure*, size_t cachedOffset, StructureChain*, void* returnAddress);
 
         void privateCompileCTIMachineTrampolines();
         void privateCompilePatchGetArrayLength(void* returnAddress);
index ae093a8..c925f91 100644 (file)
@@ -173,51 +173,51 @@ static void printPutByIdOp(int location, Vector<Instruction>::const_iterator& it
     it += 4;
 }
 
-void CodeBlock::printStructureID(const char* name, const Instruction* vPC, int operand) const
+void CodeBlock::printStructure(const char* name, const Instruction* vPC, int operand) const
 {
     unsigned instructionOffset = vPC - instructions.begin();
-    printf("  [%4d] %s: %s\n", instructionOffset, name, pointerToSourceString(vPC[operand].u.structureID).UTF8String().c_str());
+    printf("  [%4d] %s: %s\n", instructionOffset, name, pointerToSourceString(vPC[operand].u.structure).UTF8String().c_str());
 }
 
-void CodeBlock::printStructureIDs(const Instruction* vPC) const
+void CodeBlock::printStructures(const Instruction* vPC) const
 {
     BytecodeInterpreter* interpreter = globalData->interpreter;
     unsigned instructionOffset = vPC - instructions.begin();
 
     if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id)) {
-        printStructureID("get_by_id", vPC, 4);
+        printStructure("get_by_id", vPC, 4);
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_self)) {
-        printStructureID("get_by_id_self", vPC, 4);
+        printStructure("get_by_id_self", vPC, 4);
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_proto)) {
-        printf("  [%4d] %s: %s, %s\n", instructionOffset, "get_by_id_proto", pointerToSourceString(vPC[4].u.structureID).UTF8String().c_str(), pointerToSourceString(vPC[5].u.structureID).UTF8String().c_str());
+        printf("  [%4d] %s: %s, %s\n", instructionOffset, "get_by_id_proto", pointerToSourceString(vPC[4].u.structure).UTF8String().c_str(), pointerToSourceString(vPC[5].u.structure).UTF8String().c_str());
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_transition)) {
-        printf("  [%4d] %s: %s, %s, %s\n", instructionOffset, "put_by_id_new", pointerToSourceString(vPC[4].u.structureID).UTF8String().c_str(), pointerToSourceString(vPC[5].u.structureID).UTF8String().c_str(), pointerToSourceString(vPC[6].u.structureIDChain).UTF8String().c_str());
+        printf("  [%4d] %s: %s, %s, %s\n", instructionOffset, "put_by_id_new", pointerToSourceString(vPC[4].u.structure).UTF8String().c_str(), pointerToSourceString(vPC[5].u.structure).UTF8String().c_str(), pointerToSourceString(vPC[6].u.structureChain).UTF8String().c_str());
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_chain)) {
-        printf("  [%4d] %s: %s, %s\n", instructionOffset, "get_by_id_chain", pointerToSourceString(vPC[4].u.structureID).UTF8String().c_str(), pointerToSourceString(vPC[5].u.structureIDChain).UTF8String().c_str());
+        printf("  [%4d] %s: %s, %s\n", instructionOffset, "get_by_id_chain", pointerToSourceString(vPC[4].u.structure).UTF8String().c_str(), pointerToSourceString(vPC[5].u.structureChain).UTF8String().c_str());
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id)) {
-        printStructureID("put_by_id", vPC, 4);
+        printStructure("put_by_id", vPC, 4);
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_replace)) {
-        printStructureID("put_by_id_replace", vPC, 4);
+        printStructure("put_by_id_replace", vPC, 4);
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_resolve_global)) {
-        printStructureID("resolve_global", vPC, 4);
+        printStructure("resolve_global", vPC, 4);
         return;
     }
 
-    // These instructions doesn't ref StructureIDs.
+    // These instructions doesn't ref Structures.
     ASSERT(vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_generic) || vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_generic) || vPC[0].u.opcode == interpreter->getOpcode(op_call) || vPC[0].u.opcode == interpreter->getOpcode(op_call_eval) || vPC[0].u.opcode == interpreter->getOpcode(op_construct));
 }
 
@@ -278,19 +278,19 @@ void CodeBlock::dump(ExecState* exec) const
     }
 
     if (globalResolveInstructions.size() || propertyAccessInstructions.size())
-        printf("\nStructureIDs:\n");
+        printf("\nStructures:\n");
 
     if (globalResolveInstructions.size()) {
         size_t i = 0;
         do {
-             printStructureIDs(&instructions[globalResolveInstructions[i]]);
+             printStructures(&instructions[globalResolveInstructions[i]]);
              ++i;
         } while (i < globalResolveInstructions.size());
     }
     if (propertyAccessInstructions.size()) {
         size_t i = 0;
         do {
-             printStructureIDs(&instructions[propertyAccessInstructions[i].bytecodeIndex]);
+             printStructures(&instructions[propertyAccessInstructions[i].bytecodeIndex]);
              ++i;
         } while (i < propertyAccessInstructions.size());
     }
@@ -950,11 +950,11 @@ void CodeBlock::dump(ExecState* exec, const Vector<Instruction>::const_iterator&
 CodeBlock::~CodeBlock()
 {
     for (size_t size = globalResolveInstructions.size(), i = 0; i < size; ++i) {
-        derefStructureIDs(&instructions[globalResolveInstructions[i]]);
+        derefStructures(&instructions[globalResolveInstructions[i]]);
     }
 
     for (size_t size = propertyAccessInstructions.size(), i = 0; i < size; ++i) {
-        derefStructureIDs(&instructions[propertyAccessInstructions[i].bytecodeIndex]);
+        derefStructures(&instructions[propertyAccessInstructions[i].bytecodeIndex]);
         if (propertyAccessInstructions[i].stubRoutine)
             WTF::fastFreeExecutable(propertyAccessInstructions[i].stubRoutine);
     }
@@ -986,74 +986,74 @@ void CodeBlock::unlinkCallers()
 }
 #endif
 
-void CodeBlock::derefStructureIDs(Instruction* vPC) const
+void CodeBlock::derefStructures(Instruction* vPC) const
 {
     BytecodeInterpreter* interpreter = globalData->interpreter;
 
     if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_self)) {
-        vPC[4].u.structureID->deref();
+        vPC[4].u.structure->deref();
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_proto)) {
-        vPC[4].u.structureID->deref();
-        vPC[5].u.structureID->deref();
+        vPC[4].u.structure->deref();
+        vPC[5].u.structure->deref();
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_chain)) {
-        vPC[4].u.structureID->deref();
-        vPC[5].u.structureIDChain->deref();
+        vPC[4].u.structure->deref();
+        vPC[5].u.structureChain->deref();
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_transition)) {
-        vPC[4].u.structureID->deref();
-        vPC[5].u.structureID->deref();
-        vPC[6].u.structureIDChain->deref();
+        vPC[4].u.structure->deref();
+        vPC[5].u.structure->deref();
+        vPC[6].u.structureChain->deref();
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_replace)) {
-        vPC[4].u.structureID->deref();
+        vPC[4].u.structure->deref();
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_resolve_global)) {
-        if(vPC[4].u.structureID)
-            vPC[4].u.structureID->deref();
+        if(vPC[4].u.structure)
+            vPC[4].u.structure->deref();
         return;
     }
     
-    // These instructions don't ref their StructureIDs.
+    // These instructions don't ref their Structures.
     ASSERT(vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id) || vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id) || vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_generic) || vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_generic) || vPC[0].u.opcode == interpreter->getOpcode(op_get_array_length) || vPC[0].u.opcode == interpreter->getOpcode(op_get_string_length));
 }
 
-void CodeBlock::refStructureIDs(Instruction* vPC) const
+void CodeBlock::refStructures(Instruction* vPC) const
 {
     BytecodeInterpreter* interpreter = globalData->interpreter;
 
     if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_self)) {
-        vPC[4].u.structureID->ref();
+        vPC[4].u.structure->ref();
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_proto)) {
-        vPC[4].u.structureID->ref();
-        vPC[5].u.structureID->ref();
+        vPC[4].u.structure->ref();
+        vPC[5].u.structure->ref();
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_chain)) {
-        vPC[4].u.structureID->ref();
-        vPC[5].u.structureIDChain->ref();
+        vPC[4].u.structure->ref();
+        vPC[5].u.structureChain->ref();
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_transition)) {
-        vPC[4].u.structureID->ref();
-        vPC[5].u.structureID->ref();
-        vPC[6].u.structureIDChain->ref();
+        vPC[4].u.structure->ref();
+        vPC[5].u.structure->ref();
+        vPC[6].u.structureChain->ref();
         return;
     }
     if (vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_replace)) {
-        vPC[4].u.structureID->ref();
+        vPC[4].u.structure->ref();
         return;
     }
     
-    // These instructions don't ref their StructureIDs.
+    // These instructions don't ref their Structures.
     ASSERT(vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id) || vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id) || vPC[0].u.opcode == interpreter->getOpcode(op_get_by_id_generic) || vPC[0].u.opcode == interpreter->getOpcode(op_put_by_id_generic));
 }
 
index 754996a..98ef12a 100644 (file)
@@ -288,8 +288,8 @@ namespace JSC {
 
 #if !defined(NDEBUG) || ENABLE_OPCODE_SAMPLING
         void dump(ExecState*) const;
-        void printStructureIDs(const Instruction*) const;
-        void printStructureID(const char* name, const Instruction*, int operand) const;
+        void printStructures(const Instruction*) const;
+        void printStructure(const char* name, const Instruction*, int operand) const;
 #endif
         int expressionRangeForVPC(const Instruction*, int& divot, int& startOffset, int& endOffset);
         int lineNumberForVPC(const Instruction* vPC);
@@ -297,8 +297,8 @@ namespace JSC {
         void* nativeExceptionCodeForHandlerVPC(const Instruction* handlerVPC);
 
         void mark();
-        void refStructureIDs(Instruction* vPC) const;
-        void derefStructureIDs(Instruction* vPC) const;
+        void refStructures(Instruction* vPC) const;
+        void derefStructures(Instruction* vPC) const;
 
         StructureStubInfo& getStubInfo(void* returnAddress)
         {
index 6e32c06..6a66406 100644 (file)
@@ -36,8 +36,8 @@
 namespace JSC {
 
     class JSCell;
-    class StructureID;
-    class StructureIDChain;
+    class Structure;
+    class StructureChain;
 
     struct Instruction {
         Instruction(Opcode opcode) { u.opcode = opcode; }
@@ -49,15 +49,15 @@ namespace JSC {
             u.operand = operand;
         }
 
-        Instruction(StructureID* structureID) { u.structureID = structureID; }
-        Instruction(StructureIDChain* structureIDChain) { u.structureIDChain = structureIDChain; }
+        Instruction(Structure* structure) { u.structure = structure; }
+        Instruction(StructureChain* structureChain) { u.structureChain = structureChain; }
         Instruction(JSCell* jsCell) { u.jsCell = jsCell; }
 
         union {
             Opcode opcode;
             int operand;
-            StructureID* structureID;
-            StructureIDChain* structureIDChain;
+            Structure* structure;
+            StructureChain* structureChain;
             JSCell* jsCell;
             ResultType::Type resultType;
         } u;
index 3e568a9..9d4c5a7 100644 (file)
@@ -286,7 +286,7 @@ static JSValue* jsTypeStringForValue(CallFrame* callFrame, JSValue* v)
     if (v->isObject()) {
         // Return "undefined" for objects that should be treated
         // as null when doing comparisons.
-        if (asObject(v)->structureID()->typeInfo().masqueradesAsUndefined())
+        if (asObject(v)->structure()->typeInfo().masqueradesAsUndefined())
             return jsNontrivialString(callFrame, "undefined");
         CallData callData;
         if (asObject(v)->getCallData(callData) != CallTypeNone)
@@ -300,11 +300,11 @@ static bool jsIsObjectType(JSValue* v)
     if (JSImmediate::isImmediate(v))
         return v->isNull();
 
-    JSType type = asCell(v)->structureID()->typeInfo().type();
+    JSType type = asCell(v)->structure()->typeInfo().type();
     if (type == NumberType || type == StringType)
         return false;
     if (type == ObjectType) {
-        if (asObject(v)->structureID()->typeInfo().masqueradesAsUndefined())
+        if (asObject(v)->structure()->typeInfo().masqueradesAsUndefined())
             return false;
         CallData callData;
         if (asObject(v)->getCallData(callData) != CallTypeNone)
@@ -390,10 +390,10 @@ NEVER_INLINE bool BytecodeInterpreter::resolveGlobal(CallFrame* callFrame, Instr
     JSGlobalObject* globalObject = static_cast<JSGlobalObject*>((vPC + 2)->u.jsCell);
     ASSERT(globalObject->isGlobalObject());
     int property = (vPC + 3)->u.operand;
-    StructureID* structureID = (vPC + 4)->u.structureID;
+    Structure* structure = (vPC + 4)->u.structure;
     int offset = (vPC + 5)->u.operand;
 
-    if (structureID == globalObject->structureID()) {
+    if (structure == globalObject->structure()) {
         callFrame[dst] = globalObject->getDirectOffset(offset);
         return true;
     }
@@ -404,10 +404,10 @@ NEVER_INLINE bool BytecodeInterpreter::resolveGlobal(CallFrame* callFrame, Instr
     if (globalObject->getPropertySlot(callFrame, ident, slot)) {
         JSValue* result = slot.getValue(callFrame, ident);
         if (slot.isCacheable()) {
-            if (vPC[4].u.structureID)
-                vPC[4].u.structureID->deref();
-            globalObject->structureID()->ref();
-            vPC[4] = globalObject->structureID();
+            if (vPC[4].u.structure)
+                vPC[4].u.structure->deref();
+            globalObject->structure()->ref();
+            vPC[4] = globalObject->structure();
             vPC[5] = slot.cachedOffset();
             callFrame[dst] = result;
             return true;
@@ -626,7 +626,7 @@ BytecodeInterpreter::BytecodeInterpreter()
     // Bizarrely, calling fastMalloc here is faster than allocating space on the stack.
     void* storage = fastMalloc(sizeof(CollectorBlock));
 
-    JSCell* jsArray = new (storage) JSArray(JSArray::createStructureID(jsNull()));
+    JSCell* jsArray = new (storage) JSArray(JSArray::createStructure(jsNull()));
     m_jsArrayVptr = jsArray->vptr();
     jsArray->~JSCell();
 
@@ -634,7 +634,7 @@ BytecodeInterpreter::BytecodeInterpreter()
     m_jsStringVptr = jsString->vptr();
     jsString->~JSCell();
 
-    JSCell* jsFunction = new (storage) JSFunction(JSFunction::createStructureID(jsNull()));
+    JSCell* jsFunction = new (storage) JSFunction(JSFunction::createStructure(jsNull()));
     m_jsFunctionVptr = jsFunction->vptr();
     jsFunction->~JSCell();
     
@@ -1236,14 +1236,14 @@ NEVER_INLINE ScopeChainNode* BytecodeInterpreter::createExceptionScope(CallFrame
     return callFrame->scopeChain()->push(scope);
 }
 
-static StructureIDChain* cachePrototypeChain(CallFrame* callFrame, StructureID* structureID)
+static StructureChain* cachePrototypeChain(CallFrame* callFrame, Structure* structure)
 {
-    JSValue* prototype = structureID->prototypeForLookup(callFrame);
+    JSValue* prototype = structure->prototypeForLookup(callFrame);
     if (JSImmediate::isImmediate(prototype))
         return 0;
-    RefPtr<StructureIDChain> chain = StructureIDChain::create(asObject(prototype)->structureID());
-    structureID->setCachedPrototypeChain(chain.release());
-    return structureID->cachedPrototypeChain();
+    RefPtr<StructureChain> chain = StructureChain::create(asObject(prototype)->structure());
+    structure->setCachedPrototypeChain(chain.release());
+    return structure->cachedPrototypeChain();
 }
 
 NEVER_INLINE void BytecodeInterpreter::tryCachePutByID(CallFrame* callFrame, CodeBlock* codeBlock, Instruction* vPC, JSValue* baseValue, const PutPropertySlot& slot)
@@ -1262,19 +1262,19 @@ NEVER_INLINE void BytecodeInterpreter::tryCachePutByID(CallFrame* callFrame, Cod
     }
     
     JSCell* baseCell = asCell(baseValue);
-    StructureID* structureID = baseCell->structureID();
+    Structure* structure = baseCell->structure();
 
-    if (structureID->isDictionary()) {
+    if (structure->isDictionary()) {
         vPC[0] = getOpcode(op_put_by_id_generic);
         return;
     }
 
-    // Cache miss: record StructureID to compare against next time.
-    StructureID* lastStructureID = vPC[4].u.structureID;
-    if (structureID != lastStructureID) {
-        // First miss: record StructureID to compare against next time.
-        if (!lastStructureID) {
-            vPC[4] = structureID;
+    // Cache miss: record Structure to compare against next time.
+    Structure* lastStructure = vPC[4].u.structure;
+    if (structure != lastStructure) {
+        // First miss: record Structure to compare against next time.
+        if (!lastStructure) {
+            vPC[4] = structure;
             return;
         }
 
@@ -1283,7 +1283,7 @@ NEVER_INLINE void BytecodeInterpreter::tryCachePutByID(CallFrame* callFrame, Cod
         return;
     }
 
-    // Cache hit: Specialize instruction and ref StructureIDs.
+    // Cache hit: Specialize instruction and ref Structures.
 
     // If baseCell != slot.base(), then baseCell must be a proxy for another object.
     if (baseCell != slot.base()) {
@@ -1291,14 +1291,14 @@ NEVER_INLINE void BytecodeInterpreter::tryCachePutByID(CallFrame* callFrame, Cod
         return;
     }
 
-    // StructureID transition, cache transition info
+    // Structure transition, cache transition info
     if (slot.type() == PutPropertySlot::NewProperty) {
         vPC[0] = getOpcode(op_put_by_id_transition);
-        vPC[4] = structureID->previousID();
-        vPC[5] = structureID;
-        StructureIDChain* chain = structureID->cachedPrototypeChain();
+        vPC[4] = structure->previousID();
+        vPC[5] = structure;
+        StructureChain* chain = structure->cachedPrototypeChain();
         if (!chain) {
-            chain = cachePrototypeChain(callFrame, structureID);
+            chain = cachePrototypeChain(callFrame, structure);
             if (!chain) {
                 // This happens if someone has manually inserted null into the prototype chain
                 vPC[0] = getOpcode(op_put_by_id_generic);
@@ -1307,18 +1307,18 @@ NEVER_INLINE void BytecodeInterpreter::tryCachePutByID(CallFrame* callFrame, Cod
         }
         vPC[6] = chain;
         vPC[7] = slot.cachedOffset();
-        codeBlock->refStructureIDs(vPC);
+        codeBlock->refStructures(vPC);
         return;
     }
 
     vPC[0] = getOpcode(op_put_by_id_replace);
     vPC[5] = slot.cachedOffset();
-    codeBlock->refStructureIDs(vPC);
+    codeBlock->refStructures(vPC);
 }
 
 NEVER_INLINE void BytecodeInterpreter::uncachePutByID(CodeBlock* codeBlock, Instruction* vPC)
 {
-    codeBlock->derefStructureIDs(vPC);
+    codeBlock->derefStructures(vPC);
     vPC[0] = getOpcode(op_put_by_id);
     vPC[4] = 0;
 }
@@ -1351,19 +1351,19 @@ NEVER_INLINE void BytecodeInterpreter::tryCacheGetByID(CallFrame* callFrame, Cod
         return;
     }
 
-    StructureID* structureID = asCell(baseValue)->structureID();
+    Structure* structure = asCell(baseValue)->structure();
 
-    if (structureID->isDictionary()) {
+    if (structure->isDictionary()) {
         vPC[0] = getOpcode(op_get_by_id_generic);
         return;
     }
 
     // Cache miss
-    StructureID* lastStructureID = vPC[4].u.structureID;
-    if (structureID != lastStructureID) {
-        // First miss: record StructureID to compare against next time.
-        if (!lastStructureID) {
-            vPC[4] = structureID;
+    Structure* lastStructure = vPC[4].u.structure;
+    if (structure != lastStructure) {
+        // First miss: record Structure to compare against next time.
+        if (!lastStructure) {
+            vPC[4] = structure;
             return;
         }
 
@@ -1372,41 +1372,41 @@ NEVER_INLINE void BytecodeInterpreter::tryCacheGetByID(CallFrame* callFrame, Cod
         return;
     }
 
-    // Cache hit: Specialize instruction and ref StructureIDs.
+    // Cache hit: Specialize instruction and ref Structures.
 
     if (slot.slotBase() == baseValue) {
         vPC[0] = getOpcode(op_get_by_id_self);
         vPC[5] = slot.cachedOffset();
 
-        codeBlock->refStructureIDs(vPC);
+        codeBlock->refStructures(vPC);
         return;
     }
 
-    if (slot.slotBase() == structureID->prototypeForLookup(callFrame)) {
+    if (slot.slotBase() == structure->prototypeForLookup(callFrame)) {
         ASSERT(slot.slotBase()->isObject());
 
         JSObject* baseObject = asObject(slot.slotBase());
 
         // Heavy access to a prototype is a good indication that it's not being
         // used as a dictionary.
-        if (baseObject->structureID()->isDictionary()) {
-            RefPtr<StructureID> transition = StructureID::fromDictionaryTransition(baseObject->structureID());
-            baseObject->setStructureID(transition.release());
-            asCell(baseValue)->structureID()->setCachedPrototypeChain(0);
+        if (baseObject->structure()->isDictionary()) {
+            RefPtr<Structure> transition = Structure::fromDictionaryTransition(baseObject->structure());
+            baseObject->setStructure(transition.release());
+            asCell(baseValue)->structure()->setCachedPrototypeChain(0);
         }
 
         vPC[0] = getOpcode(op_get_by_id_proto);
-        vPC[5] = baseObject->structureID();
+        vPC[5] = baseObject->structure();
         vPC[6] = slot.cachedOffset();
 
-        codeBlock->refStructureIDs(vPC);
+        codeBlock->refStructures(vPC);
         return;
     }
 
     size_t count = 0;
     JSObject* o = asObject(baseValue);
     while (slot.slotBase() != o) {
-        JSValue* v = o->structureID()->prototypeForLookup(callFrame);
+        JSValue* v = o->structure()->prototypeForLookup(callFrame);
 
         // If we didn't find base in baseValue's prototype chain, then baseValue
         // must be a proxy for another object.
@@ -1419,31 +1419,31 @@ NEVER_INLINE void BytecodeInterpreter::tryCacheGetByID(CallFrame* callFrame, Cod
 
         // Heavy access to a prototype is a good indication that it's not being
         // used as a dictionary.
-        if (o->structureID()->isDictionary()) {
-            RefPtr<StructureID> transition = StructureID::fromDictionaryTransition(o->structureID());
-            o->setStructureID(transition.release());
-            asObject(baseValue)->structureID()->setCachedPrototypeChain(0);
+        if (o->structure()->isDictionary()) {
+            RefPtr<Structure> transition = Structure::fromDictionaryTransition(o->structure());
+            o->setStructure(transition.release());
+            asObject(baseValue)->structure()->setCachedPrototypeChain(0);
         }
 
         ++count;
     }
 
-    StructureIDChain* chain = structureID->cachedPrototypeChain();
+    StructureChain* chain = structure->cachedPrototypeChain();
     if (!chain)
-        chain = cachePrototypeChain(callFrame, structureID);
+        chain = cachePrototypeChain(callFrame, structure);
     ASSERT(chain);
 
     vPC[0] = getOpcode(op_get_by_id_chain);
-    vPC[4] = structureID;
+    vPC[4] = structure;
     vPC[5] = chain;
     vPC[6] = count;
     vPC[7] = slot.cachedOffset();
-    codeBlock->refStructureIDs(vPC);
+    codeBlock->refStructures(vPC);
 }
 
 NEVER_INLINE void BytecodeInterpreter::uncacheGetByID(CodeBlock* codeBlock, Instruction* vPC)
 {
-    codeBlock->derefStructureIDs(vPC);
+    codeBlock->derefStructures(vPC);
     vPC[0] = getOpcode(op_get_by_id);
     vPC[4] = 0;
 }
@@ -1619,7 +1619,7 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
             NEXT_INSTRUCTION;
         }
         
-        callFrame[dst] = jsBoolean(!JSImmediate::isImmediate(src) && src->asCell()->structureID()->typeInfo().masqueradesAsUndefined());
+        callFrame[dst] = jsBoolean(!JSImmediate::isImmediate(src) && src->asCell()->structure()->typeInfo().masqueradesAsUndefined());
         ++vPC;
         NEXT_INSTRUCTION;
     }
@@ -1659,7 +1659,7 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
             NEXT_INSTRUCTION;
         }
         
-        callFrame[dst] = jsBoolean(JSImmediate::isImmediate(src) || !asCell(src)->structureID()->typeInfo().masqueradesAsUndefined());
+        callFrame[dst] = jsBoolean(JSImmediate::isImmediate(src) || !asCell(src)->structure()->typeInfo().masqueradesAsUndefined());
         ++vPC;
         NEXT_INSTRUCTION;
     }
@@ -2191,7 +2191,7 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
             goto vm_throw;
 
         JSObject* baseObj = asObject(baseVal);
-        callFrame[dst] = jsBoolean(baseObj->structureID()->typeInfo().implementsHasInstance() ? baseObj->hasInstance(callFrame, callFrame[value].jsValue(callFrame), callFrame[baseProto].jsValue(callFrame)) : false);
+        callFrame[dst] = jsBoolean(baseObj->structure()->typeInfo().implementsHasInstance() ? baseObj->hasInstance(callFrame, callFrame[value].jsValue(callFrame), callFrame[baseProto].jsValue(callFrame)) : false);
 
         vPC += 5;
         NEXT_INSTRUCTION;
@@ -2219,7 +2219,7 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
         int dst = (++vPC)->u.operand;
         int src = (++vPC)->u.operand;
         JSValue* v = callFrame[src].jsValue(callFrame);
-        callFrame[dst] = jsBoolean(JSImmediate::isImmediate(v) ? v->isUndefined() : v->asCell()->structureID()->typeInfo().masqueradesAsUndefined());
+        callFrame[dst] = jsBoolean(JSImmediate::isImmediate(v) ? v->isUndefined() : v->asCell()->structure()->typeInfo().masqueradesAsUndefined());
 
         ++vPC;
         NEXT_INSTRUCTION;
@@ -2355,12 +2355,12 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
         NEXT_INSTRUCTION;
     }
     DEFINE_OPCODE(op_resolve_global) {
-        /* resolve_skip dst(r) globalObject(c) property(id) structureID(sID) offset(n)
+        /* resolve_skip dst(r) globalObject(c) property(id) structure(sID) offset(n)
          
            Performs a dynamic property lookup for the given property, on the provided
-           global object.  If structureID matches the StructureID of the global then perform
+           global object.  If structure matches the Structure of the global then perform
            a fast lookup using the case offset, otherwise fall back to a full resolve and
-           cache the new structureID and offset
+           cache the new structure and offset
          */
         if (UNLIKELY(!resolveGlobal(callFrame, vPC, exceptionValue)))
             goto vm_throw;
@@ -2498,7 +2498,7 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
         NEXT_INSTRUCTION;
     }
     DEFINE_OPCODE(op_get_by_id) {
-        /* get_by_id dst(r) base(r) property(id) structureID(sID) nop(n) nop(n) nop(n)
+        /* get_by_id dst(r) base(r) property(id) structure(sID) nop(n) nop(n) nop(n)
 
            Generic property access: Gets the property named by identifier
            property from the value base, and puts the result in register dst.
@@ -2521,7 +2521,7 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
         NEXT_INSTRUCTION;
     }
     DEFINE_OPCODE(op_get_by_id_self) {
-        /* op_get_by_id_self dst(r) base(r) property(id) structureID(sID) offset(n) nop(n) nop(n)
+        /* op_get_by_id_self dst(r) base(r) property(id) structure(sID) offset(n) nop(n) nop(n)
 
            Cached property access: Attempts to get a cached property from the
            value base. If the cache misses, op_get_by_id_self reverts to
@@ -2532,9 +2532,9 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
 
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
             JSCell* baseCell = asCell(baseValue);
-            StructureID* structureID = vPC[4].u.structureID;
+            Structure* structure = vPC[4].u.structure;
 
-            if (LIKELY(baseCell->structureID() == structureID)) {
+            if (LIKELY(baseCell->structure() == structure)) {
                 ASSERT(baseCell->isObject());
                 JSObject* baseObject = asObject(baseCell);
                 int dst = vPC[1].u.operand;
@@ -2552,7 +2552,7 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
         NEXT_INSTRUCTION;
     }
     DEFINE_OPCODE(op_get_by_id_proto) {
-        /* op_get_by_id_proto dst(r) base(r) property(id) structureID(sID) protoStructureID(sID) offset(n) nop(n)
+        /* op_get_by_id_proto dst(r) base(r) property(id) structure(sID) prototypeStructure(sID) offset(n) nop(n)
 
            Cached property access: Attempts to get a cached property from the
            value base's prototype. If the cache misses, op_get_by_id_proto
@@ -2563,14 +2563,14 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
 
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
             JSCell* baseCell = asCell(baseValue);
-            StructureID* structureID = vPC[4].u.structureID;
+            Structure* structure = vPC[4].u.structure;
 
-            if (LIKELY(baseCell->structureID() == structureID)) {
-                ASSERT(structureID->prototypeForLookup(callFrame)->isObject());
-                JSObject* protoObject = asObject(structureID->prototypeForLookup(callFrame));
-                StructureID* protoStructureID = vPC[5].u.structureID;
+            if (LIKELY(baseCell->structure() == structure)) {
+                ASSERT(structure->prototypeForLookup(callFrame)->isObject());
+                JSObject* protoObject = asObject(structure->prototypeForLookup(callFrame));
+                Structure* prototypeStructure = vPC[5].u.structure;
 
-                if (LIKELY(protoObject->structureID() == protoStructureID)) {
+                if (LIKELY(protoObject->structure() == prototypeStructure)) {
                     int dst = vPC[1].u.operand;
                     int offset = vPC[6].u.operand;
 
@@ -2587,7 +2587,7 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
         NEXT_INSTRUCTION;
     }
     DEFINE_OPCODE(op_get_by_id_chain) {
-        /* op_get_by_id_chain dst(r) base(r) property(id) structureID(sID) structureIDChain(sIDc) count(n) offset(n)
+        /* op_get_by_id_chain dst(r) base(r) property(id) structure(sID) structureChain(chain) count(n) offset(n)
 
            Cached property access: Attempts to get a cached property from the
            value base's prototype chain. If the cache misses, op_get_by_id_chain
@@ -2598,17 +2598,17 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
 
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
             JSCell* baseCell = asCell(baseValue);
-            StructureID* structureID = vPC[4].u.structureID;
+            Structure* structure = vPC[4].u.structure;
 
-            if (LIKELY(baseCell->structureID() == structureID)) {
-                RefPtr<StructureID>* it = vPC[5].u.structureIDChain->head();
+            if (LIKELY(baseCell->structure() == structure)) {
+                RefPtr<Structure>* it = vPC[5].u.structureChain->head();
                 size_t count = vPC[6].u.operand;
-                RefPtr<StructureID>* end = it + count;
+                RefPtr<Structure>* end = it + count;
 
                 JSObject* baseObject = asObject(baseCell);
                 while (1) {
-                    baseObject = asObject(baseObject->structureID()->prototypeForLookup(callFrame));
-                    if (UNLIKELY(baseObject->structureID() != (*it).get()))
+                    baseObject = asObject(baseObject->structure()->prototypeForLookup(callFrame));
+                    if (UNLIKELY(baseObject->structure() != (*it).get()))
                         break;
 
                     if (++it == end) {
@@ -2715,7 +2715,7 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
         NEXT_INSTRUCTION;
     }
     DEFINE_OPCODE(op_put_by_id_transition) {
-        /* op_put_by_id_transition base(r) property(id) value(r) oldStructureID(sID) newStructureID(sID) structureIDChain(sIDc) offset(n)
+        /* op_put_by_id_transition base(r) property(id) value(r) oldStructure(sID) newStructure(sID) structureChain(chain) offset(n)
          
            Cached property access: Attempts to set a new property with a cached transition
            property named by identifier property, belonging to register base,
@@ -2730,26 +2730,26 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
         
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
             JSCell* baseCell = asCell(baseValue);
-            StructureID* oldStructureID = vPC[4].u.structureID;
-            StructureID* newStructureID = vPC[5].u.structureID;
+            Structure* oldStructure = vPC[4].u.structure;
+            Structure* newStructure = vPC[5].u.structure;
             
-            if (LIKELY(baseCell->structureID() == oldStructureID)) {
+            if (LIKELY(baseCell->structure() == oldStructure)) {
                 ASSERT(baseCell->isObject());
                 JSObject* baseObject = asObject(baseCell);
 
-                RefPtr<StructureID>* it = vPC[6].u.structureIDChain->head();
+                RefPtr<Structure>* it = vPC[6].u.structureChain->head();
 
-                JSValue* proto = baseObject->structureID()->prototypeForLookup(callFrame);
+                JSValue* proto = baseObject->structure()->prototypeForLookup(callFrame);
                 while (!proto->isNull()) {
-                    if (UNLIKELY(asObject(proto)->structureID() != (*it).get())) {
+                    if (UNLIKELY(asObject(proto)->structure() != (*it).get())) {
                         uncachePutByID(callFrame->codeBlock(), vPC);
                         NEXT_INSTRUCTION;
                     }
                     ++it;
-                    proto = asObject(proto)->structureID()->prototypeForLookup(callFrame);
+                    proto = asObject(proto)->structure()->prototypeForLookup(callFrame);
                 }
 
-                baseObject->transitionTo(newStructureID);
+                baseObject->transitionTo(newStructure);
 
                 int value = vPC[3].u.operand;
                 unsigned offset = vPC[7].u.operand;
@@ -2765,7 +2765,7 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
         NEXT_INSTRUCTION;
     }
     DEFINE_OPCODE(op_put_by_id_replace) {
-        /* op_put_by_id_replace base(r) property(id) value(r) structureID(sID) offset(n) nop(n) nop(n)
+        /* op_put_by_id_replace base(r) property(id) value(r) structure(sID) offset(n) nop(n) nop(n)
 
            Cached property access: Attempts to set a pre-existing, cached
            property named by identifier property, belonging to register base,
@@ -2780,9 +2780,9 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
 
         if (LIKELY(!JSImmediate::isImmediate(baseValue))) {
             JSCell* baseCell = asCell(baseValue);
-            StructureID* structureID = vPC[4].u.structureID;
+            Structure* structure = vPC[4].u.structure;
 
-            if (LIKELY(baseCell->structureID() == structureID)) {
+            if (LIKELY(baseCell->structure() == structure)) {
                 ASSERT(baseCell->isObject());
                 JSObject* baseObject = asObject(baseCell);
                 int value = vPC[3].u.operand;
@@ -3068,7 +3068,7 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
         int target = (++vPC)->u.operand;
         JSValue* srcValue = callFrame[src].jsValue(callFrame);
 
-        if (srcValue->isUndefinedOrNull() || (!JSImmediate::isImmediate(srcValue) && srcValue->asCell()->structureID()->typeInfo().masqueradesAsUndefined())) {
+        if (srcValue->isUndefinedOrNull() || (!JSImmediate::isImmediate(srcValue) && srcValue->asCell()->structure()->typeInfo().masqueradesAsUndefined())) {
             vPC += target;
             NEXT_INSTRUCTION;
         }
@@ -3086,7 +3086,7 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
         int target = (++vPC)->u.operand;
         JSValue* srcValue = callFrame[src].jsValue(callFrame);
 
-        if (!srcValue->isUndefinedOrNull() || (!JSImmediate::isImmediate(srcValue) && !srcValue->asCell()->structureID()->typeInfo().masqueradesAsUndefined())) {
+        if (!srcValue->isUndefinedOrNull() || (!JSImmediate::isImmediate(srcValue) && !srcValue->asCell()->structure()->typeInfo().masqueradesAsUndefined())) {
             vPC += target;
             NEXT_INSTRUCTION;
         }
@@ -3577,7 +3577,7 @@ JSValue* BytecodeInterpreter::privateExecute(ExecutionFlag flag, RegisterFile* r
             FunctionBodyNode* functionBodyNode = constructData.js.functionBody;
             CodeBlock* newCodeBlock = &functionBodyNode->bytecode(callDataScopeChain);
 
-            StructureID* structure;
+            Structure* structure;
             JSValue* prototype = callFrame[proto].jsValue(callFrame);
             if (prototype->isObject())
                 structure = asObject(prototype)->inheritorID();
@@ -4072,9 +4072,9 @@ NEVER_INLINE void BytecodeInterpreter::tryCTICachePutByID(CallFrame* callFrame,
     }
     
     JSCell* baseCell = asCell(baseValue);
-    StructureID* structureID = baseCell->structureID();
+    Structure* structure = baseCell->structure();
 
-    if (structureID->isDictionary()) {
+    if (structure->isDictionary()) {
         ctiRepatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(cti_op_put_by_id_generic));
         return;
     }
@@ -4085,7 +4085,7 @@ NEVER_INLINE void BytecodeInterpreter::tryCTICachePutByID(CallFrame* callFrame,
     unsigned vPCIndex = codeBlock->ctiReturnAddressVPCMap.get(returnAddress);
     Instruction* vPC = codeBlock->instructions.begin() + vPCIndex;
 
-    // Cache hit: Specialize instruction and ref StructureIDs.
+    // Cache hit: Specialize instruction and ref Structures.
 
     // If baseCell != base, then baseCell must be a proxy for another object.
     if (baseCell != slot.base()) {
@@ -4093,14 +4093,14 @@ NEVER_INLINE void BytecodeInterpreter::tryCTICachePutByID(CallFrame* callFrame,
         return;
     }
 
-    // StructureID transition, cache transition info
+    // Structure transition, cache transition info
     if (slot.type() == PutPropertySlot::NewProperty) {
         vPC[0] = getOpcode(op_put_by_id_transition);
-        vPC[4] = structureID->previousID();
-        vPC[5] = structureID;
-        StructureIDChain* chain = structureID->cachedPrototypeChain();
+        vPC[4] = structure->previousID();
+        vPC[5] = structure;
+        StructureChain* chain = structure->cachedPrototypeChain();
         if (!chain) {
-            chain = cachePrototypeChain(callFrame, structureID);
+            chain = cachePrototypeChain(callFrame, structure);
             if (!chain) {
                 // This happens if someone has manually inserted null into the prototype chain
                 vPC[0] = getOpcode(op_put_by_id_generic);
@@ -4109,21 +4109,21 @@ NEVER_INLINE void BytecodeInterpreter::tryCTICachePutByID(CallFrame* callFrame,
         }
         vPC[6] = chain;
         vPC[7] = slot.cachedOffset();
-        codeBlock->refStructureIDs(vPC);
-        CTI::compilePutByIdTransition(callFrame->scopeChain()->globalData, codeBlock, structureID->previousID(), structureID, slot.cachedOffset(), chain, returnAddress);
+        codeBlock->refStructures(vPC);
+        CTI::compilePutByIdTransition(callFrame->scopeChain()->globalData, codeBlock, structure->previousID(), structure, slot.cachedOffset(), chain, returnAddress);
         return;
     }
     
     vPC[0] = getOpcode(op_put_by_id_replace);
-    vPC[4] = structureID;
+    vPC[4] = structure;
     vPC[5] = slot.cachedOffset();
-    codeBlock->refStructureIDs(vPC);
+    codeBlock->refStructures(vPC);
 
 #if USE(CTI_REPATCH_PIC)
     UNUSED_PARAM(callFrame);
-    CTI::patchPutByIdReplace(codeBlock, structureID, slot.cachedOffset(), returnAddress);
+    CTI::patchPutByIdReplace(codeBlock, structure, slot.cachedOffset(), returnAddress);
 #else
-    CTI::compilePutByIdReplace(callFrame->scopeChain()->globalData, callFrame, codeBlock, structureID, slot.cachedOffset(), returnAddress);
+    CTI::compilePutByIdReplace(callFrame->scopeChain()->globalData, callFrame, codeBlock, structure, slot.cachedOffset(), returnAddress);
 #endif
 }
 
@@ -4160,9 +4160,9 @@ NEVER_INLINE void BytecodeInterpreter::tryCTICacheGetByID(CallFrame* callFrame,
     }
 
     JSCell* baseCell = asCell(baseValue);
-    StructureID* structureID = baseCell->structureID();
+    Structure* structure = baseCell->structure();
 
-    if (structureID->isDictionary()) {
+    if (structure->isDictionary()) {
         ctiRepatchCallByReturnAddress(returnAddress, reinterpret_cast<void*>(cti_op_get_by_id_generic));
         return;
     }
@@ -4173,50 +4173,50 @@ NEVER_INLINE void BytecodeInterpreter::tryCTICacheGetByID(CallFrame* callFrame,
     unsigned vPCIndex = codeBlock->ctiReturnAddressVPCMap.get(returnAddress);
     Instruction* vPC = codeBlock->instructions.begin() + vPCIndex;
 
-    // Cache hit: Specialize instruction and ref StructureIDs.
+    // Cache hit: Specialize instruction and ref Structures.
 
     if (slot.slotBase() == baseValue) {
-        // set this up, so derefStructureIDs can do it's job.
+        // set this up, so derefStructures can do it's job.
         vPC[0] = getOpcode(op_get_by_id_self);
-        vPC[4] = structureID;
+        vPC[4] = structure;
         vPC[5] = slot.cachedOffset();
-        codeBlock->refStructureIDs(vPC);
+        codeBlock->refStructures(vPC);
         
 #if USE(CTI_REPATCH_PIC)
-        CTI::patchGetByIdSelf(codeBlock, structureID, slot.cachedOffset(), returnAddress);
+        CTI::patchGetByIdSelf(codeBlock, structure, slot.cachedOffset(), returnAddress);
 #else
-        CTI::compileGetByIdSelf(callFrame->scopeChain()->globalData, callFrame, codeBlock, structureID, slot.cachedOffset(), returnAddress);
+        CTI::compileGetByIdSelf(callFrame->scopeChain()->globalData, callFrame, codeBlock, structure, slot.cachedOffset(), returnAddress);
 #endif
         return;
     }
 
-    if (slot.slotBase() == structureID->prototypeForLookup(callFrame)) {
+    if (slot.slotBase() == structure->prototypeForLookup(callFrame)) {
         ASSERT(slot.slotBase()->isObject());
 
         JSObject* slotBaseObject = asObject(slot.slotBase());
 
         // Heavy access to a prototype is a good indication that it's not being
         // used as a dictionary.
-        if (slotBaseObject->structureID()->isDictionary()) {
-            RefPtr<StructureID> transition = StructureID::fromDictionaryTransition(slotBaseObject->structureID());
-            slotBaseObject->setStructureID(transition.release());
-            asObject(baseValue)->structureID()->setCachedPrototypeChain(0);
+        if (slotBaseObject->structure()->isDictionary()) {
+            RefPtr<Structure> transition = Structure::fromDictionaryTransition(slotBaseObject->structure());
+            slotBaseObject->setStructure(transition.release());
+            asObject(baseValue)->structure()->setCachedPrototypeChain(0);
         }
 
         vPC[0] = getOpcode(op_get_by_id_proto);
-        vPC[4] = structureID;
-        vPC[5] = slotBaseObject->structureID();
+        vPC[4] = structure;
+        vPC[5] = slotBaseObject->structure();
         vPC[6] = slot.cachedOffset();
-        codeBlock->refStructureIDs(vPC);
+        codeBlock->refStructures(vPC);
 
-        CTI::compileGetByIdProto(callFrame->scopeChain()->globalData, callFrame, codeBlock, structureID, slotBaseObject->structureID(), slot.cachedOffset(), returnAddress);
+        CTI::compileGetByIdProto(callFrame->scopeChain()->globalData, callFrame, codeBlock, structure, slotBaseObject->structure(), slot.cachedOffset(), returnAddress);
         return;
     }
 
     size_t count = 0;
     JSObject* o = asObject(baseValue);
     while (slot.slotBase() != o) {
-        JSValue* v = o->structureID()->prototypeForLookup(callFrame);
+        JSValue* v = o->structure()->prototypeForLookup(callFrame);
 
         // If we didn't find slotBase in baseValue's prototype chain, then baseValue
         // must be a proxy for another object.
@@ -4230,28 +4230,28 @@ NEVER_INLINE void BytecodeInterpreter::tryCTICacheGetByID(CallFrame* callFrame,
 
         // Heavy access to a prototype is a good indication that it's not being
         // used as a dictionary.
-        if (o->structureID()->isDictionary()) {
-            RefPtr<StructureID> transition = StructureID::fromDictionaryTransition(o->structureID());
-            o->setStructureID(transition.release());
-            asObject(baseValue)->structureID()->setCachedPrototypeChain(0);
+        if (o->structure()->isDictionary()) {
+            RefPtr<Structure> transition = Structure::fromDictionaryTransition(o->structure());
+            o->setStructure(transition.release());
+            asObject(baseValue)->structure()->setCachedPrototypeChain(0);
         }
 
         ++count;
     }
 
-    StructureIDChain* chain = structureID->cachedPrototypeChain();
+    StructureChain* chain = structure->cachedPrototypeChain();
     if (!chain)
-        chain = cachePrototypeChain(callFrame, structureID);
+        chain = cachePrototypeChain(callFrame, structure);
 
     ASSERT(chain);
     vPC[0] = getOpcode(op_get_by_id_chain);
-    vPC[4] = structureID;
+    vPC[4] = structure;
     vPC[5] = chain;
     vPC[6] = count;
     vPC[7] = slot.cachedOffset();
-    codeBlock->refStructureIDs(vPC);
+    codeBlock->refStructures(vPC);
 
-    CTI::compileGetByIdChain(callFrame->scopeChain()->globalData, callFrame, codeBlock, structureID, chain, count, slot.cachedOffset(), returnAddress);
+    CTI::compileGetByIdChain(callFrame->scopeChain()->globalData, callFrame, codeBlock, structure, chain, count, slot.cachedOffset(), returnAddress);
 }
 
 #ifndef NDEBUG
@@ -4608,7 +4608,7 @@ JSValue* BytecodeInterpreter::cti_op_instanceof(CTI_ARGS)
     // at least one of these checks must have failed to get to the slow case
     ASSERT(JSImmediate::isAnyImmediate(value, baseVal, proto) 
            || !value->isObject() || !baseVal->isObject() || !proto->isObject() 
-           || (asObject(baseVal)->structureID()->typeInfo().flags() & (ImplementsHasInstance | OverridesHasInstance)) != ImplementsHasInstance);
+           || (asObject(baseVal)->structure()->typeInfo().flags() & (ImplementsHasInstance | OverridesHasInstance)) != ImplementsHasInstance);
 
     if (!baseVal->isObject()) {
         CallFrame* callFrame = ARG_callFrame;
@@ -4619,7 +4619,7 @@ JSValue* BytecodeInterpreter::cti_op_instanceof(CTI_ARGS)
         VM_THROW_EXCEPTION();
     }
 
-    if (!asObject(baseVal)->structureID()->typeInfo().implementsHasInstance())
+    if (!asObject(baseVal)->structure()->typeInfo().implementsHasInstance())
         return jsBoolean(false);
 
     if (!proto->isObject()) {
@@ -4928,7 +4928,7 @@ JSObject* BytecodeInterpreter::cti_op_construct_JSConstruct(CTI_ARGS)
     ASSERT(asFunction(ARG_src1)->getConstructData(constructData) == ConstructTypeJS);
 #endif
 
-    StructureID* structure;
+    Structure* structure;
     if (ARG_src4->isObject())
         structure = asObject(ARG_src4)->inheritorID();
     else
@@ -5218,10 +5218,10 @@ JSValue* BytecodeInterpreter::cti_op_resolve_global(CTI_ARGS)
     if (globalObject->getPropertySlot(callFrame, ident, slot)) {
         JSValue* result = slot.getValue(callFrame, ident);
         if (slot.isCacheable()) {
-            if (vPC[4].u.structureID)
-                vPC[4].u.structureID->deref();
-            globalObject->structureID()->ref();
-            vPC[4] = globalObject->structureID();
+            if (vPC[4].u.structure)
+                vPC[4].u.structure->deref();
+            globalObject->structure()->ref();
+            vPC[4] = globalObject->structure();
             vPC[5] = slot.cachedOffset();
             return result;
         }
@@ -5661,7 +5661,7 @@ JSValue* BytecodeInterpreter::cti_op_is_undefined(CTI_ARGS)
     CTI_STACK_HACK();
 
     JSValue* v = ARG_src1;
-    return jsBoolean(JSImmediate::isImmediate(v) ? v->isUndefined() : v->asCell()->structureID()->typeInfo().masqueradesAsUndefined());
+    return jsBoolean(JSImmediate::isImmediate(v) ? v->isUndefined() : v->asCell()->structure()->typeInfo().masqueradesAsUndefined());
 }
 
 JSValue* BytecodeInterpreter::cti_op_is_boolean(CTI_ARGS)
index ae1d6fd..8a88158 100644 (file)
@@ -73,9 +73,9 @@ namespace JSC {
             d->registers = &activation->registerAt(0);
         }
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* prototype) 
+        static PassRefPtr<Structure> createStructure(JSValue* prototype) 
         { 
-            return StructureID::create(prototype, TypeInfo(ObjectType)); 
+            return Structure::create(prototype, TypeInfo(ObjectType)); 
         }
 
     private:
index a9949ba..0cd62aa 100644 (file)
@@ -32,7 +32,7 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(ArrayConstructor);
 
-ArrayConstructor::ArrayConstructor(ExecState* exec, PassRefPtr<StructureID> structure, ArrayPrototype* arrayPrototype)
+ArrayConstructor::ArrayConstructor(ExecState* exec, PassRefPtr<Structure> structure, ArrayPrototype* arrayPrototype)
     : InternalFunction(&exec->globalData(), structure, Identifier(exec, arrayPrototype->classInfo()->className))
 {
     // ECMA 15.4.3.1 Array.prototype
index 6f0f866..8300d8c 100644 (file)
@@ -29,7 +29,7 @@ namespace JSC {
 
     class ArrayConstructor : public InternalFunction {
     public:
-        ArrayConstructor(ExecState*, PassRefPtr<StructureID>, ArrayPrototype*);
+        ArrayConstructor(ExecState*, PassRefPtr<Structure>, ArrayPrototype*);
 
         virtual ConstructType getConstructData(ConstructData&);
         virtual CallType getCallData(CallData&);
index 65c3cb8..6764e7d 100644 (file)
@@ -91,7 +91,7 @@ const ClassInfo ArrayPrototype::info = {"Array", &JSArray::info, 0, ExecState::a
 */
 
 // ECMA 15.4.4
-ArrayPrototype::ArrayPrototype(PassRefPtr<StructureID> structure)
+ArrayPrototype::ArrayPrototype(PassRefPtr<Structure> structure)
     : JSArray(structure)
 {
 }
index 95f69c7..2165089 100644 (file)
@@ -28,7 +28,7 @@ namespace JSC {
 
     class ArrayPrototype : public JSArray {
     public:
-        explicit ArrayPrototype(PassRefPtr<StructureID>);
+        explicit ArrayPrototype(PassRefPtr<Structure>);
 
         bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
 
index 536d09c..13dd95c 100644 (file)
@@ -37,13 +37,13 @@ namespace JSC {
         BatchedTransitionOptimizer(JSObject* object)
             : m_object(object)
         {
-            if (!m_object->structureID()->isDictionary())
-                m_object->setStructureID(StructureID::toDictionaryTransition(m_object->structureID()));
+            if (!m_object->structure()->isDictionary())
+                m_object->setStructure(Structure::toDictionaryTransition(m_object->structure()));
         }
 
         ~BatchedTransitionOptimizer()
         {
-            m_object->setStructureID(StructureID::fromDictionaryTransition(m_object->structureID()));
+            m_object->setStructure(Structure::fromDictionaryTransition(m_object->structure()));
         }
 
     private:
index 46a6018..8ec55c2 100644 (file)
@@ -28,7 +28,7 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(BooleanConstructor);
 
-BooleanConstructor::BooleanConstructor(ExecState* exec, PassRefPtr<StructureID> structure, BooleanPrototype* booleanPrototype)
+BooleanConstructor::BooleanConstructor(ExecState* exec, PassRefPtr<Structure> structure, BooleanPrototype* booleanPrototype)
     : InternalFunction(&exec->globalData(), structure, Identifier(exec, booleanPrototype->classInfo()->className))
 {
     putDirectWithoutTransition(exec->propertyNames().prototype, booleanPrototype, DontEnum | DontDelete | ReadOnly);
index 3b1f1a0..5350732 100644 (file)
@@ -29,7 +29,7 @@ namespace JSC {
 
     class BooleanConstructor : public InternalFunction {
     public:
-        BooleanConstructor(ExecState*, PassRefPtr<StructureID>, BooleanPrototype*);
+        BooleanConstructor(ExecState*, PassRefPtr<Structure>, BooleanPrototype*);
 
     private:
         virtual ConstructType getConstructData(ConstructData&);
index 2ebfb1b..01f695a 100644 (file)
@@ -27,7 +27,7 @@ ASSERT_CLASS_FITS_IN_CELL(BooleanObject);
 
 const ClassInfo BooleanObject::info = { "Boolean", 0, 0, 0 };
 
-BooleanObject::BooleanObject(PassRefPtr<StructureID> structure)
+BooleanObject::BooleanObject(PassRefPtr<Structure> structure)
     : JSWrapperObject(structure)
 {
 }
index 5963b28..3017f69 100644 (file)
@@ -27,7 +27,7 @@ namespace JSC {
 
     class BooleanObject : public JSWrapperObject {
     public:
-        explicit BooleanObject(PassRefPtr<StructureID>);
+        explicit BooleanObject(PassRefPtr<Structure>);
 
         virtual const ClassInfo* classInfo() const { return &info; }
         static const ClassInfo info;
index b47aeac..1903d36 100644 (file)
@@ -36,7 +36,7 @@ static JSValue* booleanProtoFuncValueOf(ExecState*, JSObject*, JSValue*, const A
 
 // ECMA 15.6.4
 
-BooleanPrototype::BooleanPrototype(ExecState* exec, PassRefPtr<StructureID> structure, StructureID* prototypeFunctionStructure)
+BooleanPrototype::BooleanPrototype(ExecState* exec, PassRefPtr<Structure> structure, Structure* prototypeFunctionStructure)
     : BooleanObject(structure)
 {
     setInternalValue(jsBoolean(false));
index 484bb7d..16f80b5 100644 (file)
@@ -27,7 +27,7 @@ namespace JSC {
 
     class BooleanPrototype : public BooleanObject {
     public:
-        BooleanPrototype(ExecState*, PassRefPtr<StructureID>, StructureID* prototypeFunctionStructure);
+        BooleanPrototype(ExecState*, PassRefPtr<Structure>, Structure* prototypeFunctionStructure);
     };
 
 } // namespace JSC
index 8339ff3..629a00c 100644 (file)
@@ -51,7 +51,7 @@ static JSValue* dateParse(ExecState*, JSObject*, JSValue*, const ArgList&);
 static JSValue* dateNow(ExecState*, JSObject*, JSValue*, const ArgList&);
 static JSValue* dateUTC(ExecState*, JSObject*, JSValue*, const ArgList&);
 
-DateConstructor::DateConstructor(ExecState* exec, PassRefPtr<StructureID> structure, StructureID* prototypeFunctionStructure, DatePrototype* datePrototype)
+DateConstructor::DateConstructor(ExecState* exec, PassRefPtr<Structure> structure, Structure* prototypeFunctionStructure, DatePrototype* datePrototype)
     : InternalFunction(&exec->globalData(), structure, Identifier(exec, datePrototype->classInfo()->className))
 {
       putDirectWithoutTransition(exec->propertyNames().prototype, datePrototype, DontEnum|DontDelete|ReadOnly);
index 1279f82..dcef3cc 100644 (file)
@@ -29,7 +29,7 @@ namespace JSC {
 
     class DateConstructor : public InternalFunction {
     public:
-        DateConstructor(ExecState*, PassRefPtr<StructureID>, StructureID* prototypeFunctionStructure, DatePrototype*);
+        DateConstructor(ExecState*, PassRefPtr<Structure>, Structure* prototypeFunctionStructure, DatePrototype*);
 
     private:
         virtual ConstructType getConstructData(ConstructData&);
index b38c6ef..8806dec 100644 (file)
@@ -37,7 +37,7 @@ struct DateInstance::Cache {
 
 const ClassInfo DateInstance::info = {"Date", 0, 0, 0};
 
-DateInstance::DateInstance(PassRefPtr<StructureID> structure)
+DateInstance::DateInstance(PassRefPtr<Structure> structure)
     : JSWrapperObject(structure)
     , m_cache(0)
 {
index 98f4b64..6e3c53e 100644 (file)
@@ -29,7 +29,7 @@ namespace JSC {
 
     class DateInstance : public JSWrapperObject {
     public:
-        explicit DateInstance(PassRefPtr<StructureID>);
+        explicit DateInstance(PassRefPtr<Structure>);
         virtual ~DateInstance();
 
         double internalNumber() const { return internalValue()->uncheckedGetNumber(); }
index a3e792e..c32cc48 100644 (file)
@@ -345,7 +345,7 @@ const ClassInfo DatePrototype::info = {"Date", &DateInstance::info, 0, ExecState
 */
 // ECMA 15.9.4
 
-DatePrototype::DatePrototype(ExecState* exec, PassRefPtr<StructureID> structure)
+DatePrototype::DatePrototype(ExecState* exec, PassRefPtr<Structure> structure)
     : DateInstance(structure)
 {
     setInternalValue(jsNaN(exec));
index 500b40d..9c320c9 100644 (file)
@@ -29,16 +29,16 @@ namespace JSC {
 
     class DatePrototype : public DateInstance {
     public:
-        DatePrototype(ExecState*, PassRefPtr<StructureID>);
+        DatePrototype(ExecState*, PassRefPtr<Structure>);
 
         virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
 
         virtual const ClassInfo* classInfo() const { return &info; }
         static const ClassInfo info;
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* prototype)
+        static PassRefPtr<Structure> createStructure(JSValue* prototype)
         {
-            return StructureID::create(prototype, TypeInfo(ObjectType));
+            return Structure::create(prototype, TypeInfo(ObjectType));
         }
     };
 
index 3c83fd4..7df2319 100644 (file)
@@ -29,7 +29,7 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(ErrorConstructor);
 
-ErrorConstructor::ErrorConstructor(ExecState* exec, PassRefPtr<StructureID> structure, ErrorPrototype* errorPrototype)
+ErrorConstructor::ErrorConstructor(ExecState* exec, PassRefPtr<Structure> structure, ErrorPrototype* errorPrototype)
     : InternalFunction(&exec->globalData(), structure, Identifier(exec, errorPrototype->classInfo()->className))
 {
     // ECMA 15.11.3.1 Error.prototype
index 45e4bb0..2dd4124 100644 (file)
@@ -30,7 +30,7 @@ namespace JSC {
 
     class ErrorConstructor : public InternalFunction {
     public:
-        ErrorConstructor(ExecState*, PassRefPtr<StructureID>, ErrorPrototype*);
+        ErrorConstructor(ExecState*, PassRefPtr<Structure>, ErrorPrototype*);
 
     private:
         virtual ConstructType getConstructData(ConstructData&);
index 1c55856..2e2cdce 100644 (file)
@@ -25,7 +25,7 @@ namespace JSC {
 
 const ClassInfo ErrorInstance::info = { "Error", 0, 0, 0 };
 
-ErrorInstance::ErrorInstance(PassRefPtr<StructureID> structure)
+ErrorInstance::ErrorInstance(PassRefPtr<Structure> structure)
     : JSObject(structure)
 {
 }
index 8d86eec..6f9d262 100644 (file)
@@ -27,7 +27,7 @@ namespace JSC {
 
     class ErrorInstance : public JSObject {
     public:
-        explicit ErrorInstance(PassRefPtr<StructureID>);
+        explicit ErrorInstance(PassRefPtr<Structure>);
 
         virtual const ClassInfo* classInfo() const { return &info; }
         static const ClassInfo info;
index 993f179..582298c 100644 (file)
@@ -33,7 +33,7 @@ ASSERT_CLASS_FITS_IN_CELL(ErrorPrototype);
 static JSValue* errorProtoFuncToString(ExecState*, JSObject*, JSValue*, const ArgList&);
 
 // ECMA 15.9.4
-ErrorPrototype::ErrorPrototype(ExecState* exec, PassRefPtr<StructureID> structure, StructureID* prototypeFunctionStructure)
+ErrorPrototype::ErrorPrototype(ExecState* exec, PassRefPtr<Structure> structure, Structure* prototypeFunctionStructure)
     : ErrorInstance(structure)
 {
     // The constructor will be added later in ErrorConstructor's constructor
index 255ea11..53d12d9 100644 (file)
@@ -29,7 +29,7 @@ namespace JSC {
 
     class ErrorPrototype : public ErrorInstance {
     public:
-        ErrorPrototype(ExecState*, PassRefPtr<StructureID>, StructureID* prototypeFunctionStructure);
+        ErrorPrototype(ExecState*, PassRefPtr<Structure>, Structure* prototypeFunctionStructure);
     };
 
 } // namespace JSC
index bc6bf23..059d5b7 100644 (file)
@@ -34,7 +34,7 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(FunctionConstructor);
 
-FunctionConstructor::FunctionConstructor(ExecState* exec, PassRefPtr<StructureID> structure, FunctionPrototype* functionPrototype)
+FunctionConstructor::FunctionConstructor(ExecState* exec, PassRefPtr<Structure> structure, FunctionPrototype* functionPrototype)
     : InternalFunction(&exec->globalData(), structure, Identifier(exec, functionPrototype->classInfo()->className))
 {
     putDirectWithoutTransition(exec->propertyNames().prototype, functionPrototype, DontEnum | DontDelete | ReadOnly);
index c309c41..e8486dc 100644 (file)
@@ -29,7 +29,7 @@ namespace JSC {
 
     class FunctionConstructor : public InternalFunction {
     public:
-        FunctionConstructor(ExecState*, PassRefPtr<StructureID>, FunctionPrototype*);
+        FunctionConstructor(ExecState*, PassRefPtr<Structure>, FunctionPrototype*);
 
     private:
         virtual ConstructType getConstructData(ConstructData&);
index 9d2f20b..fd9586e 100644 (file)
@@ -36,13 +36,13 @@ static JSValue* functionProtoFuncToString(ExecState*, JSObject*, JSValue*, const
 static JSValue* functionProtoFuncApply(ExecState*, JSObject*, JSValue*, const ArgList&);
 static JSValue* functionProtoFuncCall(ExecState*, JSObject*, JSValue*, const ArgList&);
 
-FunctionPrototype::FunctionPrototype(ExecState* exec, PassRefPtr<StructureID> structure)
+FunctionPrototype::FunctionPrototype(ExecState* exec, PassRefPtr<Structure> structure)
     : InternalFunction(&exec->globalData(), structure, exec->propertyNames().nullIdentifier)
 {
     putDirectWithoutTransition(exec->propertyNames().length, jsNumber(exec, 0), DontDelete | ReadOnly | DontEnum);
 }
 
-void FunctionPrototype::addFunctionProperties(ExecState* exec, StructureID* prototypeFunctionStructure)
+void FunctionPrototype::addFunctionProperties(ExecState* exec, Structure* prototypeFunctionStructure)
 {
     putDirectFunctionWithoutTransition(exec, new (exec) PrototypeFunction(exec, prototypeFunctionStructure, 0, exec->propertyNames().toString, functionProtoFuncToString), DontEnum);
     putDirectFunctionWithoutTransition(exec, new (exec) PrototypeFunction(exec, prototypeFunctionStructure, 2, exec->propertyNames().apply, functionProtoFuncApply), DontEnum);
index f493642..dc274cf 100644 (file)
@@ -27,12 +27,12 @@ namespace JSC {
 
     class FunctionPrototype : public InternalFunction {
     public:
-        FunctionPrototype(ExecState*, PassRefPtr<StructureID>);
-        void addFunctionProperties(ExecState*, StructureID* prototypeFunctionStructure);
+        FunctionPrototype(ExecState*, PassRefPtr<Structure>);
+        void addFunctionProperties(ExecState*, Structure* prototypeFunctionStructure);
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* proto)
+        static PassRefPtr<Structure> createStructure(JSValue* proto)
         {
-            return StructureID::create(proto, TypeInfo(ObjectType, HasStandardGetOwnPropertySlot));
+            return Structure::create(proto, TypeInfo(ObjectType, HasStandardGetOwnPropertySlot));
         }
 
     private:
index 10b3a2f..b0d4c25 100644 (file)
@@ -32,7 +32,7 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(GlobalEvalFunction);
 
-GlobalEvalFunction::GlobalEvalFunction(ExecState* exec, PassRefPtr<StructureID> structure, int len, const Identifier& name, NativeFunction function, JSGlobalObject* cachedGlobalObject)
+GlobalEvalFunction::GlobalEvalFunction(ExecState* exec, PassRefPtr<Structure> structure, int len, const Identifier& name, NativeFunction function, JSGlobalObject* cachedGlobalObject)
     : PrototypeFunction(exec, structure, len, name, function)
     , m_cachedGlobalObject(cachedGlobalObject)
 {
index 2d207c4..49b1847 100644 (file)
@@ -32,7 +32,7 @@ namespace JSC {
 
     class GlobalEvalFunction : public PrototypeFunction {
     public:
-        GlobalEvalFunction(ExecState*, PassRefPtr<StructureID>, int len, const Identifier&, NativeFunction, JSGlobalObject* expectedThisObject);
+        GlobalEvalFunction(ExecState*, PassRefPtr<Structure>, int len, const Identifier&, NativeFunction, JSGlobalObject* expectedThisObject);
         JSGlobalObject* cachedGlobalObject() const { return m_cachedGlobalObject; }
 
     private:
index 9088d53..a2bc0b6 100644 (file)
@@ -29,7 +29,7 @@ namespace JSC {
     class ExecState;
 
     class Identifier {
-        friend class StructureID;
+        friend class Structure;
     public:
         Identifier() { }
 
index ee81a58..6714cf5 100644 (file)
@@ -37,7 +37,7 @@ const ClassInfo* InternalFunction::classInfo() const
     return &info;
 }
 
-InternalFunction::InternalFunction(JSGlobalData* globalData, PassRefPtr<StructureID> structure, const Identifier& name)
+InternalFunction::InternalFunction(JSGlobalData* globalData, PassRefPtr<Structure> structure, const Identifier& name)
     : JSObject(structure)
 {
     putDirect(globalData->propertyNames->name, jsString(globalData, name.ustring()), DontDelete | ReadOnly | DontEnum);
index dfccc3e..65900fb 100644 (file)
@@ -38,14 +38,14 @@ namespace JSC {
 
         const UString& name(JSGlobalData*);
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* proto) 
+        static PassRefPtr<Structure> createStructure(JSValue* proto) 
         { 
-            return StructureID::create(proto, TypeInfo(ObjectType, ImplementsHasInstance | HasStandardGetOwnPropertySlot)); 
+            return Structure::create(proto, TypeInfo(ObjectType, ImplementsHasInstance | HasStandardGetOwnPropertySlot)); 
         }
 
     protected:
-        InternalFunction(PassRefPtr<StructureID> structure) : JSObject(structure) { }
-        InternalFunction(JSGlobalData*, PassRefPtr<StructureID>, const Identifier&);
+        InternalFunction(PassRefPtr<Structure> structure) : JSObject(structure) { }
+        InternalFunction(JSGlobalData*, PassRefPtr<Structure>, const Identifier&);
 
     private:
         virtual CallType getCallData(CallData&) = 0;
index 0471cf2..d00cfa6 100644 (file)
@@ -40,7 +40,7 @@ ASSERT_CLASS_FITS_IN_CELL(JSActivation);
 const ClassInfo JSActivation::info = { "JSActivation", 0, 0, 0 };
 
 JSActivation::JSActivation(CallFrame* callFrame, PassRefPtr<FunctionBodyNode> functionBody)
-    : Base(callFrame->globalData().activationStructureID, new JSActivationData(functionBody, callFrame))
+    : Base(callFrame->globalData().activationStructure, new JSActivationData(functionBody, callFrame))
 {
 }
 
index 35399dd..866d4b2 100644 (file)
@@ -64,7 +64,7 @@ namespace JSC {
         virtual const ClassInfo* classInfo() const { return &info; }
         static const ClassInfo info;
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* proto) { return StructureID::create(proto, TypeInfo(ObjectType, NeedsThisConversion)); }
+        static PassRefPtr<Structure> createStructure(JSValue* proto) { return Structure::create(proto, TypeInfo(ObjectType, NeedsThisConversion)); }
 
     private:
         struct JSActivationData : public JSVariableObjectData {
index 8d526ea..9c7f852 100644 (file)
@@ -126,8 +126,8 @@ inline void JSArray::checkConsistency(ConsistencyCheckType)
 
 #endif
 
-JSArray::JSArray(PassRefPtr<StructureID> structureID)
-    : JSObject(structureID)
+JSArray::JSArray(PassRefPtr<Structure> structure)
+    : JSObject(structure)
 {
     unsigned initialCapacity = 0;
 
@@ -139,7 +139,7 @@ JSArray::JSArray(PassRefPtr<StructureID> structureID)
     checkConsistency();
 }
 
-JSArray::JSArray(PassRefPtr<StructureID> structure, unsigned initialLength)
+JSArray::JSArray(PassRefPtr<Structure> structure, unsigned initialLength)
     : JSObject(structure)
 {
     unsigned initialCapacity = min(initialLength, MIN_SPARSE_ARRAY_INDEX);
@@ -154,7 +154,7 @@ JSArray::JSArray(PassRefPtr<StructureID> structure, unsigned initialLength)
     checkConsistency();
 }
 
-JSArray::JSArray(ExecState* exec, PassRefPtr<StructureID> structure, const ArgList& list)
+JSArray::JSArray(ExecState* exec, PassRefPtr<Structure> structure, const ArgList& list)
     : JSObject(structure)
 {
     unsigned length = list.size();
index 165fafd..a69d53f 100644 (file)
@@ -40,9 +40,9 @@ namespace JSC {
         friend class CTI;
 
     public:
-        explicit JSArray(PassRefPtr<StructureID>);
-        JSArray(PassRefPtr<StructureID>, unsigned initialLength);
-        JSArray(ExecState*, PassRefPtr<StructureID>, const ArgList& initialValues);
+        explicit JSArray(PassRefPtr<Structure>);
+        JSArray(PassRefPtr<Structure>, unsigned initialLength);
+        JSArray(ExecState*, PassRefPtr<Structure>, const ArgList& initialValues);
         virtual ~JSArray();
 
         virtual bool getOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
@@ -76,9 +76,9 @@ namespace JSC {
 
         void fillArgList(ExecState*, ArgList&);
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* prototype)
+        static PassRefPtr<Structure> createStructure(JSValue* prototype)
         {
-            return StructureID::create(prototype, TypeInfo(ObjectType));
+            return Structure::create(prototype, TypeInfo(ObjectType));
         }
 
     protected:
index 932aac2..ce20f07 100644 (file)
@@ -23,7 +23,7 @@
 #ifndef JSCell_h
 #define JSCell_h
 
-#include "StructureID.h"
+#include "Structure.h"
 #include "JSValue.h"
 #include "Collector.h"
 
@@ -41,7 +41,7 @@ namespace JSC {
         friend class BytecodeInterpreter;
 
     private:
-        explicit JSCell(StructureID*);
+        explicit JSCell(Structure*);
         virtual ~JSCell();
 
     public:
@@ -52,7 +52,7 @@ namespace JSC {
         virtual bool isGetterSetter() const;
         virtual bool isObject(const ClassInfo*) const;
 
-        StructureID* structureID() const;
+        Structure* structure() const;
 
         // Extracting the value.
         bool getNumber(double&) const;
@@ -104,7 +104,7 @@ namespace JSC {
         virtual bool getOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
         virtual bool getOwnPropertySlot(ExecState*, unsigned propertyName, PropertySlot&);
         
-        StructureID* m_structureID;
+        Structure* m_structure;
     };
 
     JSCell* asCell(JSValue*);
@@ -115,8 +115,8 @@ namespace JSC {
         return static_cast<JSCell*>(value);
     }
 
-    inline JSCell::JSCell(StructureID* structureID)
-        : m_structureID(structureID)
+    inline JSCell::JSCell(Structure* structure)
+        : m_structure(structure)
     {
     }
 
@@ -131,17 +131,17 @@ namespace JSC {
 
     inline bool JSCell::isObject() const
     {
-        return m_structureID->typeInfo().type() == ObjectType;
+        return m_structure->typeInfo().type() == ObjectType;
     }
 
     inline bool JSCell::isString() const
     {
-        return m_structureID->typeInfo().type() == StringType;
+        return m_structure->typeInfo().type() == StringType;
     }
 
-    inline StructureID* JSCell::structureID() const
+    inline Structure* JSCell::structure() const
     {
-        return m_structureID;
+        return m_structure;
     }
 
     inline bool JSCell::marked() const
@@ -292,7 +292,7 @@ namespace JSC {
     {
         if (UNLIKELY(JSImmediate::isImmediate(asValue())))
             return true;
-        return asCell()->structureID()->typeInfo().needsThisConversion();
+        return asCell()->structure()->typeInfo().needsThisConversion();
     }
 
     inline UString JSValue::toThisString(ExecState* exec) const
index 4f329f3..c79d050 100644 (file)
@@ -183,7 +183,7 @@ ConstructType JSFunction::getConstructData(ConstructData& constructData)
 
 JSObject* JSFunction::construct(ExecState* exec, const ArgList& args)
 {
-    StructureID* structure;
+    Structure* structure;
     JSValue* prototype = get(exec, exec->propertyNames().prototype);
     if (prototype->isObject())
         structure = asObject(prototype)->inheritorID();
index 1c6b2ae..d501edc 100644 (file)
@@ -42,7 +42,7 @@ namespace JSC {
         friend class BytecodeInterpreter;
 
         typedef InternalFunction Base;
-        JSFunction(PassRefPtr<JSC::StructureID> st) : InternalFunction(st), m_scopeChain(NoScopeChain()) {}
+        JSFunction(PassRefPtr<JSC::Structure> st) : InternalFunction(st), m_scopeChain(NoScopeChain()) {}
     public:
         JSFunction(ExecState*, const Identifier&, FunctionBodyNode*, ScopeChainNode*);
         ~JSFunction();
@@ -68,9 +68,9 @@ namespace JSC {
         // FIXME: This should be private
         RefPtr<FunctionBodyNode> m_body;
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* prototype) 
+        static PassRefPtr<Structure> createStructure(JSValue* prototype) 
         { 
-            return StructureID::create(prototype, TypeInfo(ObjectType, ImplementsHasInstance)); 
+            return Structure::create(prototype, TypeInfo(ObjectType, ImplementsHasInstance)); 
         }
 
     private:
index ec00edd..0751d30 100644 (file)
@@ -73,13 +73,13 @@ JSGlobalData::JSGlobalData(bool isShared)
     , regExpTable(new HashTable(JSC::regExpTable))
     , regExpConstructorTable(new HashTable(JSC::regExpConstructorTable))
     , stringTable(new HashTable(JSC::stringTable))
-    , activationStructureID(JSActivation::createStructureID(jsNull()))
-    , interruptedExecutionErrorStructure(JSObject::createStructureID(jsNull()))
-    , staticScopeStructureID(JSStaticScopeObject::createStructureID(jsNull()))
-    , stringStructureID(JSString::createStructureID(jsNull()))
-    , notAnObjectErrorStubStructure(JSNotAnObjectErrorStub::createStructureID(jsNull()))
-    , notAnObjectStructure(JSNotAnObject::createStructureID(jsNull()))
-    , numberStructureID(JSNumberCell::createStructureID(jsNull()))
+    , activationStructure(JSActivation::createStructure(jsNull()))
+    , interruptedExecutionErrorStructure(JSObject::createStructure(jsNull()))
+    , staticScopeStructure(JSStaticScopeObject::createStructure(jsNull()))
+    , stringStructure(JSString::createStructure(jsNull()))
+    , notAnObjectErrorStubStructure(JSNotAnObjectErrorStub::createStructure(jsNull()))
+    , notAnObjectStructure(JSNotAnObject::createStructure(jsNull()))
+    , numberStructure(JSNumberCell::createStructure(jsNull()))
     , identifierTable(createIdentifierTable())
     , propertyNames(new CommonIdentifiers(this))
     , emptyList(new ArgList)
@@ -148,9 +148,9 @@ PassRefPtr<JSGlobalData> JSGlobalData::create()
 PassRefPtr<JSGlobalData> JSGlobalData::createLeaked()
 {
 #ifndef NDEBUG
-    StructureID::startIgnoringLeaks();
+    Structure::startIgnoringLeaks();
     RefPtr<JSGlobalData> data = create();
-    StructureID::stopIgnoringLeaks();
+    Structure::stopIgnoringLeaks();
     return data.release();
 #else
     return create();
index d2f7e46..265d289 100644 (file)
@@ -50,7 +50,7 @@ namespace JSC {
     class BytecodeInterpreter;
     class Parser;
     class ParserRefCounted;
-    class StructureID;
+    class Structure;
     class UString;
     struct HashTable;
 
@@ -78,13 +78,13 @@ namespace JSC {
         const HashTable* regExpConstructorTable;
         const HashTable* stringTable;
         
-        RefPtr<StructureID> activationStructureID;
-        RefPtr<StructureID> interruptedExecutionErrorStructure;
-        RefPtr<StructureID> staticScopeStructureID;
-        RefPtr<StructureID> stringStructureID;
-        RefPtr<StructureID> notAnObjectErrorStubStructure;
-        RefPtr<StructureID> notAnObjectStructure;
-        RefPtr<StructureID> numberStructureID;
+        RefPtr<Structure> activationStructure;
+        RefPtr<Structure> interruptedExecutionErrorStructure;
+        RefPtr<Structure> staticScopeStructure;
+        RefPtr<Structure> stringStructure;
+        RefPtr<Structure> notAnObjectErrorStubStructure;
+        RefPtr<Structure> notAnObjectStructure;
+        RefPtr<Structure> numberStructure;
 
         IdentifierTable* identifierTable;
         CommonIdentifiers* propertyNames;
index af0ee25..9422223 100644 (file)
@@ -84,7 +84,7 @@ static inline void markIfNeeded(JSValue* v)
         v->mark();
 }
 
-static inline void markIfNeeded(const RefPtr<StructureID>& s)
+static inline void markIfNeeded(const RefPtr<Structure>& s)
 {
     if (s)
         s->mark();
@@ -200,43 +200,43 @@ void JSGlobalObject::reset(JSValue* prototype)
 
     // Prototypes
 
-    d()->functionPrototype = new (exec) FunctionPrototype(exec, FunctionPrototype::createStructureID(jsNull())); // The real prototype will be set once ObjectPrototype is created.
-    d()->prototypeFunctionStructure = PrototypeFunction::createStructureID(d()->functionPrototype);
+    d()->functionPrototype = new (exec) FunctionPrototype(exec, FunctionPrototype::createStructure(jsNull())); // The real prototype will be set once ObjectPrototype is created.
+    d()->prototypeFunctionStructure = PrototypeFunction::createStructure(d()->functionPrototype);
     d()->functionPrototype->addFunctionProperties(exec, d()->prototypeFunctionStructure.get());
-    d()->objectPrototype = new (exec) ObjectPrototype(exec, ObjectPrototype::createStructureID(jsNull()), d()->prototypeFunctionStructure.get());
-    d()->functionPrototype->structureID()->setPrototypeWithoutTransition(d()->objectPrototype);
+    d()->objectPrototype = new (exec) ObjectPrototype(exec, ObjectPrototype::createStructure(jsNull()), d()->prototypeFunctionStructure.get());
+    d()->functionPrototype->structure()->setPrototypeWithoutTransition(d()->objectPrototype);
 
     d()->emptyObjectStructure = d()->objectPrototype->inheritorID();
 
-    d()->functionStructure = JSFunction::createStructureID(d()->functionPrototype);
-    d()->callbackFunctionStructure = JSCallbackFunction::createStructureID(d()->functionPrototype);
-    d()->argumentsStructure = Arguments::createStructureID(d()->objectPrototype);
-    d()->callbackConstructorStructure = JSCallbackConstructor::createStructureID(d()->objectPrototype);
-    d()->callbackObjectStructure = JSCallbackObject<JSObject>::createStructureID(d()->objectPrototype);
+    d()->functionStructure = JSFunction::createStructure(d()->functionPrototype);
+    d()->callbackFunctionStructure = JSCallbackFunction::createStructure(d()->functionPrototype);
+    d()->argumentsStructure = Arguments::createStructure(d()->objectPrototype);
+    d()->callbackConstructorStructure = JSCallbackConstructor::createStructure(d()->objectPrototype);
+    d()->callbackObjectStructure = JSCallbackObject<JSObject>::createStructure(d()->objectPrototype);
 
-    d()->arrayPrototype = new (exec) ArrayPrototype(ArrayPrototype::createStructureID(d()->objectPrototype));
-    d()->arrayStructure = JSArray::createStructureID(d()->arrayPrototype);
-    d()->regExpMatchesArrayStructure = RegExpMatchesArray::createStructureID(d()->arrayPrototype);
+    d()->arrayPrototype = new (exec) ArrayPrototype(ArrayPrototype::createStructure(d()->objectPrototype));
+    d()->arrayStructure = JSArray::createStructure(d()->arrayPrototype);
+    d()->regExpMatchesArrayStructure = RegExpMatchesArray::createStructure(d()->arrayPrototype);
 
-    d()->stringPrototype = new (exec) StringPrototype(exec, StringPrototype::createStructureID(d()->objectPrototype));
-    d()->stringObjectStructure = StringObject::createStructureID(d()->stringPrototype);
+    d()->stringPrototype = new (exec) StringPrototype(exec, StringPrototype::createStructure(d()->objectPrototype));
+    d()->stringObjectStructure = StringObject::createStructure(d()->stringPrototype);
 
-    d()->booleanPrototype = new (exec) BooleanPrototype(exec, BooleanPrototype::createStructureID(d()->objectPrototype), d()->prototypeFunctionStructure.get());
-    d()->booleanObjectStructure = BooleanObject::createStructureID(d()->booleanPrototype);
+    d()->booleanPrototype = new (exec) BooleanPrototype(exec, BooleanPrototype::createStructure(d()->objectPrototype), d()->prototypeFunctionStructure.get());
+    d()->booleanObjectStructure = BooleanObject::createStructure(d()->booleanPrototype);
 
-    d()->numberPrototype = new (exec) NumberPrototype(exec, NumberPrototype::createStructureID(d()->objectPrototype), d()->prototypeFunctionStructure.get());
-    d()->numberObjectStructure = NumberObject::createStructureID(d()->numberPrototype);
+    d()->numberPrototype = new (exec) NumberPrototype(exec, NumberPrototype::createStructure(d()->objectPrototype), d()->prototypeFunctionStructure.get());
+    d()->numberObjectStructure = NumberObject::createStructure(d()->numberPrototype);
 
-    d()->datePrototype = new (exec) DatePrototype(exec, DatePrototype::createStructureID(d()->objectPrototype));
-    d()->dateStructure = DateInstance::createStructureID(d()->datePrototype);
+    d()->datePrototype = new (exec) DatePrototype(exec, DatePrototype::createStructure(d()->objectPrototype));
+    d()->dateStructure = DateInstance::createStructure(d()->datePrototype);
 
-    d()->regExpPrototype = new (exec) RegExpPrototype(exec, RegExpPrototype::createStructureID(d()->objectPrototype), d()->prototypeFunctionStructure.get());
-    d()->regExpStructure = RegExpObject::createStructureID(d()->regExpPrototype);
+    d()->regExpPrototype = new (exec) RegExpPrototype(exec, RegExpPrototype::createStructure(d()->objectPrototype), d()->prototypeFunctionStructure.get());
+    d()->regExpStructure = RegExpObject::createStructure(d()->regExpPrototype);
 
-    ErrorPrototype* errorPrototype = new (exec) ErrorPrototype(exec, ErrorPrototype::createStructureID(d()->objectPrototype), d()->prototypeFunctionStructure.get());
-    d()->errorStructure = ErrorInstance::createStructureID(errorPrototype);
+    ErrorPrototype* errorPrototype = new (exec) ErrorPrototype(exec, ErrorPrototype::createStructure(d()->objectPrototype), d()->prototypeFunctionStructure.get());
+    d()->errorStructure = ErrorInstance::createStructure(errorPrototype);
 
-    RefPtr<StructureID> nativeErrorPrototypeStructure = NativeErrorPrototype::createStructureID(errorPrototype);
+    RefPtr<Structure> nativeErrorPrototypeStructure = NativeErrorPrototype::createStructure(errorPrototype);
 
     NativeErrorPrototype* evalErrorPrototype = new (exec) NativeErrorPrototype(exec, nativeErrorPrototypeStructure, "EvalError", "EvalError");
     NativeErrorPrototype* rangeErrorPrototype = new (exec) NativeErrorPrototype(exec, nativeErrorPrototypeStructure, "RangeError", "RangeError");
@@ -247,19 +247,19 @@ void JSGlobalObject::reset(JSValue* prototype)
 
     // Constructors
 
-    JSValue* objectConstructor = new (exec) ObjectConstructor(exec, ObjectConstructor::createStructureID(d()->functionPrototype), d()->objectPrototype);
-    JSValue* functionConstructor = new (exec) FunctionConstructor(exec, FunctionConstructor::createStructureID(d()->functionPrototype), d()->functionPrototype);
-    JSValue* arrayConstructor = new (exec) ArrayConstructor(exec, ArrayConstructor::createStructureID(d()->functionPrototype), d()->arrayPrototype);
-    JSValue* stringConstructor = new (exec) StringConstructor(exec, StringConstructor::createStructureID(d()->functionPrototype), d()->prototypeFunctionStructure.get(), d()->stringPrototype);
-    JSValue* booleanConstructor = new (exec) BooleanConstructor(exec, BooleanConstructor::createStructureID(d()->functionPrototype), d()->booleanPrototype);
-    JSValue* numberConstructor = new (exec) NumberConstructor(exec, NumberConstructor::createStructureID(d()->functionPrototype), d()->numberPrototype);
-    JSValue* dateConstructor = new (exec) DateConstructor(exec, DateConstructor::createStructureID(d()->functionPrototype), d()->prototypeFunctionStructure.get(), d()->datePrototype);
+    JSValue* objectConstructor = new (exec) ObjectConstructor(exec, ObjectConstructor::createStructure(d()->functionPrototype), d()->objectPrototype);
+    JSValue* functionConstructor = new (exec) FunctionConstructor(exec, FunctionConstructor::createStructure(d()->functionPrototype), d()->functionPrototype);
+    JSValue* arrayConstructor = new (exec) ArrayConstructor(exec, ArrayConstructor::createStructure(d()->functionPrototype), d()->arrayPrototype);
+    JSValue* stringConstructor = new (exec) StringConstructor(exec, StringConstructor::createStructure(d()->functionPrototype), d()->prototypeFunctionStructure.get(), d()->stringPrototype);
+    JSValue* booleanConstructor = new (exec) BooleanConstructor(exec, BooleanConstructor::createStructure(d()->functionPrototype), d()->booleanPrototype);
+    JSValue* numberConstructor = new (exec) NumberConstructor(exec, NumberConstructor::createStructure(d()->functionPrototype), d()->numberPrototype);
+    JSValue* dateConstructor = new (exec) DateConstructor(exec, DateConstructor::createStructure(d()->functionPrototype), d()->prototypeFunctionStructure.get(), d()->datePrototype);
 
-    d()->regExpConstructor = new (exec) RegExpConstructor(exec, RegExpConstructor::createStructureID(d()->functionPrototype), d()->regExpPrototype);
+    d()->regExpConstructor = new (exec) RegExpConstructor(exec, RegExpConstructor::createStructure(d()->functionPrototype), d()->regExpPrototype);
 
-    d()->errorConstructor = new (exec) ErrorConstructor(exec, ErrorConstructor::createStructureID(d()->functionPrototype), errorPrototype);
+    d()->errorConstructor = new (exec) ErrorConstructor(exec, ErrorConstructor::createStructure(d()->functionPrototype), errorPrototype);
 
-    RefPtr<StructureID> nativeErrorStructure = NativeErrorConstructor::createStructureID(d()->functionPrototype);
+    RefPtr<Structure> nativeErrorStructure = NativeErrorConstructor::createStructure(d()->functionPrototype);
 
     d()->evalErrorConstructor = new (exec) NativeErrorConstructor(exec, nativeErrorStructure, evalErrorPrototype);
     d()->rangeErrorConstructor = new (exec) NativeErrorConstructor(exec, nativeErrorStructure, rangeErrorPrototype);
@@ -307,7 +307,7 @@ void JSGlobalObject::reset(JSValue* prototype)
 
     // Set global values.
     GlobalPropertyInfo staticGlobals[] = {
-        GlobalPropertyInfo(Identifier(exec, "Math"), new (exec) MathObject(exec, MathObject::createStructureID(d()->objectPrototype)), DontEnum | DontDelete),
+        GlobalPropertyInfo(Identifier(exec, "Math"), new (exec) MathObject(exec, MathObject::createStructure(d()->objectPrototype)), DontEnum | DontDelete),
         GlobalPropertyInfo(Identifier(exec, "NaN"), jsNaN(exec), DontEnum | DontDelete),
         GlobalPropertyInfo(Identifier(exec, "Infinity"), jsNumber(exec, Inf), DontEnum | DontDelete),
         GlobalPropertyInfo(Identifier(exec, "undefined"), jsUndefined(), DontEnum | DontDelete)
@@ -317,7 +317,7 @@ void JSGlobalObject::reset(JSValue* prototype)
 
     // Set global functions.
 
-    d()->evalFunction = new (exec) GlobalEvalFunction(exec, GlobalEvalFunction::createStructureID(d()->functionPrototype), 1, exec->propertyNames().eval, globalFuncEval, this);
+    d()->evalFunction = new (exec) GlobalEvalFunction(exec, GlobalEvalFunction::createStructure(d()->functionPrototype), 1, exec->propertyNames().eval, globalFuncEval, this);
     putDirectFunctionWithoutTransition(exec, d()->evalFunction, DontEnum);
     putDirectFunctionWithoutTransition(exec, new (exec) PrototypeFunction(exec, d()->prototypeFunctionStructure.get(), 2, Identifier(exec, "parseInt"), globalFuncParseInt), DontEnum);
     putDirectFunctionWithoutTransition(exec, new (exec) PrototypeFunction(exec, d()->prototypeFunctionStructure.get(), 1, Identifier(exec, "parseFloat"), globalFuncParseFloat), DontEnum);
index d8a072a..2f559fa 100644 (file)
@@ -114,21 +114,21 @@ namespace JSC {
             DatePrototype* datePrototype;
             RegExpPrototype* regExpPrototype;
 
-            RefPtr<StructureID> argumentsStructure;
-            RefPtr<StructureID> arrayStructure;
-            RefPtr<StructureID> booleanObjectStructure;
-            RefPtr<StructureID> callbackConstructorStructure;
-            RefPtr<StructureID> callbackFunctionStructure;
-            RefPtr<StructureID> callbackObjectStructure;
-            RefPtr<StructureID> dateStructure;
-            RefPtr<StructureID> emptyObjectStructure;
-            RefPtr<StructureID> errorStructure;
-            RefPtr<StructureID> functionStructure;
-            RefPtr<StructureID> numberObjectStructure;
-            RefPtr<StructureID> prototypeFunctionStructure;
-            RefPtr<StructureID> regExpMatchesArrayStructure;
-            RefPtr<StructureID> regExpStructure;
-            RefPtr<StructureID> stringObjectStructure;
+            RefPtr<Structure> argumentsStructure;
+            RefPtr<Structure> arrayStructure;
+            RefPtr<Structure> booleanObjectStructure;
+            RefPtr<Structure> callbackConstructorStructure;
+            RefPtr<Structure> callbackFunctionStructure;
+            RefPtr<Structure> callbackObjectStructure;
+            RefPtr<Structure> dateStructure;
+            RefPtr<Structure> emptyObjectStructure;
+            RefPtr<Structure> errorStructure;
+            RefPtr<Structure> functionStructure;
+            RefPtr<Structure> numberObjectStructure;
+            RefPtr<Structure> prototypeFunctionStructure;
+            RefPtr<Structure> regExpMatchesArrayStructure;
+            RefPtr<Structure> regExpStructure;
+            RefPtr<Structure> stringObjectStructure;
 
             SymbolTable symbolTable;
             unsigned profileGroup;
@@ -142,13 +142,13 @@ namespace JSC {
         void* operator new(size_t, JSGlobalData*);
 
         explicit JSGlobalObject()
-            : JSVariableObject(JSGlobalObject::createStructureID(jsNull()), new JSGlobalObjectData)
+            : JSVariableObject(JSGlobalObject::createStructure(jsNull()), new JSGlobalObjectData)
         {
             init(this);
         }
 
     protected:
-        JSGlobalObject(PassRefPtr<StructureID> structure, JSGlobalObjectData* data, JSObject* thisValue)
+        JSGlobalObject(PassRefPtr<Structure> structure, JSGlobalObjectData* data, JSObject* thisValue)
             : JSVariableObject(structure, data)
         {
             init(thisValue);
@@ -196,21 +196,21 @@ namespace JSC {
         DatePrototype* datePrototype() const { return d()->datePrototype; }
         RegExpPrototype* regExpPrototype() const { return d()->regExpPrototype; }
 
-        StructureID* argumentsStructure() const { return d()->argumentsStructure.get(); }
-        StructureID* arrayStructure() const { return d()->arrayStructure.get(); }
-        StructureID* booleanObjectStructure() const { return d()->booleanObjectStructure.get(); }
-        StructureID* callbackConstructorStructure() const { return d()->callbackConstructorStructure.get(); }
-        StructureID* callbackFunctionStructure() const { return d()->callbackFunctionStructure.get(); }
-        StructureID* callbackObjectStructure() const { return d()->callbackObjectStructure.get(); }
-        StructureID* dateStructure() const { return d()->dateStructure.get(); }
-        StructureID* emptyObjectStructure() const { return d()->emptyObjectStructure.get(); }
-        StructureID* errorStructure() const { return d()->errorStructure.get(); }
-        StructureID* functionStructure() const { return d()->functionStructure.get(); }
-        StructureID* numberObjectStructure() const { return d()->numberObjectStructure.get(); }
-        StructureID* prototypeFunctionStructure() const { return d()->prototypeFunctionStructure.get(); }
-        StructureID* regExpMatchesArrayStructure() const { return d()->regExpMatchesArrayStructure.get(); }
-        StructureID* regExpStructure() const { return d()->regExpStructure.get(); }
-        StructureID* stringObjectStructure() const { return d()->stringObjectStructure.get(); }
+        Structure* argumentsStructure() const { return d()->argumentsStructure.get(); }
+        Structure* arrayStructure() const { return d()->arrayStructure.get(); }
+        Structure* booleanObjectStructure() const { return d()->booleanObjectStructure.get(); }
+        Structure* callbackConstructorStructure() const { return d()->callbackConstructorStructure.get(); }
+        Structure* callbackFunctionStructure() const { return d()->callbackFunctionStructure.get(); }
+        Structure* callbackObjectStructure() const { return d()->callbackObjectStructure.get(); }
+        Structure* dateStructure() const { return d()->dateStructure.get(); }
+        Structure* emptyObjectStructure() const { return d()->emptyObjectStructure.get(); }
+        Structure* errorStructure() const { return d()->errorStructure.get(); }
+        Structure* functionStructure() const { return d()->functionStructure.get(); }
+        Structure* numberObjectStructure() const { return d()->numberObjectStructure.get(); }
+        Structure* prototypeFunctionStructure() const { return d()->prototypeFunctionStructure.get(); }
+        Structure* regExpMatchesArrayStructure() const { return d()->regExpMatchesArrayStructure.get(); }
+        Structure* regExpStructure() const { return d()->regExpStructure.get(); }
+        Structure* stringObjectStructure() const { return d()->stringObjectStructure.get(); }
 
         void setProfileGroup(unsigned value) { d()->profileGroup = value; }
         unsigned profileGroup() const { return d()->profileGroup; }
@@ -251,9 +251,9 @@ namespace JSC {
         JSGlobalData* globalData() { return d()->globalData.get(); }
         JSGlobalObjectData* d() const { return static_cast<JSGlobalObjectData*>(JSVariableObject::d); }
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* prototype)
+        static PassRefPtr<Structure> createStructure(JSValue* prototype)
         {
-            return StructureID::create(prototype, TypeInfo(ObjectType));
+            return Structure::create(prototype, TypeInfo(ObjectType));
         }
 
     protected:
@@ -335,7 +335,7 @@ namespace JSC {
         return asGlobalObject(n->object);
     }
 
-    inline JSValue* StructureID::prototypeForLookup(ExecState* exec)
+    inline JSValue* Structure::prototypeForLookup(ExecState* exec)
     {
         if (typeInfo().type() == ObjectType)
             return m_prototype;
index cde2a84..ed97da2 100644 (file)
@@ -60,9 +60,9 @@ namespace JSC {
         {
         }
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* prototype)
+        static PassRefPtr<Structure> createStructure(JSValue* prototype)
         {
-            return StructureID::create(prototype, TypeInfo(ObjectType));
+            return Structure::create(prototype, TypeInfo(ObjectType));
         }
 
      private:
index 89fdf1b..5e1d89d 100644 (file)
@@ -82,22 +82,22 @@ namespace JSC {
     #endif
         }
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* proto) { return StructureID::create(proto, TypeInfo(NumberType, NeedsThisConversion)); }
+        static PassRefPtr<Structure> createStructure(JSValue* proto) { return Structure::create(proto, TypeInfo(NumberType, NeedsThisConversion)); }
 
         JSNumberCell(JSGlobalData* globalData)
-        : JSCell(globalData->numberStructureID.get())
+        : JSCell(globalData->numberStructure.get())
         {
         }
 
     private:
         JSNumberCell(JSGlobalData* globalData, double value)
-            : JSCell(globalData->numberStructureID.get())
+            : JSCell(globalData->numberStructure.get())
             , m_value(value)
         {
         }
 
         JSNumberCell(ExecState* exec, double value)
-            : JSCell(exec->globalData().numberStructureID.get())
+            : JSCell(exec->globalData().numberStructure.get())
             , m_value(value)
         {
         }
index 0723d1c..03f85a9 100644 (file)
@@ -67,9 +67,9 @@ void JSObject::mark()
     JSOBJECT_MARK_BEGIN();
 
     JSCell::mark();
-    m_structureID->mark();
+    m_structure->mark();
 
-    size_t storageSize = m_structureID->propertyStorageSize();
+    size_t storageSize = m_structure->propertyStorageSize();
     for (size_t i = 0; i < storageSize; ++i) {
         JSValue* v = m_propertyStorage[i];
         if (!v->marked())
@@ -124,7 +124,7 @@ void JSObject::put(ExecState* exec, const Identifier& propertyName, JSValue* val
     
     // Check if there are any setters or getters in the prototype chain
     JSValue* prototype;
-    for (JSObject* obj = this; !obj->structureID()->hasGetterSetterProperties(); obj = asObject(prototype)) {
+    for (JSObject* obj = this; !obj->structure()->hasGetterSetterProperties(); obj = asObject(prototype)) {
         prototype = obj->prototype();
         if (prototype->isNull()) {
             putDirect(propertyName, value, 0, true, slot);
@@ -133,7 +133,7 @@ void JSObject::put(ExecState* exec, const Identifier& propertyName, JSValue* val
     }
     
     unsigned attributes;
-    if ((m_structureID->get(propertyName, attributes) != WTF::notFound) && attributes & ReadOnly)
+    if ((m_structure->get(propertyName, attributes) != WTF::notFound) && attributes & ReadOnly)
         return;
 
     for (JSObject* obj = this; ; obj = asObject(prototype)) {
@@ -199,7 +199,7 @@ bool JSObject::hasProperty(ExecState* exec, unsigned propertyName) const
 bool JSObject::deleteProperty(ExecState* exec, const Identifier& propertyName)
 {
     unsigned attributes;
-    if (m_structureID->get(propertyName, attributes) != WTF::notFound) {
+    if (m_structure->get(propertyName, attributes) != WTF::notFound) {
         if ((attributes & DontDelete))
             return false;
         removeDirect(propertyName);
@@ -291,7 +291,7 @@ void JSObject::defineGetter(ExecState* exec, const Identifier& propertyName, JSO
 {
     JSValue* object = getDirect(propertyName);
     if (object && object->isGetterSetter()) {
-        ASSERT(m_structureID->hasGetterSetterProperties());
+        ASSERT(m_structure->hasGetterSetterProperties());
         asGetterSetter(object)->setGetter(getterFunction);
         return;
     }
@@ -300,17 +300,17 @@ void JSObject::defineGetter(ExecState* exec, const Identifier& propertyName, JSO
     GetterSetter* getterSetter = new (exec) GetterSetter;
     putDirect(propertyName, getterSetter, None, true, slot);
 
-    // putDirect will change our StructureID if we add a new property. For
-    // getters and setters, though, we also need to change our StructureID
+    // putDirect will change our Structure if we add a new property. For
+    // getters and setters, though, we also need to change our Structure
     // if we override an existing non-getter or non-setter.
     if (slot.type() != PutPropertySlot::NewProperty) {
-        if (!m_structureID->isDictionary()) {
-            RefPtr<StructureID> structureID = StructureID::getterSetterTransition(m_structureID);
-            setStructureID(structureID.release());
+        if (!m_structure->isDictionary()) {
+            RefPtr<Structure> structure = Structure::getterSetterTransition(m_structure);
+            setStructure(structure.release());
         }
     }
 
-    m_structureID->setHasGetterSetterProperties(true);
+    m_structure->setHasGetterSetterProperties(true);
     getterSetter->setGetter(getterFunction);
 }
 
@@ -318,7 +318,7 @@ void JSObject::defineSetter(ExecState* exec, const Identifier& propertyName, JSO
 {
     JSValue* object = getDirect(propertyName);
     if (object && object->isGetterSetter()) {
-        ASSERT(m_structureID->hasGetterSetterProperties());
+        ASSERT(m_structure->hasGetterSetterProperties());
         asGetterSetter(object)->setSetter(setterFunction);
         return;
     }
@@ -327,17 +327,17 @@ void JSObject::defineSetter(ExecState* exec, const Identifier& propertyName, JSO
     GetterSetter* getterSetter = new (exec) GetterSetter;
     putDirect(propertyName, getterSetter, None, true, slot);
 
-    // putDirect will change our StructureID if we add a new property. For
-    // getters and setters, though, we also need to change our StructureID
+    // putDirect will change our Structure if we add a new property. For
+    // getters and setters, though, we also need to change our Structure
     // if we override an existing non-getter or non-setter.
     if (slot.type() != PutPropertySlot::NewProperty) {
-        if (!m_structureID->isDictionary()) {
-            RefPtr<StructureID> structureID = StructureID::getterSetterTransition(m_structureID);
-            setStructureID(structureID.release());
+        if (!m_structure->isDictionary()) {
+            RefPtr<Structure> structure = Structure::getterSetterTransition(m_structure);
+            setStructure(structure.release());
         }
     }
 
-    m_structureID->setHasGetterSetterProperties(true);
+    m_structure->setHasGetterSetterProperties(true);
     getterSetter->setSetter(setterFunction);
 }
 
@@ -409,7 +409,7 @@ bool JSObject::propertyIsEnumerable(ExecState* exec, const Identifier& propertyN
 
 bool JSObject::getPropertyAttributes(ExecState* exec, const Identifier& propertyName, unsigned& attributes) const
 {
-    if (m_structureID->get(propertyName, attributes) != WTF::notFound)
+    if (m_structure->get(propertyName, attributes) != WTF::notFound)
         return true;
     
     // Look in the static hashtable of properties
@@ -424,7 +424,7 @@ bool JSObject::getPropertyAttributes(ExecState* exec, const Identifier& property
 
 void JSObject::getPropertyNames(ExecState* exec, PropertyNameArray& propertyNames)
 {
-    m_structureID->getEnumerablePropertyNames(exec, propertyNames, this);
+    m_structure->getEnumerablePropertyNames(exec, propertyNames, this);
 }
 
 bool JSObject::toBoolean(ExecState*) const
@@ -466,17 +466,17 @@ JSGlobalObject* JSObject::toGlobalObject(ExecState*) const
 void JSObject::removeDirect(const Identifier& propertyName)
 {
     size_t offset;
-    if (m_structureID->isDictionary()) {
-        offset = m_structureID->removePropertyWithoutTransition(propertyName);
+    if (m_structure->isDictionary()) {
+        offset = m_structure->removePropertyWithoutTransition(propertyName);
         if (offset != WTF::notFound)
             m_propertyStorage[offset] = jsUndefined();
         return;
     }
 
-    RefPtr<StructureID> structureID = StructureID::removePropertyTransition(m_structureID, propertyName, offset);
+    RefPtr<Structure> structure = Structure::removePropertyTransition(m_structure, propertyName, offset);
     if (offset != WTF::notFound)
         m_propertyStorage[offset] = jsUndefined();
-    setStructureID(structureID.release());
+    setStructure(structure.release());
 }
 
 void JSObject::putDirectFunction(ExecState* exec, InternalFunction* function, unsigned attr)
@@ -497,9 +497,9 @@ NEVER_INLINE void JSObject::fillGetterPropertySlot(PropertySlot& slot, JSValue**
         slot.setUndefined();
 }
 
-StructureID* JSObject::createInheritorID()
+Structure* JSObject::createInheritorID()
 {
-    m_inheritorID = JSObject::createStructureID(this);
+    m_inheritorID = JSObject::createStructure(this);
     return m_inheritorID.get();
 }
 
index 52fb1ec..68e55d9 100644 (file)
 #include "PropertySlot.h"
 #include "PutPropertySlot.h"
 #include "ScopeChain.h"
-#include "StructureID.h"
+#include "Structure.h"
 
 namespace JSC {
 
     class InternalFunction;
     class PropertyNameArray;
-    class StructureID;
+    class Structure;
     struct HashEntry;
     struct HashTable;
 
@@ -59,7 +59,7 @@ namespace JSC {
         friend class JSCell;
 
     public:
-        explicit JSObject(PassRefPtr<StructureID>);
+        explicit JSObject(PassRefPtr<Structure>);
 
         virtual void mark();
 
@@ -72,8 +72,8 @@ namespace JSC {
         JSValue* prototype() const;
         void setPrototype(JSValue* prototype);
         
-        void setStructureID(PassRefPtr<StructureID>);
-        StructureID* inheritorID();
+        void setStructure(PassRefPtr<Structure>);
+        Structure* inheritorID();
 
         PropertyStorage& propertyStorage() { return m_propertyStorage; }
 
@@ -124,19 +124,19 @@ namespace JSC {
         // This get function only looks at the property map.
         JSValue* getDirect(const Identifier& propertyName) const
         {
-            size_t offset = m_structureID->get(propertyName);
+            size_t offset = m_structure->get(propertyName);
             return offset != WTF::notFound ? m_propertyStorage[offset] : noValue();
         }
 
         JSValue** getDirectLocation(const Identifier& propertyName)
         {
-            size_t offset = m_structureID->get(propertyName);
+            size_t offset = m_structure->get(propertyName);
             return offset != WTF::notFound ? locationForOffset(offset) : 0;
         }
 
         JSValue** getDirectLocation(const Identifier& propertyName, unsigned& attributes)
         {
-            size_t offset = m_structureID->get(propertyName, attributes);
+            size_t offset = m_structure->get(propertyName, attributes);
             return offset != WTF::notFound ? locationForOffset(offset) : 0;
         }
 
@@ -150,11 +150,11 @@ namespace JSC {
             return &m_propertyStorage[offset];
         }
 
-        void transitionTo(StructureID*);
+        void transitionTo(Structure*);
 
         void removeDirect(const Identifier& propertyName);
-        bool hasCustomProperties() { return !m_structureID->isEmpty(); }
-        bool hasGetterSetterProperties() { return m_structureID->hasGetterSetterProperties(); }
+        bool hasCustomProperties() { return !m_structure->isEmpty(); }
+        bool hasGetterSetterProperties() { return m_structure->hasGetterSetterProperties(); }
 
         void putDirect(const Identifier& propertyName, JSValue* value, unsigned attr = 0);
         void putDirect(const Identifier& propertyName, JSValue* value, unsigned attr, bool checkReadOnly, PutPropertySlot& slot);
@@ -185,9 +185,9 @@ namespace JSC {
         static const size_t inlineStorageCapacity = 2;
         static const size_t nonInlineBaseStorageCapacity = 16;
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* prototype)
+        static PassRefPtr<Structure> createStructure(JSValue* prototype)
         {
-            return StructureID::create(prototype, TypeInfo(ObjectType, HasStandardGetOwnPropertySlot));
+            return Structure::create(prototype, TypeInfo(ObjectType, HasStandardGetOwnPropertySlot));
         }
 
     protected:
@@ -197,9 +197,9 @@ namespace JSC {
         bool inlineGetOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
 
         const HashEntry* findPropertyHashEntry(ExecState*, const Identifier& propertyName) const;
-        StructureID* createInheritorID();
+        Structure* createInheritorID();
 
-        RefPtr<StructureID> m_inheritorID;
+        RefPtr<Structure> m_inheritorID;
 
         PropertyStorage m_propertyStorage;        
         JSValue* m_inlineStorage[inlineStorageCapacity];
@@ -215,43 +215,43 @@ inline JSObject* asObject(JSValue* value)
     return static_cast<JSObject*>(asCell(value));
 }
 
-inline JSObject::JSObject(PassRefPtr<StructureID> structureID)
-    : JSCell(structureID.releaseRef()) // ~JSObject balances this ref()
+inline JSObject::JSObject(PassRefPtr<Structure> structure)
+    : JSCell(structure.releaseRef()) // ~JSObject balances this ref()
     , m_propertyStorage(m_inlineStorage)
 {
-    ASSERT(m_structureID);
-    ASSERT(m_structureID->propertyStorageCapacity() == inlineStorageCapacity);
-    ASSERT(m_structureID->isEmpty());
+    ASSERT(m_structure);
+    ASSERT(m_structure->propertyStorageCapacity() == inlineStorageCapacity);
+    ASSERT(m_structure->isEmpty());
     ASSERT(prototype()->isNull() || Heap::heap(this) == Heap::heap(prototype()));
 }
 
 inline JSObject::~JSObject()
 {
-    ASSERT(m_structureID);
+    ASSERT(m_structure);
     if (m_propertyStorage != m_inlineStorage)
         delete [] m_propertyStorage;
-    m_structureID->deref();
+    m_structure->deref();
 }
 
 inline JSValue* JSObject::prototype() const
 {
-    return m_structureID->storedPrototype();
+    return m_structure->storedPrototype();
 }
 
 inline void JSObject::setPrototype(JSValue* prototype)
 {
     ASSERT(prototype);
-    RefPtr<StructureID> newStructureID = StructureID::changePrototypeTransition(m_structureID, prototype);
-    setStructureID(newStructureID.release());
+    RefPtr<Structure> newStructure = Structure::changePrototypeTransition(m_structure, prototype);
+    setStructure(newStructure.release());
 }
 
-inline void JSObject::setStructureID(PassRefPtr<StructureID> structureID)
+inline void JSObject::setStructure(PassRefPtr<Structure> structure)
 {
-    m_structureID->deref();
-    m_structureID = structureID.releaseRef(); // ~JSObject balances this ref()
+    m_structure->deref();
+    m_structure = structure.releaseRef(); // ~JSObject balances this ref()
 }
 
-inline StructureID* JSObject::inheritorID()
+inline Structure* JSObject::inheritorID()
 {
     if (m_inheritorID)
         return m_inheritorID.get();
@@ -276,7 +276,7 @@ inline bool JSValue::isObject(const ClassInfo* classInfo) const
 ALWAYS_INLINE bool JSObject::inlineGetOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
 {
     if (JSValue** location = getDirectLocation(propertyName)) {
-        if (m_structureID->hasGetterSetterProperties() && location[0]->isGetterSetter())
+        if (m_structure->hasGetterSetterProperties() && location[0]->isGetterSetter())
             fillGetterPropertySlot(slot, location);
         else
             slot.setValueSlot(this, location, offsetForLocation(location));
@@ -296,7 +296,7 @@ ALWAYS_INLINE bool JSObject::getOwnPropertySlotForWrite(ExecState* exec, const I
 {
     unsigned attributes;
     if (JSValue** location = getDirectLocation(propertyName, attributes)) {
-        if (m_structureID->hasGetterSetterProperties() && location[0]->isGetterSetter()) {
+        if (m_structure->hasGetterSetterProperties() && location[0]->isGetterSetter()) {
             slotIsWriteable = false;
             fillGetterPropertySlot(slot, location);
         } else {
@@ -326,7 +326,7 @@ ALWAYS_INLINE bool JSObject::getOwnPropertySlot(ExecState* exec, const Identifie
 
 ALWAYS_INLINE bool JSCell::fastGetOwnPropertySlot(ExecState* exec, const Identifier& propertyName, PropertySlot& slot)
 {
-    if (structureID()->typeInfo().hasStandardGetOwnPropertySlot())
+    if (structure()->typeInfo().hasStandardGetOwnPropertySlot())
         return asObject(this)->inlineGetOwnPropertySlot(exec, propertyName, slot);
     return getOwnPropertySlot(exec, propertyName, slot);
 }
@@ -387,9 +387,9 @@ inline void JSObject::putDirect(const Identifier& propertyName, JSValue* value,
 {
     ASSERT(!Heap::heap(value) || Heap::heap(value) == Heap::heap(this));
 
-    if (m_structureID->isDictionary()) {
+    if (m_structure->isDictionary()) {
         unsigned currentAttributes;
-        size_t offset = m_structureID->get(propertyName, currentAttributes);
+        size_t offset = m_structure->get(propertyName, currentAttributes);
         if (offset != WTF::notFound) {
             if (checkReadOnly && currentAttributes & ReadOnly)
                 return;
@@ -398,33 +398,33 @@ inline void JSObject::putDirect(const Identifier& propertyName, JSValue* value,
             return;
         }
 
-        size_t currentCapacity = m_structureID->propertyStorageCapacity();
-        offset = m_structureID->addPropertyWithoutTransition(propertyName, attributes);
-        if (currentCapacity != m_structureID->propertyStorageCapacity())
-            allocatePropertyStorage(currentCapacity, m_structureID->propertyStorageCapacity());
+        size_t currentCapacity = m_structure->propertyStorageCapacity();
+        offset = m_structure->addPropertyWithoutTransition(propertyName, attributes);
+        if (currentCapacity != m_structure->propertyStorageCapacity())
+            allocatePropertyStorage(currentCapacity, m_structure->propertyStorageCapacity());
 
-        ASSERT(offset < m_structureID->propertyStorageCapacity());
+        ASSERT(offset < m_structure->propertyStorageCapacity());
         m_propertyStorage[offset] = value;
         slot.setNewProperty(this, offset);
         return;
     }
 
     size_t offset;
-    size_t currentCapacity = m_structureID->propertyStorageCapacity();
-    if (RefPtr<StructureID> structureID = StructureID::addPropertyTransitionToExistingStructure(m_structureID, propertyName, attributes, offset)) {
-        if (currentCapacity != structureID->propertyStorageCapacity())
-            allocatePropertyStorage(currentCapacity, structureID->propertyStorageCapacity());
+    size_t currentCapacity = m_structure->propertyStorageCapacity();
+    if (RefPtr<Structure> structure = Structure::addPropertyTransitionToExistingStructure(m_structure, propertyName, attributes, offset)) {
+        if (currentCapacity != structure->propertyStorageCapacity())
+            allocatePropertyStorage(currentCapacity, structure->propertyStorageCapacity());
 
-        ASSERT(offset < structureID->propertyStorageCapacity());
+        ASSERT(offset < structure->propertyStorageCapacity());
         m_propertyStorage[offset] = value;
         slot.setNewProperty(this, offset);
         slot.setWasTransition(true);
-        setStructureID(structureID.release());
+        setStructure(structure.release());
         return;
     }
 
     unsigned currentAttributes;
-    offset = m_structureID->get(propertyName, currentAttributes);
+    offset = m_structure->get(propertyName, currentAttributes);
     if (offset != WTF::notFound) {
         if (checkReadOnly && currentAttributes & ReadOnly)
             return;
@@ -433,31 +433,31 @@ inline void JSObject::putDirect(const Identifier& propertyName, JSValue* value,
         return;
     }
 
-    RefPtr<StructureID> structureID = StructureID::addPropertyTransition(m_structureID, propertyName, attributes, offset);
-    if (currentCapacity != structureID->propertyStorageCapacity())
-        allocatePropertyStorage(currentCapacity, structureID->propertyStorageCapacity());
+    RefPtr<Structure> structure = Structure::addPropertyTransition(m_structure, propertyName, attributes, offset);
+    if (currentCapacity != structure->propertyStorageCapacity())
+        allocatePropertyStorage(currentCapacity, structure->propertyStorageCapacity());
 
-    ASSERT(offset < structureID->propertyStorageCapacity());
+    ASSERT(offset < structure->propertyStorageCapacity());
     m_propertyStorage[offset] = value;
     slot.setNewProperty(this, offset);
     slot.setWasTransition(true);
-    setStructureID(structureID.release());
+    setStructure(structure.release());
 }
 
 inline void JSObject::putDirectWithoutTransition(const Identifier& propertyName, JSValue* value, unsigned attributes)
 {
-    size_t currentCapacity = m_structureID->propertyStorageCapacity();
-    size_t offset = m_structureID->addPropertyWithoutTransition(propertyName, attributes);
-    if (currentCapacity != m_structureID->propertyStorageCapacity())
-        allocatePropertyStorage(currentCapacity, m_structureID->propertyStorageCapacity());
+    size_t currentCapacity = m_structure->propertyStorageCapacity();
+    size_t offset = m_structure->addPropertyWithoutTransition(propertyName, attributes);
+    if (currentCapacity != m_structure->propertyStorageCapacity())
+        allocatePropertyStorage(currentCapacity, m_structure->propertyStorageCapacity());
     m_propertyStorage[offset] = value;
 }
 
-inline void JSObject::transitionTo(StructureID* newStructureID)
+inline void JSObject::transitionTo(Structure* newStructure)
 {
-    if (m_structureID->propertyStorageCapacity() != newStructureID->propertyStorageCapacity())
-        allocatePropertyStorage(m_structureID->propertyStorageCapacity(), newStructureID->propertyStorageCapacity());
-    setStructureID(newStructureID);
+    if (m_structure->propertyStorageCapacity() != newStructure->propertyStorageCapacity())
+        allocatePropertyStorage(m_structure->propertyStorageCapacity(), newStructure->propertyStorageCapacity());
+    setStructure(newStructure);
 }
 
 inline JSValue* JSObject::toPrimitive(ExecState* exec, PreferredPrimitiveType preferredType) const
index 1853999..b36852f 100644 (file)
@@ -99,7 +99,7 @@ inline JSValue* JSPropertyNameIterator::next(ExecState* exec)
     if (m_position == m_end)
         return noValue();
 
-    if (m_data->cachedStructureID() == m_object->structureID() && structureIDChainsAreEqual(m_data->cachedPrototypeChain(), m_object->structureID()->cachedPrototypeChain()))
+    if (m_data->cachedStructure() == m_object->structure() && structureChainsAreEqual(m_data->cachedPrototypeChain(), m_object->structure()->cachedPrototypeChain()))
         return jsOwnedString(exec, (*m_position++).ustring());
 
     do {
index b152862..7f27364 100644 (file)
@@ -44,7 +44,7 @@ namespace JSC{
         
     public:
         JSStaticScopeObject(ExecState* exec, const Identifier& ident, JSValue* value, unsigned attributes)
-            : JSVariableObject(exec->globalData().staticScopeStructureID, new JSStaticScopeObjectData())
+            : JSVariableObject(exec->globalData().staticScopeStructure, new JSStaticScopeObjectData())
         {
             d()->registerStore = value;
             symbolTable().add(ident.ustring().rep(), SymbolTableEntry(-1, attributes));
@@ -58,7 +58,7 @@ namespace JSC{
         virtual void put(ExecState*, const Identifier&, JSValue*, PutPropertySlot&);
         void putWithAttributes(ExecState*, const Identifier&, JSValue*, unsigned attributes);
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* proto) { return StructureID::create(proto, TypeInfo(ObjectType, NeedsThisConversion)); }
+        static PassRefPtr<Structure> createStructure(JSValue* proto) { return Structure::create(proto, TypeInfo(ObjectType, NeedsThisConversion)); }
 
     private:
         JSStaticScopeObjectData* d() { return static_cast<JSStaticScopeObjectData*>(JSVariableObject::d); }
index 45cbe2b..d6212d8 100644 (file)
@@ -64,7 +64,7 @@ namespace JSC {
 
     public:
         JSString(JSGlobalData* globalData, const UString& value)
-            : JSCell(globalData->stringStructureID.get())
+            : JSCell(globalData->stringStructure.get())
             , m_value(value)
         {
             Heap::heap(this)->reportExtraMemoryCost(value.cost());
@@ -72,12 +72,12 @@ namespace JSC {
 
         enum HasOtherOwnerType { HasOtherOwner };
         JSString(JSGlobalData* globalData, const UString& value, HasOtherOwnerType)
-            : JSCell(globalData->stringStructureID.get())
+            : JSCell(globalData->stringStructure.get())
             , m_value(value)
         {
         }
         JSString(JSGlobalData* globalData, PassRefPtr<UString::Rep> value, HasOtherOwnerType)
-            : JSCell(globalData->stringStructureID.get())
+            : JSCell(globalData->stringStructure.get())
             , m_value(value)
         {
         }
@@ -90,7 +90,7 @@ namespace JSC {
         bool canGetIndex(unsigned i) { return i < static_cast<unsigned>(m_value.size()); }
         JSString* getIndex(JSGlobalData*, unsigned);
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* proto) { return StructureID::create(proto, TypeInfo(StringType, NeedsThisConversion)); }
+        static PassRefPtr<Structure> createStructure(JSValue* proto) { return Structure::create(proto, TypeInfo(StringType, NeedsThisConversion)); }
 
     private:
         enum VPtrStealingHackType { VPtrStealingHack };
index 1194517..91ad698 100644 (file)
@@ -82,8 +82,8 @@ namespace JSC {
             JSVariableObjectData& operator=(const JSVariableObjectData&);
         };
 
-        JSVariableObject(PassRefPtr<StructureID> structureID, JSVariableObjectData* data)
-            : JSObject(structureID)
+        JSVariableObject(PassRefPtr<Structure> structure, JSVariableObjectData* data)
+            : JSObject(structure)
             , d(data) // Subclass owns this pointer.
         {
         }
index 5e4ba17..7681c48 100644 (file)
@@ -30,7 +30,7 @@ namespace JSC {
     // Number, Boolean and Date which are wrappers for primitive types.
     class JSWrapperObject : public JSObject {
     protected:
-        explicit JSWrapperObject(PassRefPtr<StructureID>);
+        explicit JSWrapperObject(PassRefPtr<Structure>);
 
     public:
         JSValue* internalValue() const { return m_internalValue; }
@@ -42,7 +42,7 @@ namespace JSC {
         JSValue* m_internalValue;
     };
     
-    inline JSWrapperObject::JSWrapperObject(PassRefPtr<StructureID> structure)
+    inline JSWrapperObject::JSWrapperObject(PassRefPtr<Structure> structure)
         : JSObject(structure)
         , m_internalValue(noValue())
     {
index ee7b700..916f69b 100644 (file)
@@ -83,7 +83,7 @@ const ClassInfo MathObject::info = { "Math", 0, 0, ExecState::mathTable };
 @end
 */
 
-MathObject::MathObject(ExecState* exec, PassRefPtr<StructureID> structure)
+MathObject::MathObject(ExecState* exec, PassRefPtr<Structure> structure)
     : JSObject(structure)
 {
     putDirectWithoutTransition(Identifier(exec, "E"), jsNumber(exec, exp(1.0)), DontDelete | DontEnum | ReadOnly);
index 704b10e..e16e79d 100644 (file)
@@ -27,16 +27,16 @@ namespace JSC {
 
     class MathObject : public JSObject {
     public:
-        MathObject(ExecState*, PassRefPtr<StructureID>);
+        MathObject(ExecState*, PassRefPtr<Structure>);
 
         virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
 
         virtual const ClassInfo* classInfo() const { return &info; }
         static const ClassInfo info;
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* prototype)
+        static PassRefPtr<Structure> createStructure(JSValue* prototype)
         {
-            return StructureID::create(prototype, TypeInfo(ObjectType));
+            return Structure::create(prototype, TypeInfo(ObjectType));
         }
     };
 
index f223c51..1124e1f 100644 (file)
@@ -32,9 +32,9 @@ ASSERT_CLASS_FITS_IN_CELL(NativeErrorConstructor);
 
 const ClassInfo NativeErrorConstructor::info = { "Function", &InternalFunction::info, 0, 0 };
 
-NativeErrorConstructor::NativeErrorConstructor(ExecState* exec, PassRefPtr<StructureID> structure, NativeErrorPrototype* nativeErrorPrototype)
+NativeErrorConstructor::NativeErrorConstructor(ExecState* exec, PassRefPtr<Structure> structure, NativeErrorPrototype* nativeErrorPrototype)
     : InternalFunction(&exec->globalData(), structure, Identifier(exec, nativeErrorPrototype->getDirect(exec->propertyNames().name)->getString()))
-    , m_errorStructure(ErrorInstance::createStructureID(nativeErrorPrototype))
+    , m_errorStructure(ErrorInstance::createStructure(nativeErrorPrototype))
 {
     putDirect(exec->propertyNames().length, jsNumber(exec, 1), DontDelete | ReadOnly | DontEnum); // ECMA 15.11.7.5
     putDirect(exec->propertyNames().prototype, nativeErrorPrototype, DontDelete | ReadOnly | DontEnum);
index 85acbb9..118d1f4 100644 (file)
@@ -31,7 +31,7 @@ namespace JSC {
 
     class NativeErrorConstructor : public InternalFunction {
     public:
-        NativeErrorConstructor(ExecState*, PassRefPtr<StructureID>, NativeErrorPrototype*);
+        NativeErrorConstructor(ExecState*, PassRefPtr<Structure>, NativeErrorPrototype*);
 
         static const ClassInfo info;
 
@@ -43,7 +43,7 @@ namespace JSC {
 
         virtual const ClassInfo* classInfo() const { return &info; }
 
-        RefPtr<StructureID> m_errorStructure;
+        RefPtr<Structure> m_errorStructure;
     };
 
 } // namespace JSC
index df311d5..84190a0 100644 (file)
@@ -29,7 +29,7 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(NativeErrorPrototype);
 
-NativeErrorPrototype::NativeErrorPrototype(ExecState* exec, PassRefPtr<StructureID> structure, const UString& name, const UString& message)
+NativeErrorPrototype::NativeErrorPrototype(ExecState* exec, PassRefPtr<Structure> structure, const UString& name, const UString& message)
     : JSObject(structure)
 {
     putDirect(exec->propertyNames().name, jsString(exec, name), 0);
index 719cb90..77bfe8a 100644 (file)
@@ -27,7 +27,7 @@ namespace JSC {
 
     class NativeErrorPrototype : public JSObject {
     public:
-        NativeErrorPrototype(ExecState*, PassRefPtr<StructureID>, const UString& name, const UString& message);
+        NativeErrorPrototype(ExecState*, PassRefPtr<Structure>, const UString& name, const UString& message);
     };
 
 } // namespace JSC
index 5b6ccf8..5fa2f14 100644 (file)
@@ -53,7 +53,7 @@ const ClassInfo NumberConstructor::info = { "Function", &InternalFunction::info,
 @end
 */
 
-NumberConstructor::NumberConstructor(ExecState* exec, PassRefPtr<StructureID> structure, NumberPrototype* numberPrototype)
+NumberConstructor::NumberConstructor(ExecState* exec, PassRefPtr<Structure> structure, NumberPrototype* numberPrototype)
     : InternalFunction(&exec->globalData(), structure, Identifier(exec, numberPrototype->info.className))
 {
     // Number.Prototype
index 8da23c4..5b38168 100644 (file)
@@ -29,16 +29,16 @@ namespace JSC {
 
     class NumberConstructor : public InternalFunction {
     public:
-        NumberConstructor(ExecState*, PassRefPtr<StructureID>, NumberPrototype*);
+        NumberConstructor(ExecState*, PassRefPtr<Structure>, NumberPrototype*);
 
         virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
         JSValue* getValueProperty(ExecState*, int token) const;
 
         static const ClassInfo info;
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* proto) 
+        static PassRefPtr<Structure> createStructure(JSValue* proto) 
         { 
-            return StructureID::create(proto, TypeInfo(ObjectType, ImplementsHasInstance)); 
+            return Structure::create(proto, TypeInfo(ObjectType, ImplementsHasInstance)); 
         }
 
         enum { NaNValue, NegInfinity, PosInfinity, MaxValue, MinValue };
index 252671b..62fd5a1 100644 (file)
@@ -31,7 +31,7 @@ ASSERT_CLASS_FITS_IN_CELL(NumberObject);
 
 const ClassInfo NumberObject::info = { "Number", 0, 0, 0 };
 
-NumberObject::NumberObject(PassRefPtr<StructureID> structure)
+NumberObject::NumberObject(PassRefPtr<Structure> structure)
     : JSWrapperObject(structure)
 {
 }
index eddecd1..b3cb115 100644 (file)
@@ -29,7 +29,7 @@ namespace JSC {
 
     class NumberObject : public JSWrapperObject {
     public:
-        explicit NumberObject(PassRefPtr<StructureID>);
+        explicit NumberObject(PassRefPtr<Structure>);
 
         static const ClassInfo info;
 
index b23641e..117205f 100644 (file)
@@ -44,7 +44,7 @@ static JSValue* numberProtoFuncToPrecision(ExecState*, JSObject*, JSValue*, cons
 
 // ECMA 15.7.4
 
-NumberPrototype::NumberPrototype(ExecState* exec, PassRefPtr<StructureID> structure, StructureID* prototypeFunctionStructure)
+NumberPrototype::NumberPrototype(ExecState* exec, PassRefPtr<Structure> structure, Structure* prototypeFunctionStructure)
     : NumberObject(structure)
 {
     setInternalValue(jsNumber(exec, 0));
index d70f260..0a3a544 100644 (file)
@@ -27,7 +27,7 @@ namespace JSC {
 
     class NumberPrototype : public NumberObject {
     public:
-        NumberPrototype(ExecState*, PassRefPtr<StructureID>, StructureID* prototypeFunctionStructure);
+        NumberPrototype(ExecState*, PassRefPtr<Structure>, Structure* prototypeFunctionStructure);
     };
 
 } // namespace JSC
index 329816f..537c39e 100644 (file)
@@ -28,7 +28,7 @@ namespace JSC {
 
 ASSERT_CLASS_FITS_IN_CELL(ObjectConstructor);
 
-ObjectConstructor::ObjectConstructor(ExecState* exec, PassRefPtr<StructureID> structure, ObjectPrototype* objectPrototype)
+ObjectConstructor::ObjectConstructor(ExecState* exec, PassRefPtr<Structure> structure, ObjectPrototype* objectPrototype)
     : InternalFunction(&exec->globalData(), structure, Identifier(exec, "Object"))
 {
     // ECMA 15.2.3.1
index c100424..f8c058a 100644 (file)
@@ -29,7 +29,7 @@ namespace JSC {
 
     class ObjectConstructor : public InternalFunction {
     public:
-        ObjectConstructor(ExecState*, PassRefPtr<StructureID>, ObjectPrototype*);
+        ObjectConstructor(ExecState*, PassRefPtr<Structure>, ObjectPrototype*);
 
     private:
         virtual ConstructType getConstructData(ConstructData&);
index 42a8063..a49a1b0 100644 (file)
@@ -39,7 +39,7 @@ static JSValue* objectProtoFuncLookupSetter(ExecState*, JSObject*, JSValue*, con
 static JSValue* objectProtoFuncPropertyIsEnumerable(ExecState*, JSObject*, JSValue*, const ArgList&);
 static JSValue* objectProtoFuncToLocaleString(ExecState*, JSObject*, JSValue*, const ArgList&);
 
-ObjectPrototype::ObjectPrototype(ExecState* exec, PassRefPtr<StructureID> stucture, StructureID* prototypeFunctionStructure)
+ObjectPrototype::ObjectPrototype(ExecState* exec, PassRefPtr<Structure> stucture, Structure* prototypeFunctionStructure)
     : JSObject(stucture)
 {
     putDirectFunctionWithoutTransition(exec, new (exec) PrototypeFunction(exec, prototypeFunctionStructure, 0, exec->propertyNames().toString, objectProtoFuncToString), DontEnum);
index aefdf95..3bebce4 100644 (file)
@@ -27,7 +27,7 @@ namespace JSC {
 
     class ObjectPrototype : public JSObject {
     public:
-        ObjectPrototype(ExecState*, PassRefPtr<StructureID>, StructureID* prototypeFunctionStructure);
+        ObjectPrototype(ExecState*, PassRefPtr<Structure>, Structure* prototypeFunctionStructure);
     };
 
     JSValue* objectProtoFuncToString(ExecState*, JSObject*, JSValue*, const ArgList&);
index fad9720..736848a 100644 (file)
@@ -50,13 +50,13 @@ namespace JSC {
                   return true;
               if (JSImmediate::isImmediate(v2))
                   return false;
-              return v2->asCell()->structureID()->typeInfo().masqueradesAsUndefined();
+              return v2->asCell()->structure()->typeInfo().masqueradesAsUndefined();
           }
 
           if (v2->isUndefinedOrNull()) {
               if (JSImmediate::isImmediate(v1))
                   return false;
-              return v1->asCell()->structureID()->typeInfo().masqueradesAsUndefined();
+              return v1->asCell()->structure()->typeInfo().masqueradesAsUndefined();
           }
 
           if (v1->isObject()) {
index 4f7c258..e9edb02 100644 (file)
@@ -23,7 +23,7 @@
 
 #include "ExecState.h"
 #include "Identifier.h"
-#include "StructureID.h"
+#include "Structure.h"
 #include <wtf/HashSet.h>
 #include <wtf/Vector.h>
 
@@ -41,21 +41,21 @@ namespace JSC {
 
         PropertyNameVector& propertyNameVector() { return m_propertyNameVector; }
 
-        void setCachedStructureID(StructureID* structureID) { m_cachedStructureID = structureID; }
-        StructureID* cachedStructureID() const { return m_cachedStructureID; }
+        void setCachedStructure(Structure* structure) { m_cachedStructure = structure; }
+        Structure* cachedStructure() const { return m_cachedStructure; }
 
-        void setCachedPrototypeChain(PassRefPtr<StructureIDChain> cachedPrototypeChain) { m_cachedPrototypeChain = cachedPrototypeChain; }
-        StructureIDChain* cachedPrototypeChain() { return m_cachedPrototypeChain.get(); }
+        void setCachedPrototypeChain(PassRefPtr<StructureChain> cachedPrototypeChain) { m_cachedPrototypeChain = cachedPrototypeChain; }
+        StructureChain* cachedPrototypeChain() { return m_cachedPrototypeChain.get(); }
 
     private:
         PropertyNameArrayData()
-            : m_cachedStructureID(0)
+            : m_cachedStructure(0)
         {
         }
 
         PropertyNameVector m_propertyNameVector;
-        StructureID* m_cachedStructureID;
-        RefPtr<StructureIDChain> m_cachedPrototypeChain;
+        Structure* m_cachedStructure;
+        RefPtr<StructureChain> m_cachedPrototypeChain;
     };
 
     class PropertyNameArray {
index 8afe6a4..8e3d107 100644 (file)
@@ -40,7 +40,7 @@ PrototypeFunction::PrototypeFunction(ExecState* exec, int length, const Identifi
     putDirect(exec->propertyNames().length, jsNumber(exec, length), DontDelete | ReadOnly | DontEnum);
 }
 
-PrototypeFunction::PrototypeFunction(ExecState* exec, PassRefPtr<StructureID> prototypeFunctionStructure, int length, const Identifier& name, NativeFunction function)
+PrototypeFunction::PrototypeFunction(ExecState* exec, PassRefPtr<Structure> prototypeFunctionStructure, int length, const Identifier& name, NativeFunction function)
     : InternalFunction(&exec->globalData(), prototypeFunctionStructure, name)
     , m_function(function)
 {
index 1592995..99ab327 100644 (file)
@@ -32,7 +32,7 @@ namespace JSC {
     class PrototypeFunction : public InternalFunction {
     public:
         PrototypeFunction(ExecState*, int length, const Identifier&, NativeFunction);
-        PrototypeFunction(ExecState*, PassRefPtr<StructureID>, int length, const Identifier&, NativeFunction);
+        PrototypeFunction(ExecState*, PassRefPtr<Structure>, int length, const Identifier&, NativeFunction);
 
     private:
         virtual CallType getCallData(CallData&);
index 6e3b90c..fb745e5 100644 (file)
@@ -103,7 +103,7 @@ struct RegExpConstructorPrivate {
     bool multiline : 1;
 };
 
-RegExpConstructor::RegExpConstructor(ExecState* exec, PassRefPtr<StructureID> structure, RegExpPrototype* regExpPrototype)
+RegExpConstructor::RegExpConstructor(ExecState* exec, PassRefPtr<Structure> structure, RegExpPrototype* regExpPrototype)
     : InternalFunction(&exec->globalData(), structure, Identifier(exec, "RegExp"))
     , d(new RegExpConstructorPrivate)
 {
index c5a94a5..8865c05 100644 (file)
@@ -32,11 +32,11 @@ namespace JSC {
 
     class RegExpConstructor : public InternalFunction {
     public:
-        RegExpConstructor(ExecState*, PassRefPtr<StructureID>, RegExpPrototype*);
+        RegExpConstructor(ExecState*, PassRefPtr<Structure>, RegExpPrototype*);
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* prototype)
+        static PassRefPtr<Structure> createStructure(JSValue* prototype)
         {
-            return StructureID::create(prototype, TypeInfo(ObjectType, ImplementsHasInstance));
+            return Structure::create(prototype, TypeInfo(ObjectType, ImplementsHasInstance));
         }
 
         virtual void put(ExecState*, const Identifier& propertyName, JSValue*, PutPropertySlot&);
index 127a71e..95434d4 100644 (file)
@@ -56,7 +56,7 @@ const ClassInfo RegExpObject::info = { "RegExp", 0, 0, ExecState::regExpTable };
 @end
 */
 
-RegExpObject::RegExpObject(PassRefPtr<StructureID> structure, PassRefPtr<RegExp> regExp)
+RegExpObject::RegExpObject(PassRefPtr<Structure> structure, PassRefPtr<RegExp> regExp)
     : JSObject(structure)
     , d(new RegExpObjectData(regExp, 0))
 {
index d5bf225..0dc6448 100644 (file)
@@ -28,7 +28,7 @@ namespace JSC {
 
     class RegExpObject : public JSObject {
     public:
-        RegExpObject(PassRefPtr<StructureID>, PassRefPtr<RegExp>);
+        RegExpObject(PassRefPtr<Structure>, PassRefPtr<RegExp>);
         virtual ~RegExpObject();
 
         void setRegExp(PassRefPtr<RegExp> r) { d->regExp = r; }
@@ -46,9 +46,9 @@ namespace JSC {
         virtual const ClassInfo* classInfo() const { return &info; }
         static const ClassInfo info;
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* prototype)
+        static PassRefPtr<Structure> createStructure(JSValue* prototype)
         {
-            return StructureID::create(prototype, TypeInfo(ObjectType));
+            return Structure::create(prototype, TypeInfo(ObjectType));
         }
 
     private:
index 6514ad6..e932244 100644 (file)
@@ -44,7 +44,7 @@ static JSValue* regExpProtoFuncToString(ExecState*, JSObject*, JSValue*, const A
 
 const ClassInfo RegExpPrototype::info = { "RegExpPrototype", 0, 0, 0 };
 
-RegExpPrototype::RegExpPrototype(ExecState* exec, PassRefPtr<StructureID> structure, StructureID* prototypeFunctionStructure)
+RegExpPrototype::RegExpPrototype(ExecState* exec, PassRefPtr<Structure> structure, Structure* prototypeFunctionStructure)
     : JSObject(structure)
 {
     putDirectFunctionWithoutTransition(exec, new (exec) PrototypeFunction(exec, prototypeFunctionStructure, 0, exec->propertyNames().compile, regExpProtoFuncCompile), DontEnum);
index 44a0f32..f5db720 100644 (file)
@@ -27,7 +27,7 @@ namespace JSC {
 
     class RegExpPrototype : public JSObject {
     public:
-        RegExpPrototype(ExecState*, PassRefPtr<StructureID>, StructureID* prototypeFunctionStructure);
+        RegExpPrototype(ExecState*, PassRefPtr<Structure>, Structure* prototypeFunctionStructure);
 
         virtual const ClassInfo* classInfo() const { return &info; }
         static const ClassInfo info;
index 850310e..e373955 100644 (file)
@@ -46,7 +46,7 @@ static JSValue* stringFromCharCode(ExecState* exec, JSObject*, JSValue*, const A
 
 ASSERT_CLASS_FITS_IN_CELL(StringConstructor);
 
-StringConstructor::StringConstructor(ExecState* exec, PassRefPtr<StructureID> structure, StructureID* prototypeFunctionStructure, StringPrototype* stringPrototype)
+StringConstructor::StringConstructor(ExecState* exec, PassRefPtr<Structure> structure, Structure* prototypeFunctionStructure, StringPrototype* stringPrototype)
     : InternalFunction(&exec->globalData(), structure, Identifier(exec, stringPrototype->classInfo()->className))
 {
     // ECMA 15.5.3.1 String.prototype
index 3376134..7d52c69 100644 (file)
@@ -29,7 +29,7 @@ namespace JSC {
 
     class StringConstructor : public InternalFunction {
     public:
-        StringConstructor(ExecState*, PassRefPtr<StructureID>, StructureID* prototypeFunctionStructure, StringPrototype*);
+        StringConstructor(ExecState*, PassRefPtr<Structure>, Structure* prototypeFunctionStructure, StringPrototype*);
 
         virtual ConstructType getConstructData(ConstructData&);
         virtual CallType getCallData(CallData&);
index 5959395..8b87a52 100644 (file)
@@ -29,19 +29,19 @@ ASSERT_CLASS_FITS_IN_CELL(StringObject);
 
 const ClassInfo StringObject::info = { "String", 0, 0, 0 };
 
-StringObject::StringObject(ExecState* exec, PassRefPtr<StructureID> structure)
+StringObject::StringObject(ExecState* exec, PassRefPtr<Structure> structure)
     : JSWrapperObject(structure)
 {
     setInternalValue(jsEmptyString(exec));
 }
 
-StringObject::StringObject(PassRefPtr<StructureID> structure, JSString* string)
+StringObject::StringObject(PassRefPtr<Structure> structure, JSString* string)
     : JSWrapperObject(structure)
 {
     setInternalValue(string);
 }
 
-StringObject::StringObject(ExecState* exec, PassRefPtr<StructureID> structure, const UString& string)
+StringObject::StringObject(ExecState* exec, PassRefPtr<Structure> structure, const UString& string)
     : JSWrapperObject(structure)
 {
     setInternalValue(jsString(exec, string));
index 9297fd7..ad8683f 100644 (file)
@@ -28,8 +28,8 @@ namespace JSC {
 
     class StringObject : public JSWrapperObject {
     public:
-        StringObject(ExecState*, PassRefPtr<StructureID>);
-        StringObject(ExecState*, PassRefPtr<StructureID>, const UString&);
+        StringObject(ExecState*, PassRefPtr<Structure>);
+        StringObject(ExecState*, PassRefPtr<Structure>, const UString&);
 
         static StringObject* create(ExecState*, JSString*);
 
@@ -45,13 +45,13 @@ namespace JSC {
 
         JSString* internalValue() const { return asString(JSWrapperObject::internalValue());}
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* prototype)
+        static PassRefPtr<Structure> createStructure(JSValue* prototype)
         {
-            return StructureID::create(prototype, TypeInfo(ObjectType));
+            return Structure::create(prototype, TypeInfo(ObjectType));
         }
 
     protected:
-        StringObject(PassRefPtr<StructureID>, JSString*);
+        StringObject(PassRefPtr<Structure>, JSString*);
 
     private:
         virtual UString toString(ExecState*) const;
index fad3852..5c0f932 100644 (file)
@@ -33,18 +33,18 @@ namespace JSC {
         static StringObjectThatMasqueradesAsUndefined* create(ExecState* exec, const UString& string)
         {
             return new (exec) StringObjectThatMasqueradesAsUndefined(exec,
-                createStructureID(exec->lexicalGlobalObject()->stringPrototype()), string);
+                createStructure(exec->lexicalGlobalObject()->stringPrototype()), string);
         }
 
     private:
-        StringObjectThatMasqueradesAsUndefined(ExecState* exec, PassRefPtr<StructureID> structure, const UString& string)
+        StringObjectThatMasqueradesAsUndefined(ExecState* exec, PassRefPtr<Structure> structure, const UString& string)
             : StringObject(exec, structure, string)
         {
         }
 
-        static PassRefPtr<StructureID> createStructureID(JSValue* proto) 
+        static PassRefPtr<Structure> createStructure(JSValue* proto) 
         { 
-            return StructureID::create(proto, TypeInfo(ObjectType, MasqueradesAsUndefined)); 
+            return Structure::create(proto, TypeInfo(ObjectType, MasqueradesAsUndefined)); 
         }
 
         virtual bool toBoolean(ExecState*) const { return false; }
index 0b11c24..c5495dd 100644 (file)
@@ -117,7 +117,7 @@ const ClassInfo StringPrototype::info = { "String", &StringObject::info, 0, Exec
 */
 
 // ECMA 15.5.4
-StringPrototype::StringPrototype(ExecState* exec, PassRefPtr<StructureID> structure)
+StringPrototype::StringPrototype(ExecState* exec, PassRefPtr<Structure> structure)
     : StringObject(exec, structure)
 {
     // The constructor will be added later, after StringConstructor has been built
index b127885..6f5344e 100644 (file)
@@ -29,7 +29,7 @@ namespace JSC {
 
     class StringPrototype : public StringObject {
     public:
-        StringPrototype(ExecState*, PassRefPtr<StructureID>);
+        StringPrototype(ExecState*, PassRefPtr<Structure>);
 
         virtual bool getOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
 
similarity index 74%
rename from JavaScriptCore/runtime/StructureID.cpp
rename to JavaScriptCore/runtime/Structure.cpp
index 742fa34..1e34316 100644 (file)
  */
 
 #include "config.h"
-#include "StructureID.h"
+#include "Structure.h"
 
 #include "Identifier.h"
 #include "JSObject.h"
 #include "PropertyNameArray.h"
-#include "StructureIDChain.h"
+#include "StructureChain.h"
 #include "Lookup.h"
 #include <wtf/RefCountedLeakCounter.h>
 #include <wtf/RefPtr.h>
@@ -62,21 +62,21 @@ static const unsigned tinyMapThreshold = 20;
 static const unsigned newTableSize = 16;
 
 #ifndef NDEBUG
-static WTF::RefCountedLeakCounter structureIDCounter("StructureID");
+static WTF::RefCountedLeakCounter structureCounter("Structure");
 
 #if ENABLE(JSC_MULTIPLE_THREADS)
 static Mutex ignoreSetMutex;
 #endif
 
 static bool shouldIgnoreLeaks;
-static HashSet<StructureID*> ignoreSet;
+static HashSet<Structure*> ignoreSet;
 #endif
 
 #if DUMP_STRUCTURE_ID_STATISTICS
-static HashSet<StructureID*> liveStructureIDSet;
+static HashSet<Structure*> liveStructureSet;
 #endif
 
-void StructureID::dumpStatistics()
+void Structure::dumpStatistics()
 {
 #if DUMP_STRUCTURE_ID_STATISTICS
     unsigned numberLeaf = 0;
@@ -85,40 +85,40 @@ void StructureID::dumpStatistics()
     unsigned numberWithPropertyMaps = 0;
     unsigned totalPropertyMapsSize = 0;
 
-    HashSet<StructureID*>::const_iterator end = liveStructureIDSet.end();
-    for (HashSet<StructureID*>::const_iterator it = liveStructureIDSet.begin(); it != end; ++it) {
-        StructureID* structureID = *it;
-        if (structureID->m_usingSingleTransitionSlot) {
-            if (!structureID->m_transitions.singleTransition)
+    HashSet<Structure*>::const_iterator end = liveStructureSet.end();
+    for (HashSet<Structure*>::const_iterator it = liveStructureSet.begin(); it != end; ++it) {
+        Structure* structure = *it;
+        if (structure->m_usingSingleTransitionSlot) {
+            if (!structure->m_transitions.singleTransition)
                 ++numberLeaf;
             else
                 ++numberUsingSingleSlot;
 
-           if (!structureID->m_previous && !structureID->m_transitions.singleTransition)
+           if (!structure->m_previous && !structure->m_transitions.singleTransition)
                 ++numberSingletons;
         }
 
-        if (structureID->m_propertyTable) {
+        if (structure->m_propertyTable) {
             ++numberWithPropertyMaps;
-            totalPropertyMapsSize += PropertyMapHashTable::allocationSize(structureID->m_propertyTable->size);
+            totalPropertyMapsSize += PropertyMapHashTable::allocationSize(structure->m_propertyTable->size);
         }
     }
 
-    printf("Number of live StructureIDs: %d\n", liveStructureIDSet.size());
-    printf("Number of StructureIDs using the single item optimization for transition map: %d\n", numberUsingSingleSlot);
-    printf("Number of StructureIDs that are leaf nodes: %d\n", numberLeaf);
-    printf("Number of StructureIDs that singletons: %d\n", numberSingletons);
-    printf("Number of StructureIDs with PropertyMaps: %d\n", numberWithPropertyMaps);
+    printf("Number of live Structures: %d\n", liveStructureSet.size());
+    printf("Number of Structures using the single item optimization for transition map: %d\n", numberUsingSingleSlot);
+    printf("Number of Structures that are leaf nodes: %d\n", numberLeaf);
+    printf("Number of Structures that singletons: %d\n", numberSingletons);
+    printf("Number of Structures with PropertyMaps: %d\n", numberWithPropertyMaps);
 
-    printf("Size of a single StructureIDs: %d\n", static_cast<unsigned>(sizeof(StructureID)));
+    printf("Size of a single Structures: %d\n", static_cast<unsigned>(sizeof(Structure)));
     printf("Size of sum of all property maps: %d\n", totalPropertyMapsSize);
-    printf("Size of average of all property maps: %f\n", static_cast<double>(totalPropertyMapsSize) / static_cast<double>(liveStructureIDSet.size()));
+    printf("Size of average of all property maps: %f\n", static_cast<double>(totalPropertyMapsSize) / static_cast<double>(liveStructureSet.size()));
 #else
-    printf("Dumping StructureID statistics is not enabled.\n");
+    printf("Dumping Structure statistics is not enabled.\n");
 #endif
 }
 
-StructureID::StructureID(JSValue* prototype, const TypeInfo& typeInfo)
+Structure::Structure(JSValue* prototype, const TypeInfo& typeInfo)
     : m_typeInfo(typeInfo)
     , m_prototype(prototype)
     , m_cachedPrototypeChain(0)
@@ -146,15 +146,15 @@ StructureID::StructureID(JSValue* prototype, const TypeInfo& typeInfo)
     if (shouldIgnoreLeaks)
         ignoreSet.add(this);
     else
-        structureIDCounter.increment();
+        structureCounter.increment();
 #endif
 
 #if DUMP_STRUCTURE_ID_STATISTICS
-    liveStructureIDSet.add(this);
+    liveStructureSet.add(this);
 #endif
 }
 
-StructureID::~StructureID()
+Structure::~Structure()
 {
     if (m_previous) {
         if (m_previous->m_usingSingleTransitionSlot) {
@@ -166,7 +166,7 @@ StructureID::~StructureID()
     }
 
     if (m_cachedPropertyNameArrayData)
-        m_cachedPropertyNameArrayData->setCachedStructureID(0);
+        m_cachedPropertyNameArrayData->setCachedStructure(0);
 
     if (!m_usingSingleTransitionSlot)
         delete m_transitions.table;
@@ -184,26 +184,26 @@ StructureID::~StructureID()
 #if ENABLE(JSC_MULTIPLE_THREADS)
     MutexLocker protect(ignoreSetMutex);
 #endif
-    HashSet<StructureID*>::iterator it = ignoreSet.find(this);
+    HashSet<Structure*>::iterator it = ignoreSet.find(this);
     if (it != ignoreSet.end())
         ignoreSet.remove(it);
     else
-        structureIDCounter.decrement();
+        structureCounter.decrement();
 #endif
 
 #if DUMP_STRUCTURE_ID_STATISTICS
-    liveStructureIDSet.remove(this);
+    liveStructureSet.remove(this);
 #endif
 }
 
-void StructureID::startIgnoringLeaks()
+void Structure::startIgnoringLeaks()
 {
 #ifndef NDEBUG
     shouldIgnoreLeaks = true;
 #endif
 }
 
-void StructureID::stopIgnoringLeaks()
+void Structure::stopIgnoringLeaks()
 {
 #ifndef NDEBUG
     shouldIgnoreLeaks = false;
@@ -247,16 +247,16 @@ static unsigned sizeForKeyCount(size_t keyCount)
     return nextPowerOf2(keyCount) * 2;
 }
 
-void StructureID::materializePropertyMap()
+void Structure::materializePropertyMap()
 {
     ASSERT(!m_propertyTable);
 
-    Vector<StructureID*, 8> structures;
+    Vector<Structure*, 8> structures;
     structures.append(this);
 
-    StructureID* structure = this;
+    Structure* structure = this;
 
-    // Search for the last StructureID with a property table. 
+    // Search for the last Structure with a property table. 
     while ((structure = structure->previousID())) {
         if (structure->m_isPinnedPropertyTable) {
             ASSERT(structure->m_propertyTable);
@@ -284,13 +284,13 @@ void StructureID::materializePropertyMap()
     }
 }
 
-void StructureID::getEnumerablePropertyNames(ExecState* exec, PropertyNameArray& propertyNames, JSObject* baseObject)
+void Structure::getEnumerablePropertyNames(ExecState* exec, PropertyNameArray& propertyNames, JSObject* baseObject)
 {
     bool shouldCache = propertyNames.cacheable() && !(propertyNames.size() || m_isDictionary);
 
     if (shouldCache) {
         if (m_cachedPropertyNameArrayData) {
-            if (structureIDChainsAreEqual(m_cachedPropertyNameArrayData->cachedPrototypeChain(), cachedPrototypeChain())) {
+            if (structureChainsAreEqual(m_cachedPropertyNameArrayData->cachedPrototypeChain(), cachedPrototypeChain())) {
                 propertyNames.setData(m_cachedPropertyNameArrayData);
                 return;
             }
@@ -320,26 +320,26 @@ void StructureID::getEnumerablePropertyNames(ExecState* exec, PropertyNameArray&
 
     if (shouldCache) {
         if (m_cachedPropertyNameArrayData)
-            m_cachedPropertyNameArrayData->setCachedStructureID(0);
+            m_cachedPropertyNameArrayData->setCachedStructure(0);
 
         m_cachedPropertyNameArrayData = propertyNames.data();
 
-        StructureIDChain* chain = cachedPrototypeChain();
+        StructureChain* chain = cachedPrototypeChain();
         if (!chain)
             chain = createCachedPrototypeChain();
         m_cachedPropertyNameArrayData->setCachedPrototypeChain(chain);
-        m_cachedPropertyNameArrayData->setCachedStructureID(this);
+        m_cachedPropertyNameArrayData->setCachedStructure(this);
     }
 }
 
-void StructureID::clearEnumerationCache()
+void Structure::clearEnumerationCache()
 {
     if (m_cachedPropertyNameArrayData)
-        m_cachedPropertyNameArrayData->setCachedStructureID(0);
+        m_cachedPropertyNameArrayData->setCachedStructure(0);
     m_cachedPropertyNameArrayData.clear();
 }
 
-void StructureID::growPropertyStorageCapacity()
+void Structure::growPropertyStorageCapacity()
 {
     if (m_propertyStorageCapacity == JSObject::inlineStorageCapacity)
         m_propertyStorageCapacity = JSObject::nonInlineBaseStorageCapacity;
@@ -347,20 +347,20 @@ void StructureID::growPropertyStorageCapacity()
         m_propertyStorageCapacity *= 2;
 }
 
-PassRefPtr<StructureID> StructureID::addPropertyTransitionToExistingStructure(StructureID* structureID, const Identifier& propertyName, unsigned attributes, size_t& offset)
+PassRefPtr<Structure> Structure::addPropertyTransitionToExistingStructure(Structure* structure, const Identifier& propertyName, unsigned attributes, size_t& offset)
 {
-    ASSERT(!structureID->m_isDictionary);
-    ASSERT(structureID->typeInfo().type() == ObjectType);
+    ASSERT(!structure->m_isDictionary);
+    ASSERT(structure->typeInfo().type() == ObjectType);
 
-    if (structureID->m_usingSingleTransitionSlot) {
-        StructureID* existingTransition = structureID->m_transitions.singleTransition;
+    if (structure->m_usingSingleTransitionSlot) {
+        Structure* existingTransition = structure->m_transitions.singleTransition;
         if (existingTransition && existingTransition->m_nameInPrevious == propertyName.ustring().rep() && existingTransition->m_attributesInPrevious == attributes) {
-            offset = structureID->m_transitions.singleTransition->m_offset;
+            offset = structure->m_transitions.singleTransition->m_offset;
             ASSERT(offset != WTF::notFound);
             return existingTransition;
         }
     } else {
-        if (StructureID* existingTransition = structureID->m_transitions.table->get(make_pair(propertyName.ustring().rep(), attributes))) {
+        if (Structure* existingTransition = structure->m_transitions.table->get(make_pair(propertyName.ustring().rep(), attributes))) {
             offset = existingTransition->m_offset;
             ASSERT(offset != WTF::notFound);
             return existingTransition;
@@ -370,39 +370,39 @@ PassRefPtr<StructureID> StructureID::addPropertyTransitionToExistingStructure(St
     return 0;
 }
 
-PassRefPtr<StructureID> StructureID::addPropertyTransition(StructureID* structureID, const Identifier& propertyName, unsigned attributes, size_t& offset)
+PassRefPtr<Structure> Structure::addPropertyTransition(Structure* structure, const Identifier& propertyName, unsigned attributes, size_t& offset)
 {
-    ASSERT(!structureID->m_isDictionary);
-    ASSERT(structureID->typeInfo().type() == ObjectType);
-    ASSERT(structureID->m_deletedOffsets.isEmpty());
-    ASSERT(!StructureID::addPropertyTransitionToExistingStructure(structureID, propertyName, attributes, offset));
+    ASSERT(!structure->m_isDictionary);
+    ASSERT(structure->typeInfo().type() == ObjectType);
+    ASSERT(structure->m_deletedOffsets.isEmpty());
+    ASSERT(!Structure::addPropertyTransitionToExistingStructure(structure, propertyName, attributes, offset));
 
-    if (structureID->m_transitionCount > s_maxTransitionLength) {
-        RefPtr<StructureID> transition = toDictionaryTransition(structureID);
+    if (structure->m_transitionCount > s_maxTransitionLength) {
+        RefPtr<Structure> transition = toDictionaryTransition(structure);
         offset = transition->put(propertyName, attributes);
         if (transition->propertyStorageSize() > transition->propertyStorageCapacity())
             transition->growPropertyStorageCapacity();
         return transition.release();
     }
 
-    RefPtr<StructureID> transition = create(structureID->m_prototype, structureID->typeInfo());
-    transition->m_cachedPrototypeChain = structureID->m_cachedPrototypeChain;
-    transition->m_previous = structureID;
+    RefPtr<Structure> transition = create(structure->m_prototype, structure->typeInfo());
+    transition->m_cachedPrototypeChain = structure->m_cachedPrototypeChain;
+    transition->m_previous = structure;
     transition->m_nameInPrevious = propertyName.ustring().rep();
     transition->m_attributesInPrevious = attributes;
-    transition->m_transitionCount = structureID->m_transitionCount + 1;
-    transition->m_propertyStorageCapacity = structureID->m_propertyStorageCapacity;
-    transition->m_hasGetterSetterProperties = structureID->m_hasGetterSetterProperties;
+    transition->m_transitionCount = structure->m_transitionCount + 1;
+    transition->m_propertyStorageCapacity = structure->m_propertyStorageCapacity;
+    transition->m_hasGetterSetterProperties = structure->m_hasGetterSetterProperties;
 
-    if (structureID->m_propertyTable) {
-        if (structureID->m_isPinnedPropertyTable)
-            transition->m_propertyTable = structureID->copyPropertyTable();
+    if (structure->m_propertyTable) {
+        if (structure->m_isPinnedPropertyTable)
+            transition->m_propertyTable = structure->copyPropertyTable();
         else {
-            transition->m_propertyTable = structureID->m_propertyTable;
-            structureID->m_propertyTable = 0;
+            transition->m_propertyTable = structure->m_propertyTable;
+            structure->m_propertyTable = 0;
         }
     } else {
-        if (structureID->m_previous)
+        if (structure->m_previous)
             transition->materializePropertyMap();
         else
             transition->createPropertyMapHashTable();
@@ -414,102 +414,102 @@ PassRefPtr<StructureID> StructureID::addPropertyTransition(StructureID* structur
 
     transition->m_offset = offset;
 
-    if (structureID->m_usingSingleTransitionSlot) {
-        if (!structureID->m_transitions.singleTransition) {
-            structureID->m_transitions.singleTransition = transition.get();
+    if (structure->m_usingSingleTransitionSlot) {
+        if (!structure->m_transitions.singleTransition) {
+            structure->m_transitions.singleTransition = transition.get();
             return transition.release();
         }
 
-        StructureID* existingTransition = structureID->m_transitions.singleTransition;
-        structureID->m_usingSingleTransitionSlot = false;
-        StructureIDTransitionTable* transitionTable = new StructureIDTransitionTable;
-        structureID->m_transitions.table = transitionTable;
+        Structure* existingTransition = structure->m_transitions.singleTransition;
+        structure->m_usingSingleTransitionSlot = false;
+        StructureTransitionTable* transitionTable = new StructureTransitionTable;
+        structure->m_transitions.table = transitionTable;
         transitionTable->add(make_pair(existingTransition->m_nameInPrevious, existingTransition->m_attributesInPrevious), existingTransition);
     }
-    structureID->m_transitions.table->add(make_pair(propertyName.ustring().rep(), attributes), transition.get());
+    structure->m_transitions.table->add(make_pair(propertyName.ustring().rep(), attributes), transition.get());
     return transition.release();
 }
 
-PassRefPtr<StructureID> StructureID::removePropertyTransition(StructureID* structureID, const Identifier& propertyName, size_t& offset)
+PassRefPtr<Structure> Structure::removePropertyTransition(Structure* structure, const Identifier& propertyName, size_t& offset)
 {
-    ASSERT(!structureID->m_isDictionary);
+    ASSERT(!structure->m_isDictionary);
 
-    RefPtr<StructureID> transition = toDictionaryTransition(structureID);
+    RefPtr<Structure> transition = toDictionaryTransition(structure);
 
     offset = transition->remove(propertyName);
 
     return transition.release();
 }
 
-PassRefPtr<StructureID> StructureID::changePrototypeTransition(StructureID* structureID, JSValue* prototype)
+PassRefPtr<Structure> Structure::changePrototypeTransition(Structure* structure, JSValue* prototype)
 {
-    RefPtr<StructureID> transition = create(prototype, structureID->typeInfo());
+    RefPtr<Structure> transition = create(prototype, structure->typeInfo());
 
-    transition->m_transitionCount = structureID->m_transitionCount + 1;
-    transition->m_deletedOffsets = structureID->m_deletedOffsets;
-    transition->m_propertyStorageCapacity = structureID->m_propertyStorageCapacity;
-    transition->m_hasGetterSetterProperties = structureID->m_hasGetterSetterProperties;
+    transition->m_transitionCount = structure->m_transitionCount + 1;
+    transition->m_deletedOffsets = structure->m_deletedOffsets;
+    transition->m_propertyStorageCapacity = structure->m_propertyStorageCapacity;
+    transition->m_hasGetterSetterProperties = structure->m_hasGetterSetterProperties;
 
     // Don't set m_offset, as one can not transition to this.
 
-    structureID->materializePropertyMapIfNecessary();
-    transition->m_propertyTable = structureID->copyPropertyTable();
+    structure->materializePropertyMapIfNecessary();
+    transition->m_propertyTable = structure->copyPropertyTable();
     transition->m_isPinnedPropertyTable = true;
 
     return transition.release();
 }
 
-PassRefPtr<StructureID> StructureID::getterSetterTransition(StructureID* structureID)
+PassRefPtr<Structure> Structure::getterSetterTransition(Structure* structure)
 {
-    RefPtr<StructureID> transition = create(structureID->storedPrototype(), structureID->typeInfo());
-    transition->m_transitionCount = structureID->m_transitionCount + 1;
-    transition->m_deletedOffsets = structureID->m_deletedOffsets;
-    transition->m_propertyStorageCapacity = structureID->m_propertyStorageCapacity;
+    RefPtr<Structure> transition = create(structure->storedPrototype(), structure->typeInfo());
+    transition->m_transitionCount = structure->m_transitionCount + 1;
+    transition->m_deletedOffsets = structure->m_deletedOffsets;
+    transition->m_propertyStorageCapacity = structure->m_propertyStorageCapacity;
     transition->m_hasGetterSetterProperties = transition->m_hasGetterSetterProperties;
 
     // Don't set m_offset, as one can not transition to this.
 
-    structureID->materializePropertyMapIfNecessary();
-    transition->m_propertyTable = structureID->copyPropertyTable();
+    structure->materializePropertyMapIfNecessary();
+    transition->m_propertyTable = structure->copyPropertyTable();
     transition->m_isPinnedPropertyTable = true;
 
     return transition.release();
 }
 
-PassRefPtr<StructureID> StructureID::toDictionaryTransition(StructureID* structureID)
+PassRefPtr<Structure> Structure::toDictionaryTransition(Structure* structure)
 {
-    ASSERT(!structureID->m_isDictionary);
+    ASSERT(!structure->m_isDictionary);
 
-    RefPtr<StructureID> transition = create(structureID->m_prototype, structureID->typeInfo());
+    RefPtr<Structure> transition = create(structure->m_prototype, structure->typeInfo());
     transition->m_isDictionary = true;
-    transition->m_deletedOffsets = structureID->m_deletedOffsets;
-    transition->m_propertyStorageCapacity = structureID->m_propertyStorageCapacity;
-    transition->m_hasGetterSetterProperties = structureID->m_hasGetterSetterProperties;
+    transition->m_deletedOffsets = structure->m_deletedOffsets;
+    transition->m_propertyStorageCapacity = structure->m_propertyStorageCapacity;
+    transition->m_hasGetterSetterProperties = structure->m_hasGetterSetterProperties;
 
-    structureID->materializePropertyMapIfNecessary();
-    transition->m_propertyTable = structureID->copyPropertyTable();
+    structure->materializePropertyMapIfNecessary();
+    transition->m_propertyTable = structure->copyPropertyTable();
     transition->m_isPinnedPropertyTable = true;
 
     return transition.release();
 }
 
-PassRefPtr<StructureID> StructureID::fromDictionaryTransition(StructureID* structureID)
+PassRefPtr<Structure> Structure::fromDictionaryTransition(Structure* structure)
 {
-    ASSERT(structureID->m_isDictionary);
+    ASSERT(structure->m_isDictionary);
 
-    // Since dictionary StructureIDs are not shared, and no opcodes specialize
-    // for them, we don't need to allocate a new StructureID when transitioning
+    // Since dictionary Structures are not shared, and no opcodes specialize
+    // for them, we don't need to allocate a new Structure when transitioning
     // to non-dictionary status.
 
-    // FIMXE: We can make this more efficient by canonicalizing the StructureID (draining the
+    // FIMXE: We can make this more efficient by canonicalizing the Structure (draining the
     // deleted offsets vector) before transitioning from dictionary. 
-    if (structureID->m_deletedOffsets.isEmpty())
-        structureID->m_isDictionary = false;
+    if (structure->m_deletedOffsets.isEmpty())
+        structure->m_isDictionary = false;
 
-    return structureID;
+    return structure;
 }
 
-size_t StructureID::addPropertyWithoutTransition(const Identifier& propertyName, unsigned attributes)
+size_t Structure::addPropertyWithoutTransition(const Identifier& propertyName, unsigned attributes)
 {
     ASSERT(!m_transitions.singleTransition);
 
@@ -523,7 +523,7 @@ size_t StructureID::addPropertyWithoutTransition(const Identifier& propertyName,
     return offset;
 }
 
-size_t StructureID::removePropertyWithoutTransition(const Identifier& propertyName)
+size_t Structure::removePropertyWithoutTransition(const Identifier& propertyName)
 {
     ASSERT(!m_transitions.singleTransition);
     ASSERT(m_isDictionary);
@@ -536,7 +536,7 @@ size_t StructureID::removePropertyWithoutTransition(const Identifier& propertyNa
     return offset;
 }
 
-StructureIDChain* StructureID::createCachedPrototypeChain()
+StructureChain* Structure::createCachedPrototypeChain()
 {
     ASSERT(typeInfo().type() == ObjectType);
     ASSERT(!m_cachedPrototypeChain);
@@ -545,7 +545,7 @@ StructureIDChain* StructureID::createCachedPrototypeChain()
     if (JSImmediate::isImmediate(prototype))
         return 0;
 
-    RefPtr<StructureIDChain> chain = StructureIDChain::create(asObject(prototype)->structureID());
+    RefPtr<StructureChain> chain = StructureChain::create(asObject(prototype)->structure());
     setCachedPrototypeChain(chain.release());
     return cachedPrototypeChain();
 }
@@ -578,13 +578,13 @@ static const unsigned deletedSentinelIndex = 1;
 
 #if !DO_PROPERTYMAP_CONSTENCY_CHECK
 
-inline void StructureID::checkConsistency()
+inline void Structure::checkConsistency()
 {
 }
 
 #endif
 
-PropertyMapHashTable* StructureID::copyPropertyTable()
+PropertyMapHashTable* Structure::copyPropertyTable()
 {
     if (!m_propertyTable)
         return 0;
@@ -602,7 +602,7 @@ PropertyMapHashTable* StructureID::copyPropertyTable()
     return newTable;
 }
 
-size_t StructureID::get(const Identifier& propertyName, unsigned& attributes)
+size_t Structure::get(const Identifier& propertyName, unsigned& attributes)
 {
     ASSERT(!propertyName.isNull());
 
@@ -651,7 +651,7 @@ size_t StructureID::get(const Identifier& propertyName, unsigned& attributes)
     }
 }
 
-size_t StructureID::put(const Identifier& propertyName, unsigned attributes)
+size_t Structure::put(const Identifier& propertyName, unsigned attributes)
 {
     ASSERT(!propertyName.isNull());
     ASSERT(get(propertyName) == WTF::notFound);
@@ -740,7 +740,7 @@ size_t StructureID::put(const Identifier& propertyName, unsigned attributes)
     return newOffset;
 }
 
-size_t StructureID::remove(const Identifier& propertyName)
+size_t Structure::remove(const Identifier& propertyName)
 {
     ASSERT(!propertyName.isNull());
 
@@ -807,7 +807,7 @@ size_t StructureID::remove(const Identifier& propertyName)
     return offset;
 }
 
-void StructureID::insertIntoPropertyMapHashTable(const PropertyMapEntry& entry)
+void Structure::insertIntoPropertyMapHashTable(const PropertyMapEntry& entry)
 {
     ASSERT(m_propertyTable);
 
@@ -844,13 +844,13 @@ void StructureID::insertIntoPropertyMapHashTable(const PropertyMapEntry& entry)
     ++m_propertyTable->keyCount;
 }
 
-void StructureID::createPropertyMapHashTable()
+void Structure::createPropertyMapHashTable()
 {
     ASSERT(sizeForKeyCount(7) == newTableSize);
     createPropertyMapHashTable(newTableSize);
 }
 
-void StructureID::createPropertyMapHashTable(unsigned newTableSize)
+void Structure::createPropertyMapHashTable(unsigned newTableSize)
 {
     ASSERT(!m_propertyTable);
     ASSERT(isPowerOf2(newTableSize));
@@ -864,20 +864,20 @@ void StructureID::createPropertyMapHashTable(unsigned newTableSize)
     checkConsistency();
 }
 
-void StructureID::expandPropertyMapHashTable()
+void Structure::expandPropertyMapHashTable()
 {
     ASSERT(m_propertyTable);
     rehashPropertyMapHashTable(m_propertyTable->size * 2);
 }
 
-void StructureID::rehashPropertyMapHashTable()
+void Structure::rehashPropertyMapHashTable()
 {
     ASSERT(m_propertyTable);
     ASSERT(m_propertyTable->size);
     rehashPropertyMapHashTable(m_propertyTable->size);
 }
 
-void StructureID::rehashPropertyMapHashTable(unsigned newTableSize)
+void Structure::rehashPropertyMapHashTable(unsigned newTableSize)
 {
     ASSERT(m_propertyTable);
     ASSERT(isPowerOf2(newTableSize));
@@ -916,7 +916,7 @@ static int comparePropertyMapEntryIndices(const void* a, const void* b)
     return 0;
 }
 
-void StructureID::getEnumerablePropertyNamesInternal(PropertyNameArray& propertyNames)
+void Structure::getEnumerablePropertyNamesInternal(PropertyNameArray& propertyNames)
 {
     materializePropertyMapIfNecessary();
     if (!m_propertyTable)
@@ -975,7 +975,7 @@ void StructureID::getEnumerablePropertyNamesInternal(PropertyNameArray& property
 
 #if DO_PROPERTYMAP_CONSTENCY_CHECK
 
-void StructureID::checkConsistency()
+void Structure::checkConsistency()
 {
     if (!m_propertyTable)
         return;
similarity index 78%
rename from JavaScriptCore/runtime/StructureID.h
rename to JavaScriptCore/runtime/Structure.h
index 79c03a6..343fde4 100644 (file)
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
  */
 
-#ifndef StructureID_h
-#define StructureID_h
+#ifndef Structure_h
+#define Structure_h
 
 #include "Identifier.h"
 #include "JSType.h"
 #include "JSValue.h"
 #include "PropertyMapHashTable.h"
-#include "StructureIDChain.h"
-#include "StructureIDTransitionTable.h"
+#include "StructureChain.h"
+#include "StructureTransitionTable.h"
 #include "TypeInfo.h"
 #include "UString.h"
 #include <wtf/HashFunctions.h>
@@ -51,12 +51,12 @@ namespace JSC {
     class PropertyNameArray;
     class PropertyNameArrayData;
 
-    class StructureID : public RefCounted<StructureID> {
+    class Structure : public RefCounted<Structure> {
     public:
         friend class CTI;
-        static PassRefPtr<StructureID> create(JSValue* prototype, const TypeInfo& typeInfo)
+        static PassRefPtr<Structure> create(JSValue* prototype, const TypeInfo& typeInfo)
         {
-            return adoptRef(new StructureID(prototype, typeInfo));
+            return adoptRef(new Structure(prototype, typeInfo));
         }
 
         static void startIgnoringLeaks();
@@ -64,15 +64,15 @@ namespace JSC {<