Remove excessive headers from JavaScriptCore
[WebKit-https.git] / Source / JavaScriptCore / runtime / JSLexicalEnvironment.h
index 9fb03c5..f3b3d4a 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2008, 2009, 2013, 2014 Apple Inc. All rights reserved.
+ * Copyright (C) 2008, 2009, 2013-2015 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
  
-#ifndef JSLexicalEnvironment_h
-#define JSLexicalEnvironment_h
+#pragma once
 
 #include "CodeBlock.h"
-#include "CopiedSpaceInlines.h"
 #include "JSEnvironmentRecord.h"
-#include "Nodes.h"
 #include "SymbolTable.h"
 
 namespace JSC {
 
-class Register;
-    
 class JSLexicalEnvironment : public JSEnvironmentRecord {
-private:
-    JSLexicalEnvironment(VM&, CallFrame*, Register*, JSScope*, CodeBlock*);
+protected:
+    JSLexicalEnvironment(VM&, Structure*, JSScope*, SymbolTable*);
     
 public:
     typedef JSEnvironmentRecord Base;
+    static const unsigned StructureFlags = Base::StructureFlags | OverridesGetOwnPropertySlot | OverridesGetPropertyNames | OverridesToThis;
 
-    static JSLexicalEnvironment* create(VM& vm, CallFrame* callFrame, Register* registers, JSScope* currentScope, CodeBlock* codeBlock)
+    static JSLexicalEnvironment* create(
+        VM& vm, Structure* structure, JSScope* currentScope, SymbolTable* symbolTable, JSValue initialValue)
     {
-        SymbolTable* symbolTable = codeBlock->symbolTable();
-        ASSERT(codeBlock->codeType() == FunctionCode);
-        JSLexicalEnvironment* lexicalEnvironment = new (
-            NotNull,
-            allocateCell<JSLexicalEnvironment>(
-                vm.heap,
-                allocationSize(symbolTable)
-            )
-        ) JSLexicalEnvironment(vm, callFrame, registers, currentScope, codeBlock);
-        lexicalEnvironment->finishCreation(vm);
-        return lexicalEnvironment;
+        JSLexicalEnvironment* result = 
+            new (
+                NotNull,
+                allocateCell<JSLexicalEnvironment>(vm.heap, allocationSize(symbolTable)))
+            JSLexicalEnvironment(vm, structure, currentScope, symbolTable);
+        result->finishCreation(vm, initialValue);
+        return result;
     }
-        
-    static JSLexicalEnvironment* create(VM& vm, CallFrame* callFrame, JSScope* currentScope, CodeBlock* codeBlock)
+
+    static JSLexicalEnvironment* create(VM& vm, JSGlobalObject* globalObject, JSScope* currentScope, SymbolTable* symbolTable, JSValue initialValue)
     {
-        return create(vm, callFrame, callFrame->registers() + codeBlock->framePointerOffsetToGetActivationRegisters(), currentScope, codeBlock);
+        Structure* structure = globalObject->activationStructure();
+        return create(vm, structure, currentScope, symbolTable, initialValue);
     }
-
-    static void visitChildren(JSCell*, SlotVisitor&);
-
+        
     static bool getOwnPropertySlot(JSObject*, ExecState*, PropertyName, PropertySlot&);
     static void getOwnNonIndexPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
 
-    static void put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&);
+    static bool put(JSCell*, ExecState*, PropertyName, JSValue, PutPropertySlot&);
 
     static bool deleteProperty(JSCell*, ExecState*, PropertyName);
 
@@ -79,108 +71,18 @@ public:
 
     DECLARE_INFO;
 
-    static Structure* createStructure(VM& vm, JSGlobalObject* globalObject) { return Structure::create(vm, globalObject, jsNull(), TypeInfo(ActivationObjectType, StructureFlags), info()); }
-
-    WriteBarrierBase<Unknown>& registerAt(int) const;
-    bool isValidIndex(int) const;
-    bool isValid(const SymbolTableEntry&) const;
-    int registersOffset();
-    static int registersOffset(SymbolTable*);
-
-protected:
-    static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesGetPropertyNames | Base::StructureFlags;
-
-private:
-    bool symbolTableGet(PropertyName, PropertySlot&);
-    bool symbolTableGet(PropertyName, PropertyDescriptor&);
-    bool symbolTableGet(PropertyName, PropertySlot&, bool& slotIsWriteable);
-    bool symbolTablePut(ExecState*, PropertyName, JSValue, bool shouldThrow);
-    bool symbolTablePutWithAttributes(VM&, PropertyName, JSValue, unsigned attributes);
-
-    static EncodedJSValue argumentsGetter(ExecState*, JSObject*, EncodedJSValue, PropertyName);
-
-    static size_t allocationSize(SymbolTable*);
-    static size_t storageOffset();
-
-    WriteBarrier<Unknown>* storage(); // captureCount() number of registers.
+    static Structure* createStructure(VM& vm, JSGlobalObject* globalObject) { return Structure::create(vm, globalObject, jsNull(), TypeInfo(LexicalEnvironmentType, StructureFlags), info()); }
 };
 
