JavaScriptCore-1218.33.tar.gz

[apple/javascriptcore.git] / runtime / JSWrapperObject.h

diff --git a/runtime/JSWrapperObject.h b/runtime/JSWrapperObject.h
index f19cd30c85049409a338cce27f617e899ede340b..f1b6d3286049ffd47a1cac108d917f9589b44463 100644 (file)
--- a/runtime/JSWrapperObject.h
+++ b/runtime/JSWrapperObject.h
@@ -22,46 +22,65 @@
 #ifndef JSWrapperObject_h
 #define JSWrapperObject_h
 
 #ifndef JSWrapperObject_h
 #define JSWrapperObject_h
 

-#include "JSObject.h"
+#include "JSDestructibleObject.h"

 
 namespace JSC {
 
     // This class is used as a base for classes such as String,
     // Number, Boolean and Date which are wrappers for primitive types.
 
 namespace JSC {
 
     // This class is used as a base for classes such as String,
     // Number, Boolean and Date which are wrappers for primitive types.

-    class JSWrapperObject : public JSObject {
-    protected:
-        explicit JSWrapperObject(NonNullPassRefPtr<Structure>);
-
+    class JSWrapperObject : public JSDestructibleObject {

     public:
     public:

-        JSValue internalValue() const { return m_internalValue; }
-        void setInternalValue(JSValue);
+        typedef JSDestructibleObject Base;
+
+        static size_t allocationSize(size_t inlineCapacity)
+        {
+            ASSERT_UNUSED(inlineCapacity, !inlineCapacity);
+            return sizeof(JSWrapperObject);
+        }
+
+        JSValue internalValue() const;
+        void setInternalValue(VM&, JSValue);

 
 

-        static PassRefPtr<Structure> createStructure(JSValue prototype) 
+        static Structure* createStructure(VM& vm, JSGlobalObject* globalObject, JSValue prototype) 

         { 
         { 

-            return Structure::create(prototype, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount);
+            return Structure::create(vm, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), &s_info);
+        }
+        
+        static ptrdiff_t internalValueOffset() { return OBJECT_OFFSETOF(JSWrapperObject, m_internalValue); }
+        static ptrdiff_t internalValueCellOffset()
+        {
+#if USE(JSVALUE64)
+            return internalValueOffset();
+#else
+            return internalValueOffset() + OBJECT_OFFSETOF(EncodedValueDescriptor, asBits.payload);
+#endif

         }
 
     protected:
         }
 
     protected:

-        static const unsigned AnonymousSlotCount = 1 + JSObject::AnonymousSlotCount;
+        explicit JSWrapperObject(VM&, Structure*);
+        static const unsigned StructureFlags = OverridesVisitChildren | Base::StructureFlags;
+
+        static void visitChildren(JSCell*, SlotVisitor&);

 
     private:
 
     private:

-        virtual void markChildren(MarkStack&);
-        
-        JSValue m_internalValue;
+        WriteBarrier<Unknown> m_internalValue;

     };
 
     };
 

-    inline JSWrapperObject::JSWrapperObject(NonNullPassRefPtr<Structure> structure)
-        : JSObject(structure)
+    inline JSWrapperObject::JSWrapperObject(VM& vm, Structure* structure)
+        : JSDestructibleObject(vm, structure)
+    {
+    }
+
+    inline JSValue JSWrapperObject::internalValue() const

     {
     {

-        putAnonymousValue(0, jsNull());
+        return m_internalValue.get();

     }
 
     }
 

-    inline void JSWrapperObject::setInternalValue(JSValue value)
+    inline void JSWrapperObject::setInternalValue(VM& vm, JSValue value)

     {
         ASSERT(value);
         ASSERT(!value.isObject());
     {
         ASSERT(value);
         ASSERT(!value.isObject());

-        m_internalValue = value;
-        putAnonymousValue(0, value);
+        m_internalValue.set(vm, this, value);

     }
 
 } // namespace JSC
     }
 
 } // namespace JSC