-extern int activationCount;
-extern int allTheThingsCount;
-
-inline JSLexicalEnvironment::JSLexicalEnvironment(VM& vm, CallFrame* callFrame, Register* registers, JSScope* currentScope, CodeBlock* codeBlock)
-    : Base(
-        vm,
-        callFrame->lexicalGlobalObject()->activationStructure(),
-        registers,
-        currentScope,
-        codeBlock->symbolTable())
+inline JSLexicalEnvironment::JSLexicalEnvironment(VM& vm, Structure* structure, JSScope* currentScope, SymbolTable* symbolTable)
+    : Base(vm, structure, currentScope, symbolTable)
 {
-    SymbolTable* symbolTable = codeBlock->symbolTable();
-    WriteBarrier<Unknown>* storage = this->storage();
-    size_t captureCount = symbolTable->captureCount();
-    for (size_t i = 0; i < captureCount; ++i)
-        new (NotNull, &storage[i]) WriteBarrier<Unknown>(UndefinedWriteBarrierTag);
-    m_registers = reinterpret_cast_ptr<WriteBarrierBase<Unknown>*>(
-        reinterpret_cast<char*>(this) + registersOffset(symbolTable));
 }
 
-JSLexicalEnvironment* asActivation(JSValue);
-
 inline JSLexicalEnvironment* asActivation(JSValue value)
 {
-    ASSERT(asObject(value)->inherits(JSLexicalEnvironment::info()));
+    ASSERT(asObject(value)->inherits(*value.getObject()->vm(), JSLexicalEnvironment::info()));
     return jsCast<JSLexicalEnvironment*>(asObject(value));
 }
     
-ALWAYS_INLINE JSLexicalEnvironment* Register::lexicalEnvironment() const
-{
-    return asActivation(jsValue());
-}
-
-inline int JSLexicalEnvironment::registersOffset(SymbolTable* symbolTable)
-{
-    return storageOffset() + ((symbolTable->captureCount() - symbolTable->captureStart()  - 1) * sizeof(WriteBarrier<Unknown>));
-}
-
-inline size_t JSLexicalEnvironment::storageOffset()
-{
-    return WTF::roundUpToMultipleOf<sizeof(WriteBarrier<Unknown>)>(sizeof(JSLexicalEnvironment));
-}
-
-inline WriteBarrier<Unknown>* JSLexicalEnvironment::storage()
-{
-    return reinterpret_cast_ptr<WriteBarrier<Unknown>*>(
-        reinterpret_cast<char*>(this) + storageOffset());
-}
-
-inline size_t JSLexicalEnvironment::allocationSize(SymbolTable* symbolTable)
-{
-    size_t objectSizeInBytes = WTF::roundUpToMultipleOf<sizeof(WriteBarrier<Unknown>)>(sizeof(JSLexicalEnvironment));
-    size_t storageSizeInBytes = symbolTable->captureCount() * sizeof(WriteBarrier<Unknown>);
-    return objectSizeInBytes + storageSizeInBytes;
-}
-
-inline bool JSLexicalEnvironment::isValidIndex(int index) const
-{
-    if (index > symbolTable()->captureStart())
-        return false;
-    if (index <= symbolTable()->captureEnd())
-        return false;
-    return true;
-}
-
-inline bool JSLexicalEnvironment::isValid(const SymbolTableEntry& entry) const
-{
-    return isValidIndex(entry.getIndex());
-}
-
-inline WriteBarrierBase<Unknown>& JSLexicalEnvironment::registerAt(int index) const
-{
-    ASSERT(isValidIndex(index));
-    return Base::registerAt(index);
-}
-
 } // namespace JSC
-
-#endif // JSLexicalEnvironment_h