JavaScriptCore: Mark all exported symbols in the header file automatically.
authormorrita@google.com <morrita@google.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 13 Jan 2012 07:23:44 +0000 (07:23 +0000)
committermorrita@google.com <morrita@google.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Fri, 13 Jan 2012 07:23:44 +0000 (07:23 +0000)
https://bugs.webkit.org/show_bug.cgi?id=72855

Reviewed by Darin Adler.

Added WTF_EXPORT_PRIVATE and JS_EXPORT_PRIVATE based on JavaScriptCore.exp files.
The change is generated by a tool calledListExportables (https://github.com/omo/ListExportables)

* API/OpaqueJSString.h:
* bytecode/CodeBlock.h:
* bytecode/SamplingTool.h:
* debugger/Debugger.h:
* debugger/DebuggerActivation.h:
* debugger/DebuggerCallFrame.h:
* heap/AllocationSpace.h:
* heap/HandleHeap.h:
* heap/Heap.h:
* heap/MachineStackMarker.h:
* heap/MarkStack.h:
* heap/VTableSpectrum.h:
* heap/WriteBarrierSupport.h:
* parser/Nodes.h:
* parser/ParserArena.h:
* profiler/Profile.h:
* runtime/ArgList.h:
* runtime/CallData.h:
* runtime/Completion.h:
* runtime/ConstructData.h:
* runtime/DateInstance.h:
* runtime/Error.h:
* runtime/ExceptionHelpers.h:
* runtime/FunctionConstructor.h:
* runtime/Identifier.h:
* runtime/InitializeThreading.h:
* runtime/InternalFunction.h:
* runtime/JSArray.h:
* runtime/JSByteArray.h:
* runtime/JSCell.h:
* runtime/JSFunction.h:
* runtime/JSGlobalData.cpp:
* runtime/JSGlobalData.h:
* runtime/JSGlobalObject.h:
* runtime/JSGlobalThis.h:
* runtime/JSLock.h:
* runtime/JSObject.h:
* runtime/JSString.h:
* runtime/JSValue.h:
* runtime/JSVariableObject.h:
* runtime/Lookup.h:
* runtime/MemoryStatistics.h:
* runtime/ObjectPrototype.h:
* runtime/Options.h:
* runtime/PropertyDescriptor.h:
* runtime/PropertyNameArray.h:
* runtime/PropertySlot.h:
* runtime/RegExp.h:
* runtime/RegExpObject.h:
* runtime/SamplingCounter.h:
* runtime/SmallStrings.h:
* runtime/StringObject.h:
* runtime/Structure.h:
* runtime/TimeoutChecker.h:
* runtime/UString.h:
* runtime/WriteBarrier.h:
* wtf/ArrayBufferView.h:
* wtf/ByteArray.h:
* wtf/CryptographicallyRandomNumber.h:
* wtf/CurrentTime.h:
* wtf/DateMath.h:
* wtf/DecimalNumber.h:
* wtf/FastMalloc.cpp:
* wtf/FastMalloc.h:
* wtf/MD5.h:
* wtf/MainThread.h:
* wtf/MetaAllocator.h:
* wtf/MetaAllocatorHandle.h:
* wtf/OSAllocator.h:
* wtf/PageBlock.h:
* wtf/RandomNumber.h:
* wtf/RefCountedLeakCounter.h:
* wtf/SHA1.h:
* wtf/Threading.cpp:
* wtf/Threading.h:
* wtf/ThreadingPrimitives.h:
* wtf/WTFThreadData.h:
* wtf/dtoa.h:
* wtf/text/AtomicString.h:
* wtf/text/CString.h:
* wtf/text/StringBuilder.h:
* wtf/text/StringImpl.h:
* wtf/text/WTFString.h:
* wtf/unicode/Collator.h:
* wtf/unicode/UTF8.h:
* yarr/Yarr.h:
* yarr/YarrPattern.h:

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

88 files changed:
Source/JavaScriptCore/API/OpaqueJSString.h
Source/JavaScriptCore/ChangeLog
Source/JavaScriptCore/bytecode/CodeBlock.h
Source/JavaScriptCore/bytecode/SamplingTool.h
Source/JavaScriptCore/debugger/Debugger.h
Source/JavaScriptCore/debugger/DebuggerActivation.h
Source/JavaScriptCore/debugger/DebuggerCallFrame.h
Source/JavaScriptCore/heap/AllocationSpace.h
Source/JavaScriptCore/heap/HandleHeap.h
Source/JavaScriptCore/heap/Heap.h
Source/JavaScriptCore/heap/MachineStackMarker.h
Source/JavaScriptCore/heap/MarkStack.h
Source/JavaScriptCore/heap/VTableSpectrum.h
Source/JavaScriptCore/heap/WriteBarrierSupport.h
Source/JavaScriptCore/parser/Nodes.h
Source/JavaScriptCore/parser/ParserArena.h
Source/JavaScriptCore/profiler/Profile.h
Source/JavaScriptCore/runtime/ArgList.h
Source/JavaScriptCore/runtime/CallData.h
Source/JavaScriptCore/runtime/Completion.h
Source/JavaScriptCore/runtime/ConstructData.h
Source/JavaScriptCore/runtime/DateInstance.h
Source/JavaScriptCore/runtime/Error.h
Source/JavaScriptCore/runtime/ExceptionHelpers.h
Source/JavaScriptCore/runtime/FunctionConstructor.h
Source/JavaScriptCore/runtime/Identifier.h
Source/JavaScriptCore/runtime/InitializeThreading.h
Source/JavaScriptCore/runtime/InternalFunction.h
Source/JavaScriptCore/runtime/JSArray.h
Source/JavaScriptCore/runtime/JSByteArray.h
Source/JavaScriptCore/runtime/JSCell.h
Source/JavaScriptCore/runtime/JSFunction.h
Source/JavaScriptCore/runtime/JSGlobalData.cpp
Source/JavaScriptCore/runtime/JSGlobalData.h
Source/JavaScriptCore/runtime/JSGlobalObject.h
Source/JavaScriptCore/runtime/JSGlobalThis.h
Source/JavaScriptCore/runtime/JSLock.h
Source/JavaScriptCore/runtime/JSObject.h
Source/JavaScriptCore/runtime/JSString.h
Source/JavaScriptCore/runtime/JSValue.h
Source/JavaScriptCore/runtime/JSVariableObject.h
Source/JavaScriptCore/runtime/Lookup.h
Source/JavaScriptCore/runtime/MemoryStatistics.h
Source/JavaScriptCore/runtime/ObjectPrototype.h
Source/JavaScriptCore/runtime/Options.h
Source/JavaScriptCore/runtime/PropertyDescriptor.h
Source/JavaScriptCore/runtime/PropertyNameArray.h
Source/JavaScriptCore/runtime/PropertySlot.h
Source/JavaScriptCore/runtime/RegExp.h
Source/JavaScriptCore/runtime/RegExpObject.h
Source/JavaScriptCore/runtime/SamplingCounter.h
Source/JavaScriptCore/runtime/SmallStrings.h
Source/JavaScriptCore/runtime/StringObject.h
Source/JavaScriptCore/runtime/Structure.h
Source/JavaScriptCore/runtime/TimeoutChecker.h
Source/JavaScriptCore/runtime/UString.h
Source/JavaScriptCore/runtime/WriteBarrier.h
Source/JavaScriptCore/wtf/ArrayBufferView.h
Source/JavaScriptCore/wtf/ByteArray.h
Source/JavaScriptCore/wtf/CryptographicallyRandomNumber.h
Source/JavaScriptCore/wtf/CurrentTime.h
Source/JavaScriptCore/wtf/DateMath.h
Source/JavaScriptCore/wtf/DecimalNumber.h
Source/JavaScriptCore/wtf/FastMalloc.cpp
Source/JavaScriptCore/wtf/FastMalloc.h
Source/JavaScriptCore/wtf/MD5.h
Source/JavaScriptCore/wtf/MainThread.h
Source/JavaScriptCore/wtf/MetaAllocator.h
Source/JavaScriptCore/wtf/MetaAllocatorHandle.h
Source/JavaScriptCore/wtf/OSAllocator.h
Source/JavaScriptCore/wtf/PageBlock.h
Source/JavaScriptCore/wtf/RandomNumber.h
Source/JavaScriptCore/wtf/RefCountedLeakCounter.h
Source/JavaScriptCore/wtf/SHA1.h
Source/JavaScriptCore/wtf/Threading.cpp
Source/JavaScriptCore/wtf/Threading.h
Source/JavaScriptCore/wtf/ThreadingPrimitives.h
Source/JavaScriptCore/wtf/WTFThreadData.h
Source/JavaScriptCore/wtf/dtoa.h
Source/JavaScriptCore/wtf/text/AtomicString.h
Source/JavaScriptCore/wtf/text/CString.h
Source/JavaScriptCore/wtf/text/StringBuilder.h
Source/JavaScriptCore/wtf/text/StringImpl.h
Source/JavaScriptCore/wtf/text/WTFString.h
Source/JavaScriptCore/wtf/unicode/Collator.h
Source/JavaScriptCore/wtf/unicode/UTF8.h
Source/JavaScriptCore/yarr/Yarr.h
Source/JavaScriptCore/yarr/YarrPattern.h

index 5c24f75..1c63150 100644 (file)
@@ -46,7 +46,7 @@ struct OpaqueJSString : public ThreadSafeRefCounted<OpaqueJSString> {
         return adoptRef(new OpaqueJSString(characters, length));
     }
 
-    static PassRefPtr<OpaqueJSString> create(const JSC::UString&);
+    JS_EXPORT_PRIVATE static PassRefPtr<OpaqueJSString> create(const JSC::UString&);
 
     UChar* characters() { return this ? m_characters : 0; }
     unsigned length() { return this ? m_length : 0; }
index 3a15987..66d6090 100644 (file)
@@ -1,3 +1,101 @@
+2012-01-12  Hajime Morrita  <morrita@chromium.org>
+
+        JavaScriptCore: Mark all exported symbols in the header file automatically.
+        https://bugs.webkit.org/show_bug.cgi?id=72855
+
+        Reviewed by Darin Adler.
+
+        Added WTF_EXPORT_PRIVATE and JS_EXPORT_PRIVATE based on JavaScriptCore.exp files.
+        The change is generated by a tool calledListExportables (https://github.com/omo/ListExportables)
+
+        * API/OpaqueJSString.h:
+        * bytecode/CodeBlock.h:
+        * bytecode/SamplingTool.h:
+        * debugger/Debugger.h:
+        * debugger/DebuggerActivation.h:
+        * debugger/DebuggerCallFrame.h:
+        * heap/AllocationSpace.h:
+        * heap/HandleHeap.h:
+        * heap/Heap.h:
+        * heap/MachineStackMarker.h:
+        * heap/MarkStack.h:
+        * heap/VTableSpectrum.h:
+        * heap/WriteBarrierSupport.h:
+        * parser/Nodes.h:
+        * parser/ParserArena.h:
+        * profiler/Profile.h:
+        * runtime/ArgList.h:
+        * runtime/CallData.h:
+        * runtime/Completion.h:
+        * runtime/ConstructData.h:
+        * runtime/DateInstance.h:
+        * runtime/Error.h:
+        * runtime/ExceptionHelpers.h:
+        * runtime/FunctionConstructor.h:
+        * runtime/Identifier.h:
+        * runtime/InitializeThreading.h:
+        * runtime/InternalFunction.h:
+        * runtime/JSArray.h:
+        * runtime/JSByteArray.h:
+        * runtime/JSCell.h:
+        * runtime/JSFunction.h:
+        * runtime/JSGlobalData.cpp:
+        * runtime/JSGlobalData.h:
+        * runtime/JSGlobalObject.h:
+        * runtime/JSGlobalThis.h:
+        * runtime/JSLock.h:
+        * runtime/JSObject.h:
+        * runtime/JSString.h:
+        * runtime/JSValue.h:
+        * runtime/JSVariableObject.h:
+        * runtime/Lookup.h:
+        * runtime/MemoryStatistics.h:
+        * runtime/ObjectPrototype.h:
+        * runtime/Options.h:
+        * runtime/PropertyDescriptor.h:
+        * runtime/PropertyNameArray.h:
+        * runtime/PropertySlot.h:
+        * runtime/RegExp.h:
+        * runtime/RegExpObject.h:
+        * runtime/SamplingCounter.h:
+        * runtime/SmallStrings.h:
+        * runtime/StringObject.h:
+        * runtime/Structure.h:
+        * runtime/TimeoutChecker.h:
+        * runtime/UString.h:
+        * runtime/WriteBarrier.h:
+        * wtf/ArrayBufferView.h:
+        * wtf/ByteArray.h:
+        * wtf/CryptographicallyRandomNumber.h:
+        * wtf/CurrentTime.h:
+        * wtf/DateMath.h:
+        * wtf/DecimalNumber.h:
+        * wtf/FastMalloc.cpp:
+        * wtf/FastMalloc.h:
+        * wtf/MD5.h:
+        * wtf/MainThread.h:
+        * wtf/MetaAllocator.h:
+        * wtf/MetaAllocatorHandle.h:
+        * wtf/OSAllocator.h:
+        * wtf/PageBlock.h:
+        * wtf/RandomNumber.h:
+        * wtf/RefCountedLeakCounter.h:
+        * wtf/SHA1.h:
+        * wtf/Threading.cpp:
+        * wtf/Threading.h:
+        * wtf/ThreadingPrimitives.h:
+        * wtf/WTFThreadData.h:
+        * wtf/dtoa.h:
+        * wtf/text/AtomicString.h:
+        * wtf/text/CString.h:
+        * wtf/text/StringBuilder.h:
+        * wtf/text/StringImpl.h:
+        * wtf/text/WTFString.h:
+        * wtf/unicode/Collator.h:
+        * wtf/unicode/UTF8.h:
+        * yarr/Yarr.h:
+        * yarr/YarrPattern.h:
+
 2012-01-12  MORITA Hajime  <morrita@google.com>
 
         [Chromium] JSExportMacros.h should be visible.
index de03f88..ceb7be6 100644 (file)
@@ -94,7 +94,7 @@ namespace JSC {
         Heap* m_heap;
 
     public:
-        virtual ~CodeBlock();
+        JS_EXPORT_PRIVATE virtual ~CodeBlock();
         
         int numParameters() const { return m_numParameters; }
         void setNumParameters(int newValue);
index b69ef02..32a44ad 100644 (file)
@@ -45,8 +45,8 @@ namespace JSC {
 
     class SamplingFlags {
     public:
-        static void start();
-        static void stop();
+        JS_EXPORT_PRIVATE static void start();
+        JS_EXPORT_PRIVATE static void stop();
 
 #if ENABLE(SAMPLING_FLAGS)
         static void setFlag(unsigned flag)
@@ -89,7 +89,7 @@ namespace JSC {
 
 #endif
     private:
-        static uint32_t s_flags;
+        JS_EXPORTDATA static uint32_t s_flags;
 #if ENABLE(SAMPLING_FLAGS)
         static uint64_t s_flagCounts[33];
 #endif
@@ -174,7 +174,7 @@ namespace JSC {
     class SamplingRegion {
     public:
         SamplingRegion(const char*) { }
-        void dump();
+        JS_EXPORT_PRIVATE void dump();
     };
 #endif // ENABLE(SAMPLING_REGIONS)
 
@@ -220,8 +220,8 @@ namespace JSC {
         static unsigned s_hertz;
         static ThreadIdentifier s_samplingThread;
 
-        static void start(unsigned hertz=10000);
-        static void stop();
+        JS_EXPORT_PRIVATE static void start(unsigned hertz=10000);
+        JS_EXPORT_PRIVATE static void stop();
 
         static void* threadStartFunc(void*);
     };
@@ -294,7 +294,7 @@ namespace JSC {
             memset(m_opcodeSamplesInCTIFunctions, 0, sizeof(m_opcodeSamplesInCTIFunctions));
         }
 
-        void setup();
+        JS_EXPORT_PRIVATE void setup();
         void dump(ExecState*);
 
         void notifyOfScope(JSGlobalData&, ScriptExecutable* scope);
index f48243c..a237329 100644 (file)
@@ -58,7 +58,7 @@ namespace JSC {
     };
 
     // This function exists only for backwards compatibility with existing WebScriptDebugger clients.
-    JSValue evaluateInGlobalCallFrame(const UString&, JSValue& exception, JSGlobalObject*);
+    JS_EXPORT_PRIVATE JSValue evaluateInGlobalCallFrame(const UString&, JSValue& exception, JSGlobalObject*);
 
 } // namespace JSC
 
index 3f1c4f8..8dba70b 100644 (file)
@@ -52,7 +52,7 @@ namespace JSC {
         static void defineGetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* getterFunction, unsigned attributes);
         static void defineSetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* setterFunction, unsigned attributes);
 
-        static const ClassInfo s_info;
+        JS_EXPORTDATA static const ClassInfo s_info;
 
         static Structure* createStructure(JSGlobalData& globalData, JSGlobalObject* globalObject, JSValue prototype) 
         {
@@ -62,10 +62,10 @@ namespace JSC {
     protected:
         static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesVisitChildren | JSObject::StructureFlags;
 
-        void finishCreation(JSGlobalData&, JSObject* activation);
+        JS_EXPORT_PRIVATE void finishCreation(JSGlobalData&, JSObject* activation);
 
     private:
-        DebuggerActivation(JSGlobalData&);
+        JS_EXPORT_PRIVATE DebuggerActivation(JSGlobalData&);
         WriteBarrier<JSActivation> m_activation;
     };
 
index d8fb9da..8605af5 100644 (file)
@@ -50,7 +50,7 @@ namespace JSC {
 
         JSGlobalObject* dynamicGlobalObject() const { return m_callFrame->dynamicGlobalObject(); }
         ScopeChainNode* scopeChain() const { return m_callFrame->scopeChain(); }
-        const UString* functionName() const;
+        JS_EXPORT_PRIVATE const UString* functionName() const;
         JS_EXPORT_PRIVATE UString calculatedFunctionName() const;
         JS_EXPORT_PRIVATE Type type() const;
         JS_EXPORT_PRIVATE JSObject* thisObject() const;
index 550cb9a..01c339b 100644 (file)
@@ -72,7 +72,7 @@ private:
     
     void* allocate(MarkedSpace::SizeClass&);
     void* tryAllocate(MarkedSpace::SizeClass&);
-    void* allocateSlowCase(MarkedSpace::SizeClass&);
+    JS_EXPORT_PRIVATE void* allocateSlowCase(MarkedSpace::SizeClass&);
     MarkedBlock* allocateBlock(size_t cellSize, AllocationEffort);
     
     Heap* m_heap;
index c577791..3b9db37 100644 (file)
@@ -40,7 +40,7 @@ class JSGlobalData;
 class JSValue;
 class SlotVisitor;
 
-class WeakHandleOwner {
+class JS_EXPORT_PRIVATE WeakHandleOwner {
 public:
     virtual ~WeakHandleOwner();
     virtual bool isReachableFromOpaqueRoots(Handle<Unknown>, void* context, SlotVisitor&);
@@ -65,7 +65,7 @@ public:
     void visitWeakHandles(HeapRootVisitor&);
     void finalizeWeakHandles();
 
-    void writeBarrier(HandleSlot, const JSValue&);
+    JS_EXPORT_PRIVATE void writeBarrier(HandleSlot, const JSValue&);
 
 #if !ASSERT_DISABLED
     bool hasWeakOwner(HandleSlot, WeakHandleOwner*);
@@ -111,7 +111,7 @@ private:
     static HandleSlot toHandle(Node*);
     static Node* toNode(HandleSlot);
 
-    void grow();
+    JS_EXPORT_PRIVATE void grow();
     
 #if ENABLE(GC_VALIDATION) || !ASSERT_DISABLED
     bool isValidWeakNode(Node*);
index 1b22825..3c78d62 100644 (file)
@@ -78,14 +78,14 @@ namespace JSC {
 
         Heap(JSGlobalData*, HeapSize);
         ~Heap();
-        void destroy(); // JSGlobalData must call destroy() before ~Heap().
+        JS_EXPORT_PRIVATE void destroy(); // JSGlobalData must call destroy() before ~Heap().
 
         JSGlobalData* globalData() const { return m_globalData; }
         AllocationSpace& objectSpace() { return m_objectSpace; }
         MachineThreads& machineThreads() { return m_machineThreads; }
 
-        GCActivityCallback* activityCallback();
-        void setActivityCallback(PassOwnPtr<GCActivityCallback>);
+        JS_EXPORT_PRIVATE GCActivityCallback* activityCallback();
+        JS_EXPORT_PRIVATE void setActivityCallback(PassOwnPtr<GCActivityCallback>);
 
         // true if an allocation or collection is in progress
         inline bool isBusy();
@@ -94,26 +94,26 @@ namespace JSC {
         void* allocate(size_t);
 
         typedef void (*Finalizer)(JSCell*);
-        void addFinalizer(JSCell*, Finalizer);
+        JS_EXPORT_PRIVATE void addFinalizer(JSCell*, Finalizer);
 
         void notifyIsSafeToCollect() { m_isSafeToCollect = true; }
-        void collectAllGarbage();
+        JS_EXPORT_PRIVATE void collectAllGarbage();
 
         void reportExtraMemoryCost(size_t cost);
 
-        void protect(JSValue);
-        bool unprotect(JSValue); // True when the protect count drops to 0.
+        JS_EXPORT_PRIVATE void protect(JSValue);
+        JS_EXPORT_PRIVATE bool unprotect(JSValue); // True when the protect count drops to 0.
         
         void jettisonDFGCodeBlock(PassOwnPtr<CodeBlock>);
 
-        size_t size();
-        size_t capacity();
-        size_t objectCount();
-        size_t globalObjectCount();
-        size_t protectedObjectCount();
-        size_t protectedGlobalObjectCount();
-        PassOwnPtr<TypeCountSet> protectedObjectTypeCounts();
-        PassOwnPtr<TypeCountSet> objectTypeCounts();
+        JS_EXPORT_PRIVATE size_t size();
+        JS_EXPORT_PRIVATE size_t capacity();
+        JS_EXPORT_PRIVATE size_t objectCount();
+        JS_EXPORT_PRIVATE size_t globalObjectCount();
+        JS_EXPORT_PRIVATE size_t protectedObjectCount();
+        JS_EXPORT_PRIVATE size_t protectedGlobalObjectCount();
+        JS_EXPORT_PRIVATE PassOwnPtr<TypeCountSet> protectedObjectTypeCounts();
+        JS_EXPORT_PRIVATE PassOwnPtr<TypeCountSet> objectTypeCounts();
 
         void pushTempSortVector(Vector<ValueStringPair>*);
         void popTempSortVector(Vector<ValueStringPair>*);
@@ -141,8 +141,8 @@ namespace JSC {
             virtual void finalize(Handle<Unknown>, void* context);
         };
 
-        bool isValidAllocation(size_t);
-        void reportExtraMemoryCostSlowCase(size_t);
+        JS_EXPORT_PRIVATE bool isValidAllocation(size_t);
+        JS_EXPORT_PRIVATE void reportExtraMemoryCostSlowCase(size_t);
 
         // Call this function before any operation that needs to know which cells
         // in the heap are live. (For example, call this function before
index 69c4537..0f5a4c3 100644 (file)
@@ -40,7 +40,7 @@ namespace JSC {
         void gatherConservativeRoots(ConservativeRoots&, void* stackCurrent);
 
         void makeUsableFromMultipleThreads();
-        void addCurrentThread(); // Only needs to be called by clients that can use the same heap from multiple threads.
+        JS_EXPORT_PRIVATE void addCurrentThread(); // Only needs to be called by clients that can use the same heap from multiple threads.
 
     private:
         void gatherFromCurrentThread(ConservativeRoots&, void* stackCurrent);
index 1478011..9562090 100644 (file)
@@ -111,7 +111,7 @@ namespace JSC {
     private:
         MarkStackSegment* m_topSegment;
         
-        void expand();
+        JS_EXPORT_PRIVATE void expand();
         
         MarkStackSegmentAllocator& m_allocator;
 
@@ -241,7 +241,7 @@ namespace JSC {
         }
 
     protected:
-        static void validate(JSCell*);
+        JS_EXPORT_PRIVATE static void validate(JSCell*);
 
         void append(JSValue*);
         void append(JSValue*, size_t count);
@@ -250,7 +250,7 @@ namespace JSC {
         void internalAppend(JSCell*);
         void internalAppend(JSValue);
         
-        void mergeOpaqueRoots();
+        JS_EXPORT_PRIVATE void mergeOpaqueRoots();
         
         void mergeOpaqueRootsIfNecessary()
         {
index 8a9737e..a50a04f 100644 (file)
@@ -39,7 +39,7 @@ public:
     ~VTableSpectrum();
     
     void countVPtr(void*);
-    void count(JSCell*);
+    JS_EXPORT_PRIVATE void count(JSCell*);
     
     void dump(FILE* output, const char* comment);
 };
index 00b9bb9..5d7d2f6 100644 (file)
@@ -81,8 +81,8 @@ public:
     }
 #else
     // These are necessary to work around not having conditional exports.
-    static char usesWithBarrierFromCpp;
-    static char usesWithoutBarrierFromCpp;
+    JS_EXPORTDATA static char usesWithBarrierFromCpp;
+    JS_EXPORTDATA static char usesWithoutBarrierFromCpp;
 #endif // ENABLE(WRITE_BARRIER_PROFILING)
 
     static void countWriteBarrier()
index 23f2cde..5098dc7 100644 (file)
@@ -181,7 +181,7 @@ namespace JSC {
         StatementNode(int);
 
     public:
-        void setLoc(int firstLine, int lastLine);
+        JS_EXPORT_PRIVATE void setLoc(int firstLine, int lastLine);
         int firstLine() const { return lineNo(); }
         int lastLine() const { return m_lastLine; }
 
index 35674b6..49f0ab6 100644 (file)
@@ -159,7 +159,7 @@ namespace JSC {
         void removeLast();
 
         bool isEmpty() const;
-        void reset();
+        JS_EXPORT_PRIVATE void reset();
 
         IdentifierArena& identifierArena() { return *m_identifierArena; }
 
index 6bf29f7..9455e35 100644 (file)
@@ -44,11 +44,11 @@ namespace JSC {
         double totalTime() const { return m_head->totalTime(); }
         unsigned int uid() const { return m_uid; }
 
-        void forEach(void (ProfileNode::*)());
+        JS_EXPORT_PRIVATE void forEach(void (ProfileNode::*)());
 
-        void focus(const ProfileNode*);
-        void exclude(const ProfileNode*);
-        void restoreAll();
+        JS_EXPORT_PRIVATE void focus(const ProfileNode*);
+        JS_EXPORT_PRIVATE void exclude(const ProfileNode*);
+        JS_EXPORT_PRIVATE void restoreAll();
 
 #ifndef NDEBUG
         void debugPrintData() const;
index ac5a4f2..1512a0f 100644 (file)
@@ -102,7 +102,7 @@ namespace JSC {
         static void markLists(HeapRootVisitor&, ListSet&);
 
     private:
-        void slowAppend(JSValue);
+        JS_EXPORT_PRIVATE void slowAppend(JSValue);
         
         EncodedJSValue& slotFor(int item) const
         {
@@ -171,7 +171,7 @@ namespace JSC {
         bool isEmpty() const { return !m_argCount; }
         size_t size() const { return m_argCount; }
         
-        void getSlice(int startIndex, ArgList& result) const;
+        JS_EXPORT_PRIVATE void getSlice(int startIndex, ArgList& result) const;
 
     private:
         JSValue* m_args;
index b138f54..15a6a0a 100644 (file)
@@ -57,7 +57,7 @@ namespace JSC {
         } js;
     };
 
-    JSValue call(ExecState*, JSValue functionObject, CallType, const CallData&, JSValue thisValue, const ArgList&);
+    JS_EXPORT_PRIVATE JSValue call(ExecState*, JSValue functionObject, CallType, const CallData&, JSValue thisValue, const ArgList&);
 
 } // namespace JSC
 
index c3dbdfc..3d3b86f 100644 (file)
@@ -31,8 +31,8 @@ namespace JSC {
     class ScopeChainNode;
     class SourceCode;
 
-    bool checkSyntax(ExecState*, const SourceCode&, JSValue* exception = 0);
-    JSValue evaluate(ExecState*, ScopeChainNode*, const SourceCode&, JSValue thisValue = JSValue(), JSValue* exception = 0);
+    JS_EXPORT_PRIVATE bool checkSyntax(ExecState*, const SourceCode&, JSValue* exception = 0);
+    JS_EXPORT_PRIVATE JSValue evaluate(ExecState*, ScopeChainNode*, const SourceCode&, JSValue thisValue = JSValue(), JSValue* exception = 0);
 
 } // namespace JSC
 
index cc8f469..d7a3c73 100644 (file)
@@ -56,7 +56,7 @@ namespace JSC {
         } js;
     };
 
-    JSObject* construct(ExecState*, JSValue constructor, ConstructType, const ConstructData&, const ArgList&);
+    JS_EXPORT_PRIVATE JSObject* construct(ExecState*, JSValue constructor, ConstructType, const ConstructData&, const ArgList&);
 
 } // namespace JSC
 
index 3edfb09..7c976a5 100644 (file)
@@ -31,9 +31,9 @@ namespace JSC {
 
     class DateInstance : public JSWrapperObject {
     protected:
-        DateInstance(ExecState*, Structure*);
+        JS_EXPORT_PRIVATE DateInstance(ExecState*, Structure*);
         void finishCreation(JSGlobalData&);
-        void finishCreation(JSGlobalData&, double);
+        JS_EXPORT_PRIVATE void finishCreation(JSGlobalData&, double);
 
         static void destroy(JSCell*);
  
index b807d4a..88b540a 100644 (file)
@@ -46,12 +46,12 @@ namespace JSC {
     JSObject* createTypeError(JSGlobalObject*, const UString&);
     JSObject* createURIError(JSGlobalObject*, const UString&);
     // ExecState wrappers.
-    JSObject* createError(ExecState*, const UString&);
+    JS_EXPORT_PRIVATE JSObject* createError(ExecState*, const UString&);
     JSObject* createEvalError(ExecState*, const UString&);
-    JSObject* createRangeError(ExecState*, const UString&);
-    JSObject* createReferenceError(ExecState*, const UString&);
-    JSObject* createSyntaxError(ExecState*, const UString&);
-    JSObject* createTypeError(ExecState*, const UString&);
+    JS_EXPORT_PRIVATE JSObject* createRangeError(ExecState*, const UString&);
+    JS_EXPORT_PRIVATE JSObject* createReferenceError(ExecState*, const UString&);
+    JS_EXPORT_PRIVATE JSObject* createSyntaxError(ExecState*, const UString&);
+    JS_EXPORT_PRIVATE JSObject* createTypeError(ExecState*, const UString&);
     JSObject* createURIError(ExecState*, const UString&);
 
     // Methods to add 
@@ -61,12 +61,12 @@ namespace JSC {
     JSObject* addErrorInfo(ExecState*, JSObject* error, int line, const SourceCode&);
 
     // Methods to throw Errors.
-    JSValue throwError(ExecState*, JSValue);
-    JSObject* throwError(ExecState*, JSObject*);
+    JS_EXPORT_PRIVATE JSValue throwError(ExecState*, JSValue);
+    JS_EXPORT_PRIVATE JSObject* throwError(ExecState*, JSObject*);
 
     // Convenience wrappers, create an throw an exception with a default message.
-    JSObject* throwTypeError(ExecState*);
-    JSObject* throwSyntaxError(ExecState*);
+    JS_EXPORT_PRIVATE JSObject* throwTypeError(ExecState*);
+    JS_EXPORT_PRIVATE JSObject* throwSyntaxError(ExecState*);
 
     // Convenience wrappers, wrap result as an EncodedJSValue.
     inline EncodedJSValue throwVMError(ExecState* exec, JSValue error) { return JSValue::encode(throwError(exec, error)); }
index f71d1a3..388235b 100644 (file)
 
 namespace JSC {
 
-JSObject* createInterruptedExecutionException(JSGlobalData*);
+JS_EXPORT_PRIVATE JSObject* createInterruptedExecutionException(JSGlobalData*);
 bool isInterruptedExecutionException(JSObject*);
 bool isInterruptedExecutionException(JSValue);
 
 JSObject* createTerminatedExecutionException(JSGlobalData*);
 bool isTerminatedExecutionException(JSObject*);
-bool isTerminatedExecutionException(JSValue);
+JS_EXPORT_PRIVATE bool isTerminatedExecutionException(JSValue);
 
-JSObject* createStackOverflowError(ExecState*);
+JS_EXPORT_PRIVATE JSObject* createStackOverflowError(ExecState*);
 JSObject* createStackOverflowError(JSGlobalObject*);
 JSObject* createOutOfMemoryError(JSGlobalObject*);
 JSObject* createUndefinedVariableError(ExecState*, const Identifier&);
index 7141916..31986b7 100644 (file)
@@ -59,7 +59,7 @@ namespace JSC {
     JSObject* constructFunction(ExecState*, JSGlobalObject*, const ArgList&, const Identifier& functionName, const UString& sourceURL, const WTF::TextPosition&);
     JSObject* constructFunction(ExecState*, JSGlobalObject*, const ArgList&);
 
-    JSObject* constructFunctionSkippingEvalEnabledCheck(ExecState*, JSGlobalObject*, const ArgList&, const Identifier&, const UString&, const WTF::TextPosition&);
+    JS_EXPORT_PRIVATE JSObject* constructFunctionSkippingEvalEnabledCheck(ExecState*, JSGlobalObject*, const ArgList&, const Identifier&, const UString&, const WTF::TextPosition&);
 
 } // namespace JSC
 
index 2cc88b2..947c95b 100644 (file)
@@ -56,14 +56,14 @@ namespace JSC {
 
         static Identifier createLCharFromUChar(JSGlobalData* globalData, const UChar* s, int length) { return Identifier(globalData, add8(globalData, s, length)); }
 
-        static Identifier from(ExecState* exec, unsigned y);
-        static Identifier from(ExecState* exec, int y);
+        JS_EXPORT_PRIVATE static Identifier from(ExecState* exec, unsigned y);
+        JS_EXPORT_PRIVATE static Identifier from(ExecState* exec, int y);
         static Identifier from(ExecState* exec, double y);
         static Identifier from(JSGlobalData*, unsigned y);
         static Identifier from(JSGlobalData*, int y);
         static Identifier from(JSGlobalData*, double y);
 
-        static uint32_t toUInt32(const UString&, bool& ok);
+        JS_EXPORT_PRIVATE static uint32_t toUInt32(const UString&, bool& ok);
         uint32_t toUInt32(bool& ok) const { return toUInt32(m_string, ok); }
         unsigned toArrayIndex(bool& ok) const;
 
@@ -84,7 +84,7 @@ namespace JSC {
         static bool equal(const StringImpl*, const UChar*, unsigned length);
         static bool equal(const StringImpl* a, const StringImpl* b) { return ::equal(a, b); }
 
-        static PassRefPtr<StringImpl> add(ExecState*, const char*); // Only to be used with string literals.
+        JS_EXPORT_PRIVATE static PassRefPtr<StringImpl> add(ExecState*, const char*); // Only to be used with string literals.
         static PassRefPtr<StringImpl> add(JSGlobalData*, const char*); // Only to be used with string literals.
 
     private:
@@ -119,11 +119,11 @@ namespace JSC {
             return addSlowCase(globalData, r);
         }
 
-        static PassRefPtr<StringImpl> addSlowCase(ExecState*, StringImpl* r);
-        static PassRefPtr<StringImpl> addSlowCase(JSGlobalData*, StringImpl* r);
+        JS_EXPORT_PRIVATE static PassRefPtr<StringImpl> addSlowCase(ExecState*, StringImpl* r);
+        JS_EXPORT_PRIVATE static PassRefPtr<StringImpl> addSlowCase(JSGlobalData*, StringImpl* r);
 
-        static void checkCurrentIdentifierTable(ExecState*);
-        static void checkCurrentIdentifierTable(JSGlobalData*);
+        JS_EXPORT_PRIVATE static void checkCurrentIdentifierTable(ExecState*);
+        JS_EXPORT_PRIVATE static void checkCurrentIdentifierTable(JSGlobalData*);
     };
 
     template <> ALWAYS_INLINE bool Identifier::canUseSingleCharacterString(LChar)
index 1a93ccb..91301a0 100644 (file)
@@ -33,7 +33,7 @@ namespace JSC {
 
     // This function must be called from the main thread. It is safe to call it repeatedly.
     // Darwin is an exception to this rule: it is OK to call this function from any thread, even reentrantly.
-    void initializeThreading();
+    JS_EXPORT_PRIVATE void initializeThreading();
 
 }
 
index a038b7a..532bd0c 100644 (file)
@@ -37,7 +37,7 @@ namespace JSC {
 
         static JS_EXPORTDATA const ClassInfo s_info;
 
-        const UString& name(ExecState*);
+        JS_EXPORT_PRIVATE const UString& name(ExecState*);
         const UString displayName(ExecState*);
         const UString calculatedDisplayName(ExecState*);
 
@@ -49,9 +49,9 @@ namespace JSC {
     protected:
         static const unsigned StructureFlags = ImplementsHasInstance | JSObject::StructureFlags;
 
-        InternalFunction(JSGlobalObject*, Structure*);
+        JS_EXPORT_PRIVATE InternalFunction(JSGlobalObject*, Structure*);
 
-        void finishCreation(JSGlobalData&, const Identifier& name);
+        JS_EXPORT_PRIVATE void finishCreation(JSGlobalData&, const Identifier& name);
 
         static CallType getCallData(JSCell*, CallData&);
     };
index 871cfc8..284c977 100644 (file)
@@ -127,16 +127,16 @@ namespace JSC {
         friend class Walker;
 
     protected:
-        explicit JSArray(JSGlobalData&, Structure*);
+        JS_EXPORT_PRIVATE explicit JSArray(JSGlobalData&, Structure*);
 
-        void finishCreation(JSGlobalData&, unsigned initialLength = 0);
-        JSArray* tryFinishCreationUninitialized(JSGlobalData&, unsigned initialLength);
+        JS_EXPORT_PRIVATE void finishCreation(JSGlobalData&, unsigned initialLength = 0);
+        JS_EXPORT_PRIVATE JSArray* tryFinishCreationUninitialized(JSGlobalData&, unsigned initialLength);
     
     public:
         typedef JSNonFinalObject Base;
 
-        ~JSArray();
-        static void destroy(JSCell*);
+        JS_EXPORT_PRIVATE ~JSArray();
+        JS_EXPORT_PRIVATE static void destroy(JSCell*);
 
         static JSArray* create(JSGlobalData& globalData, Structure* structure, unsigned initialLength = 0)
         {
@@ -156,10 +156,10 @@ namespace JSC {
             return array->tryFinishCreationUninitialized(globalData, initialLength);
         }
 
-        static bool defineOwnProperty(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&, bool throwException);
+        JS_EXPORT_PRIVATE static bool defineOwnProperty(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&, bool throwException);
 
         static bool getOwnPropertySlot(JSCell*, ExecState*, const Identifier&, PropertySlot&);
-        static bool getOwnPropertySlotByIndex(JSCell*, ExecState*, unsigned propertyName, PropertySlot&);
+        JS_EXPORT_PRIVATE static bool getOwnPropertySlotByIndex(JSCell*, ExecState*, unsigned propertyName, PropertySlot&);
         static bool getOwnPropertyDescriptor(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&);
         static void putByIndex(JSCell*, ExecState*, unsigned propertyName, JSValue);
 
@@ -254,7 +254,7 @@ namespace JSC {
             return OBJECT_OFFSETOF(JSArray, m_vectorLength);
         }
 
-        static void visitChildren(JSCell*, SlotVisitor&);
+        JS_EXPORT_PRIVATE static void visitChildren(JSCell*, SlotVisitor&);
 
     protected:
         static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesVisitChildren | OverridesGetPropertyNames | JSObject::StructureFlags;
@@ -264,8 +264,8 @@ namespace JSC {
         static bool deletePropertyByIndex(JSCell*, ExecState*, unsigned propertyName);
         static void getOwnPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
 
-        void* subclassData() const;
-        void setSubclassData(void*);
+        JS_EXPORT_PRIVATE void* subclassData() const;
+        JS_EXPORT_PRIVATE void setSubclassData(void*);
 
     private:
         bool isLengthWritable()
index 754774d..d1f4ad6 100644 (file)
@@ -76,7 +76,7 @@ namespace JSC {
         }
 
     private:
-        JSByteArray(ExecState*, Structure*, ByteArray* storage);
+        JS_EXPORT_PRIVATE JSByteArray(ExecState*, Structure*, ByteArray* storage);
         
     public:
         static JSByteArray* create(ExecState* exec, Structure* structure, ByteArray* storage)
@@ -86,15 +86,15 @@ namespace JSC {
             return array;
         }
 
-        static Structure* createStructure(JSGlobalData&, JSGlobalObject*, JSValue prototype, const JSC::ClassInfo* = &s_info);
+        JS_EXPORT_PRIVATE static Structure* createStructure(JSGlobalData&, JSGlobalObject*, JSValue prototype, const JSC::ClassInfo* = &s_info);
 
-        static bool getOwnPropertySlot(JSC::JSCell*, JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertySlot&);
-        static bool getOwnPropertySlotByIndex(JSC::JSCell*, JSC::ExecState*, unsigned propertyName, JSC::PropertySlot&);
-        static bool getOwnPropertyDescriptor(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&);
-        static void put(JSC::JSCell*, JSC::ExecState*, const JSC::Identifier& propertyName, JSC::JSValue, JSC::PutPropertySlot&);
-        static void putByIndex(JSC::JSCell*, JSC::ExecState*, unsigned propertyName, JSC::JSValue);
+        JS_EXPORT_PRIVATE static bool getOwnPropertySlot(JSC::JSCell*, JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertySlot&);
+        JS_EXPORT_PRIVATE static bool getOwnPropertySlotByIndex(JSC::JSCell*, JSC::ExecState*, unsigned propertyName, JSC::PropertySlot&);
+        JS_EXPORT_PRIVATE static bool getOwnPropertyDescriptor(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&);
+        JS_EXPORT_PRIVATE static void put(JSC::JSCell*, JSC::ExecState*, const JSC::Identifier& propertyName, JSC::JSValue, JSC::PutPropertySlot&);
+        JS_EXPORT_PRIVATE static void putByIndex(JSC::JSCell*, JSC::ExecState*, unsigned propertyName, JSC::JSValue);
 
-        static void getOwnPropertyNames(JSC::JSObject*, JSC::ExecState*, JSC::PropertyNameArray&, EnumerationMode);
+        JS_EXPORT_PRIVATE static void getOwnPropertyNames(JSC::JSObject*, JSC::ExecState*, JSC::PropertyNameArray&, EnumerationMode);
 
         static JS_EXPORTDATA const ClassInfo s_info;
         
@@ -103,7 +103,7 @@ namespace JSC {
         WTF::ByteArray* storage() const { return m_storage.get(); }
 
         ~JSByteArray();
-        static void destroy(JSCell*);
+        JS_EXPORT_PRIVATE static void destroy(JSCell*);
 
         static size_t offsetOfStorage() { return OBJECT_OFFSETOF(JSByteArray, m_storage); }
 
index f47d06e..3bee78e 100644 (file)
@@ -67,7 +67,7 @@ namespace JSC {
 
     protected:
         JSCell(JSGlobalData&, Structure*);
-        static void destroy(JSCell*);
+        JS_EXPORT_PRIVATE static void destroy(JSCell*);
 
     public:
         // Querying the type.
@@ -82,21 +82,21 @@ namespace JSC {
         void clearStructure() { m_structure.clear(); }
 
         // Extracting the value.
-        bool getString(ExecState* exec, UString&) const;
-        UString getString(ExecState* exec) const; // null string if not a string
-        JSObject* getObject(); // NULL if not an object
+        JS_EXPORT_PRIVATE bool getString(ExecState* exec, UString&) const;
+        JS_EXPORT_PRIVATE UString getString(ExecState* exec) const; // null string if not a string
+        JS_EXPORT_PRIVATE JSObject* getObject(); // NULL if not an object
         const JSObject* getObject() const; // NULL if not an object
         
-        static CallType getCallData(JSCell*, CallData&);
-        static ConstructType getConstructData(JSCell*, ConstructData&);
+        JS_EXPORT_PRIVATE static CallType getCallData(JSCell*, CallData&);
+        JS_EXPORT_PRIVATE static ConstructType getConstructData(JSCell*, ConstructData&);
 
         // Basic conversions.
-        JSValue toPrimitive(ExecState*, PreferredPrimitiveType) const;
+        JS_EXPORT_PRIVATE JSValue toPrimitive(ExecState*, PreferredPrimitiveType) const;
         bool getPrimitiveNumber(ExecState*, double& number, JSValue&) const;
         bool toBoolean(ExecState*) const;
-        double toNumber(ExecState*) const;
-        UString toString(ExecState*) const;
-        JSObject* toObject(ExecState*, JSGlobalObject*) const;
+        JS_EXPORT_PRIVATE double toNumber(ExecState*) const;
+        JS_EXPORT_PRIVATE UString toString(ExecState*) const;
+        JS_EXPORT_PRIVATE JSObject* toObject(ExecState*, JSGlobalObject*) const;
 
         static void visitChildren(JSCell*, SlotVisitor&);
 
index 5118f8b..b8cfd71 100644 (file)
@@ -40,7 +40,7 @@ namespace JSC {
     class JITCompiler;
     }
 
-    EncodedJSValue JSC_HOST_CALL callHostFunctionAsConstructor(ExecState*);
+    JS_EXPORT_PRIVATE EncodedJSValue JSC_HOST_CALL callHostFunctionAsConstructor(ExecState*);
 
     class JSFunction : public JSNonFinalObject {
         friend class JIT;
@@ -51,7 +51,7 @@ namespace JSC {
     public:
         typedef JSNonFinalObject Base;
 
-        static JSFunction* create(ExecState*, JSGlobalObject*, int length, const Identifier& name, NativeFunction nativeFunction, NativeFunction nativeConstructor = callHostFunctionAsConstructor);
+        JS_EXPORT_PRIVATE static JSFunction* create(ExecState*, JSGlobalObject*, int length, const Identifier& name, NativeFunction nativeFunction, NativeFunction nativeConstructor = callHostFunctionAsConstructor);
         static JSFunction* create(ExecState*, JSGlobalObject*, int length, const Identifier& name, NativeExecutable* nativeExecutable);
 
         static JSFunction* create(ExecState* exec, FunctionExecutable* executable, ScopeChainNode* scopeChain)
@@ -64,7 +64,7 @@ namespace JSC {
         
         static void destroy(JSCell*);
 
-        const UString& name(ExecState*);
+        JS_EXPORT_PRIVATE const UString& name(ExecState*);
         const UString displayName(ExecState*);
         const UString calculatedDisplayName(ExecState*);
 
@@ -94,7 +94,7 @@ namespace JSC {
         inline bool isHostFunction() const;
         FunctionExecutable* jsExecutable() const;
 
-        const SourceCode* sourceCode() const;
+        JS_EXPORT_PRIVATE const SourceCode* sourceCode() const;
 
         static JS_EXPORTDATA const ClassInfo s_info;
 
@@ -123,7 +123,7 @@ namespace JSC {
     protected:
         const static unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | OverridesVisitChildren | OverridesGetPropertyNames | JSObject::StructureFlags;
 
-        JSFunction(ExecState*, JSGlobalObject*, Structure*);
+        JS_EXPORT_PRIVATE JSFunction(ExecState*, JSGlobalObject*, Structure*);
         JSFunction(ExecState*, FunctionExecutable*, ScopeChainNode*);
         
         void finishCreation(ExecState*, NativeExecutable*, int length, const Identifier& name);
@@ -140,7 +140,7 @@ namespace JSC {
         static void visitChildren(JSCell*, SlotVisitor&);
 
     private:
-        bool isHostFunctionNonInline() const;
+        JS_EXPORT_PRIVATE bool isHostFunctionNonInline() const;
 
         static JSValue argumentsGetter(ExecState*, JSValue, const Identifier&);
         static JSValue callerGetter(ExecState*, JSValue, const Identifier&);
index dab3f24..508c51e 100644 (file)
@@ -101,7 +101,7 @@ extern const HashTable globalObjectTable;
 extern const HashTable mathTable;
 extern const HashTable numberConstructorTable;
 extern const HashTable numberPrototypeTable;
-extern const HashTable objectConstructorTable;
+JS_EXPORTDATA extern const HashTable objectConstructorTable;
 extern const HashTable objectPrototypeTable;
 extern const HashTable regExpTable;
 extern const HashTable regExpConstructorTable;
index a6ad8a7..f3b5415 100644 (file)
@@ -134,18 +134,18 @@ namespace JSC {
         enum GlobalDataType { Default, APIContextGroup, APIShared };
         
         struct ClientData {
-            virtual ~ClientData() = 0;
+            JS_EXPORT_PRIVATE virtual ~ClientData() = 0;
         };
 
         bool isSharedInstance() { return globalDataType == APIShared; }
         bool usingAPI() { return globalDataType != Default; }
         static bool sharedInstanceExists();
-        static JSGlobalData& sharedInstance();
+        JS_EXPORT_PRIVATE static JSGlobalData& sharedInstance();
 
-        static PassRefPtr<JSGlobalData> create(ThreadStackType, HeapSize = SmallHeap);
-        static PassRefPtr<JSGlobalData> createLeaked(ThreadStackType, HeapSize = SmallHeap);
+        JS_EXPORT_PRIVATE static PassRefPtr<JSGlobalData> create(ThreadStackType, HeapSize = SmallHeap);
+        JS_EXPORT_PRIVATE static PassRefPtr<JSGlobalData> createLeaked(ThreadStackType, HeapSize = SmallHeap);
         static PassRefPtr<JSGlobalData> createContextGroup(ThreadStackType, HeapSize = SmallHeap);
-        ~JSGlobalData();
+        JS_EXPORT_PRIVATE ~JSGlobalData();
 
         void makeUsableFromMultipleThreads() { heap.machineThreads().makeUsableFromMultipleThreads(); }
 
@@ -308,21 +308,21 @@ namespace JSC {
 
         CachedTranscendentalFunction<sin> cachedSin;
 
-        void resetDateCache();
+        JS_EXPORT_PRIVATE void resetDateCache();
 
-        void startSampling();
-        void stopSampling();
-        void dumpSampleData(ExecState* exec);
+        JS_EXPORT_PRIVATE void startSampling();
+        JS_EXPORT_PRIVATE void stopSampling();
+        JS_EXPORT_PRIVATE void dumpSampleData(ExecState* exec);
         void recompileAllJSFunctions();
         RegExpCache* regExpCache() { return m_regExpCache; }
 #if ENABLE(REGEXP_TRACING)
         void addRegExpToTrace(PassRefPtr<RegExp> regExp);
 #endif
-        void dumpRegExpTrace();
-        void clearBuiltinStructures();
+        JS_EXPORT_PRIVATE void dumpRegExpTrace();
+        JS_EXPORT_PRIVATE void clearBuiltinStructures();
 
         bool isCollectorBusy() { return heap.isBusy(); }
-        void releaseExecutableMemory();
+        JS_EXPORT_PRIVATE void releaseExecutableMemory();
 
 #if ENABLE(GC_VALIDATION)
         bool isInitializingObject() const; 
index d1c5a72..7036830 100644 (file)
@@ -192,20 +192,20 @@ namespace JSC {
         }
 
     public:
-        ~JSGlobalObject();
-        static void destroy(JSCell*);
+        JS_EXPORT_PRIVATE ~JSGlobalObject();
+        JS_EXPORT_PRIVATE static void destroy(JSCell*);
 
-        static void visitChildren(JSCell*, SlotVisitor&);
+        JS_EXPORT_PRIVATE static void visitChildren(JSCell*, SlotVisitor&);
 
-        static bool getOwnPropertySlot(JSCell*, ExecState*, const Identifier&, PropertySlot&);
-        static bool getOwnPropertyDescriptor(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&);
+        JS_EXPORT_PRIVATE static bool getOwnPropertySlot(JSCell*, ExecState*, const Identifier&, PropertySlot&);
+        JS_EXPORT_PRIVATE static bool getOwnPropertyDescriptor(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&);
         bool hasOwnPropertyForWrite(ExecState*, const Identifier&);
-        static void put(JSCell*, ExecState*, const Identifier&, JSValue, PutPropertySlot&);
+        JS_EXPORT_PRIVATE static void put(JSCell*, ExecState*, const Identifier&, JSValue, PutPropertySlot&);
 
-        static void putDirectVirtual(JSObject*, ExecState*, const Identifier& propertyName, JSValue, unsigned attributes);
+        JS_EXPORT_PRIVATE static void putDirectVirtual(JSObject*, ExecState*, const Identifier& propertyName, JSValue, unsigned attributes);
 
-        static void defineGetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* getterFunc, unsigned attributes);
-        static void defineSetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* setterFunc, unsigned attributes);
+        JS_EXPORT_PRIVATE static void defineGetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* getterFunc, unsigned attributes);
+        JS_EXPORT_PRIVATE static void defineSetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* setterFunc, unsigned attributes);
 
         // We use this in the code generator as we perform symbol table
         // lookups prior to initializing the properties
@@ -283,7 +283,7 @@ namespace JSC {
 
         ScopeChainNode* globalScopeChain() { return m_globalScopeChain.get(); }
 
-        ExecState* globalExec();
+        JS_EXPORT_PRIVATE ExecState* globalExec();
 
         static bool shouldInterruptScript(const JSGlobalObject*) { return true; }
 
@@ -332,17 +332,17 @@ namespace JSC {
             JSValue value;
             unsigned attributes;
         };
-        void addStaticGlobals(GlobalPropertyInfo*, int count);
+        JS_EXPORT_PRIVATE void addStaticGlobals(GlobalPropertyInfo*, int count);
 
     private:
         // FIXME: Fold reset into init.
-        void init(JSObject* thisValue);
+        JS_EXPORT_PRIVATE void init(JSObject* thisValue);
         void reset(JSValue prototype);
 
         void createThrowTypeError(ExecState*);
 
         void setRegisters(WriteBarrier<Unknown>* registers, PassOwnArrayPtr<WriteBarrier<Unknown> > registerArray, size_t count);
-        static void clearRareData(JSCell*);
+        JS_EXPORT_PRIVATE static void clearRareData(JSCell*);
     };
 
     JSGlobalObject* asGlobalObject(JSValue);
@@ -488,7 +488,7 @@ namespace JSC {
     class DynamicGlobalObjectScope {
         WTF_MAKE_NONCOPYABLE(DynamicGlobalObjectScope);
     public:
-        DynamicGlobalObjectScope(JSGlobalData&, JSGlobalObject*);
+        JS_EXPORT_PRIVATE DynamicGlobalObjectScope(JSGlobalData&, JSGlobalObject*);
 
         ~DynamicGlobalObjectScope()
         {
index fa5de04..fa5c2eb 100644 (file)
@@ -63,7 +63,7 @@ protected:
 
     static const unsigned StructureFlags = OverridesVisitChildren | Base::StructureFlags;
 
-    static void visitChildren(JSCell*, SlotVisitor&);
+    JS_EXPORT_PRIVATE static void visitChildren(JSCell*, SlotVisitor&);
 
     WriteBarrier<JSGlobalObject> m_unwrappedObject;
 };
index 7b07b4f..a0eb969 100644 (file)
@@ -56,7 +56,7 @@ namespace JSC {
     class JSLock {
         WTF_MAKE_NONCOPYABLE(JSLock);
     public:
-        JSLock(ExecState*);
+        JS_EXPORT_PRIVATE JSLock(ExecState*);
         JSLock(JSGlobalData*);
 
         JSLock(JSLockBehavior lockBehavior)
@@ -80,22 +80,22 @@ namespace JSC {
             unlock(m_lockBehavior); 
         }
         
-        static void lock(JSLockBehavior);
-        static void unlock(JSLockBehavior);
+        JS_EXPORT_PRIVATE static void lock(JSLockBehavior);
+        JS_EXPORT_PRIVATE static void unlock(JSLockBehavior);
         static void lock(ExecState*);
         static void unlock(ExecState*);
 
-        static intptr_t lockCount();
-        static bool currentThreadIsHoldingLock();
+        JS_EXPORT_PRIVATE static intptr_t lockCount();
+        JS_EXPORT_PRIVATE static bool currentThreadIsHoldingLock();
 
         JSLockBehavior m_lockBehavior;
 
         class DropAllLocks {
             WTF_MAKE_NONCOPYABLE(DropAllLocks);
         public:
-            DropAllLocks(ExecState* exec);
-            DropAllLocks(JSLockBehavior);
-            ~DropAllLocks();
+            JS_EXPORT_PRIVATE DropAllLocks(ExecState* exec);
+            JS_EXPORT_PRIVATE DropAllLocks(JSLockBehavior);
+            JS_EXPORT_PRIVATE ~DropAllLocks();
             
         private:
             intptr_t m_lockCount;
index b57cf15..6d45e82 100644 (file)
@@ -55,7 +55,7 @@ namespace JSC {
     class Structure;
     struct HashTable;
 
-    JSObject* throwTypeError(ExecState*, const UString&);
+    JS_EXPORT_PRIVATE JSObject* throwTypeError(ExecState*, const UString&);
     extern JS_EXPORTDATA const char* StrictModeReadonlyPropertyWriteError;
 
     // ECMA 262-3 8.6.1
@@ -74,7 +74,7 @@ namespace JSC {
         friend class JIT;
         friend class JSCell;
         friend class MarkedBlock;
-        friend bool setUpStaticFunctionSlot(ExecState* exec, const HashEntry* entry, JSObject* thisObj, const Identifier& propertyName, PropertySlot& slot);
+        JS_EXPORT_PRIVATE friend bool setUpStaticFunctionSlot(ExecState* exec, const HashEntry* entry, JSObject* thisObj, const Identifier& propertyName, PropertySlot& slot);
 
         enum PutMode {
             PutModePut,
@@ -84,11 +84,11 @@ namespace JSC {
     public:
         typedef JSCell Base;
 
-        static void destroy(JSCell*);
+        JS_EXPORT_PRIVATE static void destroy(JSCell*);
 
-        static void visitChildren(JSCell*, SlotVisitor&);
+        JS_EXPORT_PRIVATE static void visitChildren(JSCell*, SlotVisitor&);
 
-        static UString className(const JSObject*);
+        JS_EXPORT_PRIVATE static UString className(const JSObject*);
 
         static void finalize(JSCell*);
 
@@ -103,49 +103,49 @@ namespace JSC {
 
         bool getPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
         bool getPropertySlot(ExecState*, unsigned propertyName, PropertySlot&);
-        bool getPropertyDescriptor(ExecState*, const Identifier& propertyName, PropertyDescriptor&);
+        JS_EXPORT_PRIVATE bool getPropertyDescriptor(ExecState*, const Identifier& propertyName, PropertyDescriptor&);
 
         static bool getOwnPropertySlot(JSCell*, ExecState*, const Identifier& propertyName, PropertySlot&);
-        static bool getOwnPropertySlotByIndex(JSCell*, ExecState*, unsigned propertyName, PropertySlot&);
-        static bool getOwnPropertyDescriptor(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&);
+        JS_EXPORT_PRIVATE static bool getOwnPropertySlotByIndex(JSCell*, ExecState*, unsigned propertyName, PropertySlot&);
+        JS_EXPORT_PRIVATE static bool getOwnPropertyDescriptor(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&);
 
-        static void put(JSCell*, ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
-        static void putByIndex(JSCell*, ExecState*, unsigned propertyName, JSValue);
+        JS_EXPORT_PRIVATE static void put(JSCell*, ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
+        JS_EXPORT_PRIVATE static void putByIndex(JSCell*, ExecState*, unsigned propertyName, JSValue);
 
         // putDirect is effectively an unchecked vesion of 'defineOwnProperty':
         //  - the prototype chain is not consulted
         //  - accessors are not called.
         //  - attributes will be respected (after the call the property will exist with the given attributes)
-        static void putDirectVirtual(JSObject*, ExecState*, const Identifier& propertyName, JSValue, unsigned attributes);
+        JS_EXPORT_PRIVATE static void putDirectVirtual(JSObject*, ExecState*, const Identifier& propertyName, JSValue, unsigned attributes);
         void putDirect(JSGlobalData&, const Identifier& propertyName, JSValue, unsigned attributes = 0);
         void putDirect(JSGlobalData&, const Identifier& propertyName, JSValue, PutPropertySlot&);
         void putDirectWithoutTransition(JSGlobalData&, const Identifier& propertyName, JSValue, unsigned attributes = 0);
 
         bool propertyIsEnumerable(ExecState*, const Identifier& propertyName) const;
 
-        bool hasProperty(ExecState*, const Identifier& propertyName) const;
-        bool hasProperty(ExecState*, unsigned propertyName) const;
+        JS_EXPORT_PRIVATE bool hasProperty(ExecState*, const Identifier& propertyName) const;
+        JS_EXPORT_PRIVATE bool hasProperty(ExecState*, unsigned propertyName) const;
         bool hasOwnProperty(ExecState*, const Identifier& propertyName) const;
 
-        static bool deleteProperty(JSCell*, ExecState*, const Identifier& propertyName);
-        static bool deletePropertyByIndex(JSCell*, ExecState*, unsigned propertyName);
+        JS_EXPORT_PRIVATE static bool deleteProperty(JSCell*, ExecState*, const Identifier& propertyName);
+        JS_EXPORT_PRIVATE static bool deletePropertyByIndex(JSCell*, ExecState*, unsigned propertyName);
 
-        static JSValue defaultValue(const JSObject*, ExecState*, PreferredPrimitiveType);
+        JS_EXPORT_PRIVATE static JSValue defaultValue(const JSObject*, ExecState*, PreferredPrimitiveType);
 
-        static bool hasInstance(JSObject*, ExecState*, JSValue, JSValue prototypeProperty);
+        JS_EXPORT_PRIVATE static bool hasInstance(JSObject*, ExecState*, JSValue, JSValue prototypeProperty);
 
-        static void getOwnPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
-        static void getPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
+        JS_EXPORT_PRIVATE static void getOwnPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
+        JS_EXPORT_PRIVATE static void getPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
 
         JSValue toPrimitive(ExecState*, PreferredPrimitiveType = NoPreference) const;
-        bool toBoolean(ExecState*) const;
+        JS_EXPORT_PRIVATE bool toBoolean(ExecState*) const;
         bool getPrimitiveNumber(ExecState*, double& number, JSValue&) const;
-        double toNumber(ExecState*) const;
-        UString toString(ExecState*) const;
+        JS_EXPORT_PRIVATE double toNumber(ExecState*) const;
+        JS_EXPORT_PRIVATE UString toString(ExecState*) const;
 
         // NOTE: JSObject and its subclasses must be able to gracefully handle ExecState* = 0,
         // because this call may come from inside the compiler.
-        static JSObject* toThisObject(JSCell*, ExecState*);
+        JS_EXPORT_PRIVATE static JSObject* toThisObject(JSCell*, ExecState*);
         JSObject* unwrappedObject();
 
         bool getPropertySpecificValue(ExecState* exec, const Identifier& propertyName, JSCell*& specificFunction) const;
@@ -193,14 +193,14 @@ namespace JSC {
         void putDirectOffset(JSGlobalData& globalData, size_t offset, JSValue value) { propertyStorage()[offset].set(globalData, this, value); }
         void putUndefinedAtDirectOffset(size_t offset) { propertyStorage()[offset].setUndefined(); }
 
-        void fillGetterPropertySlot(PropertySlot&, WriteBarrierBase<Unknown>* location);
+        JS_EXPORT_PRIVATE void fillGetterPropertySlot(PropertySlot&, WriteBarrierBase<Unknown>* location);
         void initializeGetterSetterProperty(ExecState*, const Identifier&, GetterSetter*, unsigned attributes);
 
-        static void defineGetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* getterFunction, unsigned attributes = 0);
-        static void defineSetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* setterFunction, unsigned attributes = 0);
-        JSValue lookupGetter(ExecState*, const Identifier& propertyName);
-        JSValue lookupSetter(ExecState*, const Identifier& propertyName);
-        static bool defineOwnProperty(JSObject*, ExecState*, const Identifier& propertyName, PropertyDescriptor&, bool shouldThrow);
+        JS_EXPORT_PRIVATE static void defineGetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* getterFunction, unsigned attributes = 0);
+        JS_EXPORT_PRIVATE static void defineSetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* setterFunction, unsigned attributes = 0);
+        JS_EXPORT_PRIVATE JSValue lookupGetter(ExecState*, const Identifier& propertyName);
+        JS_EXPORT_PRIVATE JSValue lookupSetter(ExecState*, const Identifier& propertyName);
+        JS_EXPORT_PRIVATE static bool defineOwnProperty(JSObject*, ExecState*, const Identifier& propertyName, PropertyDescriptor&, bool shouldThrow);
 
         bool isGlobalObject() const;
         bool isVariableObject() const;
@@ -210,7 +210,7 @@ namespace JSC {
 
         void seal(JSGlobalData&);
         void freeze(JSGlobalData&);
-        void preventExtensions(JSGlobalData&);
+        JS_EXPORT_PRIVATE void preventExtensions(JSGlobalData&);
         bool isSealed(JSGlobalData& globalData) { return structure()->isSealed(globalData); }
         bool isFrozen(JSGlobalData& globalData) { return structure()->isFrozen(globalData); }
         bool isExtensible() { return structure()->isExtensible(); }
@@ -218,7 +218,7 @@ namespace JSC {
         bool staticFunctionsReified() { return structure()->staticFunctionsReified(); }
         void reifyStaticFunctionsForDelete(ExecState* exec);
 
-        void allocatePropertyStorage(JSGlobalData&, size_t oldSize, size_t newSize);
+        JS_EXPORT_PRIVATE void allocatePropertyStorage(JSGlobalData&, size_t oldSize, size_t newSize);
         bool isUsingInlineStorage() const { return static_cast<const void*>(m_propertyStorage.get()) == static_cast<const void*>(this + 1); }
 
         void* addressOfPropertyStorage()
@@ -329,7 +329,7 @@ COMPILE_ASSERT((JSFinalObject_inlineStorageCapacity >= JSNonFinalObject_inlineSt
             return Structure::create(globalData, globalObject, prototype, TypeInfo(ObjectType, StructureFlags), &s_info);
         }
 
-        static void destroy(JSCell*);
+        JS_EXPORT_PRIVATE static void destroy(JSCell*);
 
     protected:
         explicit JSNonFinalObject(JSGlobalData& globalData, Structure* structure)
index 3a677af..7ca90de 100644 (file)
@@ -214,7 +214,7 @@ namespace JSC {
         unsigned length() { return m_length; }
 
         JSValue toPrimitive(ExecState*, PreferredPrimitiveType) const;
-        bool toBoolean(ExecState*) const;
+        JS_EXPORT_PRIVATE bool toBoolean(ExecState*) const;
         bool getPrimitiveNumber(ExecState*, double& number, JSValue&) const;
         JSObject* toObject(ExecState*, JSGlobalObject*) const;
         UString toString(ExecState*) const;
@@ -241,7 +241,7 @@ namespace JSC {
         static void visitChildren(JSCell*, SlotVisitor&);
 
     private:
-        void resolveRope(ExecState*) const;
+        JS_EXPORT_PRIVATE void resolveRope(ExecState*) const;
         void resolveRopeSlowCase8(LChar*) const;
         void resolveRopeSlowCase(UChar*) const;
         void outOfMemory(ExecState*) const;
index 1973812..de5e181 100644 (file)
@@ -93,7 +93,7 @@ namespace JSC {
     };
 
     // This implements ToInt32, defined in ECMA-262 9.5.
-    int32_t toInt32(double);
+    JS_EXPORT_PRIVATE int32_t toInt32(double);
 
     // This implements ToUInt32, defined in ECMA-262 9.6.
     inline uint32_t toUInt32(double number)
@@ -203,7 +203,7 @@ namespace JSC {
         JSObject* toObject(ExecState*, JSGlobalObject*) const;
 
         // Integer conversions.
-        double toInteger(ExecState*) const;
+        JS_EXPORT_PRIVATE double toInteger(ExecState*) const;
         double toIntegerPreserveNaN(ExecState*) const;
         int32_t toInt32(ExecState*) const;
         uint32_t toUInt32(ExecState*) const;
@@ -231,7 +231,7 @@ namespace JSC {
 
         bool isCell() const;
         JSCell* asCell() const;
-        bool isValidCallee();
+        JS_EXPORT_PRIVATE bool isValidCallee();
 
 #ifndef NDEBUG
         char* description();
@@ -244,11 +244,11 @@ namespace JSC {
         JSValue(HashTableDeletedValueTag);
 
         inline const JSValue asValue() const { return *this; }
-        double toNumberSlowCase(ExecState*) const;
-        JSObject* toObjectSlowCase(ExecState*, JSGlobalObject*) const;
-        JSObject* toThisObjectSlowCase(ExecState*) const;
+        JS_EXPORT_PRIVATE double toNumberSlowCase(ExecState*) const;
+        JS_EXPORT_PRIVATE JSObject* toObjectSlowCase(ExecState*, JSGlobalObject*) const;
+        JS_EXPORT_PRIVATE JSObject* toThisObjectSlowCase(ExecState*) const;
 
-        JSObject* synthesizePrototype(ExecState*) const;
+        JS_EXPORT_PRIVATE JSObject* synthesizePrototype(ExecState*) const;
         JSObject* synthesizeObject(ExecState*) const;
 
 #if USE(JSVALUE32_64)
index de878aa..c1d05ff 100644 (file)
@@ -48,12 +48,12 @@ namespace JSC {
 
         SymbolTable& symbolTable() const { return *m_symbolTable; }
 
-        static void destroy(JSCell*);
+        JS_EXPORT_PRIVATE static void destroy(JSCell*);
 
         static NO_RETURN_DUE_TO_ASSERT void putDirectVirtual(JSObject*, ExecState*, const Identifier&, JSValue, unsigned attributes);
 
-        static bool deleteProperty(JSCell*, ExecState*, const Identifier&);
-        static void getOwnPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
+        JS_EXPORT_PRIVATE static bool deleteProperty(JSCell*, ExecState*, const Identifier&);
+        JS_EXPORT_PRIVATE static void getOwnPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
         
         bool isDynamicScope(bool& requiresDynamicChecks) const;
 
@@ -88,7 +88,7 @@ namespace JSC {
         void setRegisters(WriteBarrier<Unknown>* registers, PassOwnArrayPtr<WriteBarrier<Unknown> > registerArray);
 
         bool symbolTableGet(const Identifier&, PropertySlot&);
-        bool symbolTableGet(const Identifier&, PropertyDescriptor&);
+        JS_EXPORT_PRIVATE bool symbolTableGet(const Identifier&, PropertyDescriptor&);
         bool symbolTableGet(const Identifier&, PropertySlot&, bool& slotIsWriteable);
         bool symbolTablePut(ExecState*, const Identifier&, JSValue, bool shouldThrow);
         bool symbolTablePutWithAttributes(JSGlobalData&, const Identifier&, JSValue, unsigned attributes);
index 8ed70b4..64d06b5 100644 (file)
@@ -126,7 +126,7 @@ namespace JSC {
                 createTable(&exec->globalData());
         }
 
-        void deleteTable() const;
+        JS_EXPORT_PRIVATE void deleteTable() const;
 
         // Find an entry in the table, and return the entry.
         ALWAYS_INLINE const HashEntry* entry(JSGlobalData* globalData, const Identifier& identifier) const
@@ -218,10 +218,10 @@ namespace JSC {
         }
 
         // Convert the hash table keys to identifiers.
-        void createTable(JSGlobalData*) const;
+        JS_EXPORT_PRIVATE void createTable(JSGlobalData*) const;
     };
 
-    bool setUpStaticFunctionSlot(ExecState*, const HashEntry*, JSObject* thisObject, const Identifier& propertyName, PropertySlot&);
+    JS_EXPORT_PRIVATE bool setUpStaticFunctionSlot(ExecState*, const HashEntry*, JSObject* thisObject, const Identifier& propertyName, PropertySlot&);
 
     /**
      * This method does it all (looking in the hashtable, checking for function
index d4b8b6f..9a86df2 100644 (file)
@@ -37,7 +37,7 @@ struct GlobalMemoryStatistics {
     size_t JITBytes;
 };
 
-GlobalMemoryStatistics globalMemoryStatistics();
+JS_EXPORT_PRIVATE GlobalMemoryStatistics globalMemoryStatistics();
 
 }
 
index 78b1cbd..4c49e97 100644 (file)
@@ -59,7 +59,7 @@ namespace JSC {
         bool m_hasNoPropertiesWithUInt32Names;
     };
 
-    EncodedJSValue JSC_HOST_CALL objectProtoFuncToString(ExecState*);
+    JS_EXPORT_PRIVATE EncodedJSValue JSC_HOST_CALL objectProtoFuncToString(ExecState*);
 
 } // namespace JSC
 
index f7cc5f4..feebd37 100644 (file)
@@ -73,8 +73,8 @@ extern unsigned gcMarkStackSegmentSize;
 extern unsigned minimumNumberOfCellsToKeep;
 extern unsigned maximumNumberOfSharedSegments;
 extern unsigned sharedStackWakeupThreshold;
-extern unsigned numberOfGCMarkers;
-extern unsigned opaqueRootMergeThreshold;
+JS_EXPORTDATA extern unsigned numberOfGCMarkers;
+JS_EXPORTDATA extern unsigned opaqueRootMergeThreshold;
 
 void initializeOptions();
 
index 4cf896c..98af02e 100644 (file)
@@ -41,27 +41,27 @@ namespace JSC {
             , m_seenAttributes(0)
         {
         }
-        bool writable() const;
-        bool enumerable() const;
-        bool configurable() const;
-        bool isDataDescriptor() const;
+        JS_EXPORT_PRIVATE bool writable() const;
+        JS_EXPORT_PRIVATE bool enumerable() const;
+        JS_EXPORT_PRIVATE bool configurable() const;
+        JS_EXPORT_PRIVATE bool isDataDescriptor() const;
         bool isGenericDescriptor() const;
-        bool isAccessorDescriptor() const;
+        JS_EXPORT_PRIVATE bool isAccessorDescriptor() const;
         unsigned attributes() const { return m_attributes; }
         JSValue value() const { return m_value; }
-        JSValue getter() const;
-        JSValue setter() const;
+        JS_EXPORT_PRIVATE JSValue getter() const;
+        JS_EXPORT_PRIVATE JSValue setter() const;
         JSObject* getterObject() const;
         JSObject* setterObject() const;
-        void setUndefined();
-        void setDescriptor(JSValue value, unsigned attributes);
+        JS_EXPORT_PRIVATE void setUndefined();
+        JS_EXPORT_PRIVATE void setDescriptor(JSValue value, unsigned attributes);
         void setAccessorDescriptor(GetterSetter* accessor, unsigned attributes);
-        void setWritable(bool);
-        void setEnumerable(bool);
-        void setConfigurable(bool);
+        JS_EXPORT_PRIVATE void setWritable(bool);
+        JS_EXPORT_PRIVATE void setEnumerable(bool);
+        JS_EXPORT_PRIVATE void setConfigurable(bool);
         void setValue(JSValue value) { m_value = value; }
-        void setSetter(JSValue);
-        void setGetter(JSValue);
+        JS_EXPORT_PRIVATE void setSetter(JSValue);
+        JS_EXPORT_PRIVATE void setGetter(JSValue);
         bool isEmpty() const { return !(m_value || m_getter || m_setter || m_seenAttributes); }
         bool writablePresent() const { return m_seenAttributes & WritablePresent; }
         bool enumerablePresent() const { return m_seenAttributes & EnumerablePresent; }
@@ -74,7 +74,7 @@ namespace JSC {
         unsigned attributesOverridingCurrent(const PropertyDescriptor& current) const;
 
     private:
-        static unsigned defaultAttributes;
+        JS_EXPORTDATA static unsigned defaultAttributes;
         bool operator==(const PropertyDescriptor&){ return false; }
         enum { WritablePresent = 1, EnumerablePresent = 2, ConfigurablePresent = 4};
         // May be a getter/setter
index 0da930f..dabda94 100644 (file)
@@ -69,7 +69,7 @@ namespace JSC {
         JSGlobalData* globalData() { return m_globalData; }
 
         void add(const Identifier& identifier) { add(identifier.impl()); }
-        void add(StringImpl*);
+        JS_EXPORT_PRIVATE void add(StringImpl*);
         void addKnownUnique(StringImpl* identifier) { m_data->propertyNameVector().append(Identifier(m_globalData, identifier)); }
 
         Identifier& operator[](unsigned i) { return m_data->propertyNameVector()[i]; }
index 8557e6d..cfedf78 100644 (file)
@@ -218,7 +218,7 @@ namespace JSC {
             return m_getValue;
         }
     private:
-        JSValue functionGetter(ExecState*) const;
+        JS_EXPORT_PRIVATE JSValue functionGetter(ExecState*) const;
 
         GetValueFunc m_getValue;
         GetIndexValueFunc m_getIndexValue;
index 65eb484..2c0b61a 100644 (file)
@@ -35,13 +35,13 @@ namespace JSC {
     struct RegExpRepresentation;
     class JSGlobalData;
 
-    RegExpFlags regExpFlags(const UString&);
+    JS_EXPORT_PRIVATE RegExpFlags regExpFlags(const UString&);
 
     class RegExp : public JSCell {
     public:
         typedef JSCell Base;
 
-        static RegExp* create(JSGlobalData&, const UString& pattern, RegExpFlags);
+        JS_EXPORT_PRIVATE static RegExp* create(JSGlobalData&, const UString& pattern, RegExpFlags);
         static void destroy(JSCell*);
 
         bool global() const { return m_flags & FlagGlobal; }
@@ -53,7 +53,7 @@ namespace JSC {
         bool isValid() const { return !m_constructionError && m_flags != InvalidFlags; }
         const char* errorMessage() const { return m_constructionError; }
 
-        int match(JSGlobalData&, const UString&, int startOffset, Vector<int, 32>* ovector = 0);
+        JS_EXPORT_PRIVATE int match(JSGlobalData&, const UString&, int startOffset, Vector<int, 32>* ovector = 0);
         unsigned numSubpatterns() const { return m_numSubpatterns; }
 
         bool hasCode()
index 4e84d38..081a7f1 100644 (file)
@@ -75,8 +75,8 @@ namespace JSC {
         }
 
     protected:
-        RegExpObject(JSGlobalObject*, Structure*, RegExp*);
-        void finishCreation(JSGlobalObject*);
+        JS_EXPORT_PRIVATE RegExpObject(JSGlobalObject*, Structure*, RegExp*);
+        JS_EXPORT_PRIVATE void finishCreation(JSGlobalObject*);
         static void destroy(JSCell*);
 
         static const unsigned StructureFlags = OverridesVisitChildren | OverridesGetOwnPropertySlot | Base::StructureFlags;
index 664b028..329a5cf 100644 (file)
@@ -46,7 +46,7 @@ public:
         m_counter += count;
     }
 
-    static void dump();
+    JS_EXPORT_PRIVATE static void dump();
 
     int64_t* addressOfCounter() { return &m_counter; }
 
@@ -74,7 +74,7 @@ protected:
     AbstractSamplingCounter** m_referer;
     // Null object used to detect end of static chain.
     static AbstractSamplingCounter s_abstractSamplingCounterChainEnd;
-    static AbstractSamplingCounter* s_abstractSamplingCounterChain;
+    JS_EXPORTDATA static AbstractSamplingCounter* s_abstractSamplingCounterChain;
     static bool s_completed;
 };
 
index 9c6ed9a..cd8e630 100644 (file)
@@ -60,7 +60,7 @@ namespace JSC {
             return m_singleCharacterStrings[character];
         }
 
-        StringImpl* singleCharacterStringRep(unsigned char character);
+        JS_EXPORT_PRIVATE StringImpl* singleCharacterStringRep(unsigned char character);
 
         void finalizeSmallStrings();
         void clear();
@@ -72,8 +72,8 @@ namespace JSC {
     private:
         static const unsigned singleCharacterStringCount = maxSingleCharacterString + 1;
 
-        void createEmptyString(JSGlobalData*);
-        void createSingleCharacterString(JSGlobalData*, unsigned char);
+        JS_EXPORT_PRIVATE void createEmptyString(JSGlobalData*);
+        JS_EXPORT_PRIVATE void createSingleCharacterString(JSGlobalData*, unsigned char);
 
         JSString* m_emptyString;
         JSString* m_singleCharacterStrings[singleCharacterStringCount];
index 5286686..248c716 100644 (file)
@@ -64,9 +64,9 @@ namespace JSC {
         }
 
     protected:
-        void finishCreation(JSGlobalData&, JSString*);
+        JS_EXPORT_PRIVATE void finishCreation(JSGlobalData&, JSString*);
         static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesGetPropertyNames | JSWrapperObject::StructureFlags;
-        StringObject(JSGlobalData&, Structure*);
+        JS_EXPORT_PRIVATE StringObject(JSGlobalData&, Structure*);
     };
 
     StringObject* asStringObject(JSValue);
index 2deacd5..ced2968 100644 (file)
@@ -84,11 +84,11 @@ namespace JSC {
     public:
         static void dumpStatistics();
 
-        static Structure* addPropertyTransition(JSGlobalData&, Structure*, const Identifier& propertyName, unsigned attributes, JSCell* specificValue, size_t& offset);
-        static Structure* addPropertyTransitionToExistingStructure(Structure*, const Identifier& propertyName, unsigned attributes, JSCell* specificValue, size_t& offset);
+        JS_EXPORT_PRIVATE static Structure* addPropertyTransition(JSGlobalData&, Structure*, const Identifier& propertyName, unsigned attributes, JSCell* specificValue, size_t& offset);
+        JS_EXPORT_PRIVATE static Structure* addPropertyTransitionToExistingStructure(Structure*, const Identifier& propertyName, unsigned attributes, JSCell* specificValue, size_t& offset);
         static Structure* removePropertyTransition(JSGlobalData&, Structure*, const Identifier& propertyName, size_t& offset);
-        static Structure* changePrototypeTransition(JSGlobalData&, Structure*, JSValue prototype);
-        static Structure* despecifyFunctionTransition(JSGlobalData&, Structure*, const Identifier&);
+        JS_EXPORT_PRIVATE static Structure* changePrototypeTransition(JSGlobalData&, Structure*, JSValue prototype);
+        JS_EXPORT_PRIVATE static Structure* despecifyFunctionTransition(JSGlobalData&, Structure*, const Identifier&);
         static Structure* attributeChangeTransition(JSGlobalData&, Structure*, const Identifier& propertyName, unsigned attributes);
         static Structure* toCacheableDictionaryTransition(JSGlobalData&, Structure*);
         static Structure* toUncacheableDictionaryTransition(JSGlobalData&, Structure*);
@@ -106,7 +106,7 @@ namespace JSC {
         static void destroy(JSCell*);
 
         // These should be used with caution.  
-        size_t addPropertyWithoutTransition(JSGlobalData&, const Identifier& propertyName, unsigned attributes, JSCell* specificValue);
+        JS_EXPORT_PRIVATE size_t addPropertyWithoutTransition(JSGlobalData&, const Identifier& propertyName, unsigned attributes, JSCell* specificValue);
         size_t removePropertyWithoutTransition(JSGlobalData&, const Identifier& propertyName);
         void setPrototypeWithoutTransition(JSGlobalData& globalData, JSValue prototype) { m_prototype.set(globalData, this, prototype); }
         
@@ -136,7 +136,7 @@ namespace JSC {
 
         size_t get(JSGlobalData&, const Identifier& propertyName);
         size_t get(JSGlobalData&, const UString& name);
-        size_t get(JSGlobalData&, StringImpl* propertyName, unsigned& attributes, JSCell*& specificValue);
+        JS_EXPORT_PRIVATE size_t get(JSGlobalData&, StringImpl* propertyName, unsigned& attributes, JSCell*& specificValue);
         size_t get(JSGlobalData& globalData, const Identifier& propertyName, unsigned& attributes, JSCell*& specificValue)
         {
             ASSERT(!propertyName.isNull());
@@ -151,7 +151,7 @@ namespace JSC {
         
         bool isEmpty() const { return m_propertyTable ? m_propertyTable->isEmpty() : m_offset == noOffset; }
 
-        void despecifyDictionaryFunction(JSGlobalData&, const Identifier& propertyName);
+        JS_EXPORT_PRIVATE void despecifyDictionaryFunction(JSGlobalData&, const Identifier& propertyName);
         void disableSpecificFunctionTracking() { m_specificFunctionThrashCount = maxSpecificFunctionThrashCount; }
 
         void setEnumerationCache(JSGlobalData&, JSPropertyNameIterator* enumerationCache); // Defined in JSPropertyNameIterator.h.
@@ -196,7 +196,7 @@ namespace JSC {
         static JS_EXPORTDATA const ClassInfo s_info;
 
     private:
-        Structure(JSGlobalData&, JSGlobalObject*, JSValue prototype, const TypeInfo&, const ClassInfo*);
+        JS_EXPORT_PRIVATE Structure(JSGlobalData&, JSGlobalObject*, JSValue prototype, const TypeInfo&, const ClassInfo*);
         Structure(JSGlobalData&);
         Structure(JSGlobalData&, const Structure*);
 
@@ -226,7 +226,7 @@ namespace JSC {
 
         PassOwnPtr<PropertyTable> copyPropertyTable(JSGlobalData&, Structure* owner);
         PassOwnPtr<PropertyTable> copyPropertyTableForPinning(JSGlobalData&, Structure* owner);
-        void materializePropertyMap(JSGlobalData&);
+        JS_EXPORT_PRIVATE void materializePropertyMap(JSGlobalData&);
         void materializePropertyMapIfNecessary(JSGlobalData& globalData)
         {
             ASSERT(structure()->classInfo() == &s_info);
index 5925641..89d6158 100644 (file)
@@ -57,9 +57,9 @@ namespace JSC {
             --m_startCount;
         }
 
-        void reset();
+        JS_EXPORT_PRIVATE void reset();
 
-        bool didTimeOut(ExecState*);
+        JS_EXPORT_PRIVATE bool didTimeOut(ExecState*);
 
     private:
         unsigned m_timeoutInterval;
index c05ae50..c11c567 100644 (file)
@@ -33,18 +33,18 @@ public:
     UString() { }
 
     // Construct a string with UTF-16 data.
-    UString(const UChar* characters, unsigned length);
+    JS_EXPORT_PRIVATE UString(const UChar* characters, unsigned length);
 
     // Construct a string with UTF-16 data, from a null-terminated source.
-    UString(const UChar*);
+    JS_EXPORT_PRIVATE UString(const UChar*);
 
     // Construct a string with latin1 data.
     UString(const LChar* characters, unsigned length);
-    UString(const char* characters, unsigned length);
+    JS_EXPORT_PRIVATE UString(const char* characters, unsigned length);
 
     // Construct a string with latin1 data, from a null-terminated source.
     UString(const LChar* characters);
-    UString(const char* characters);
+    JS_EXPORT_PRIVATE UString(const char* characters);
 
     // Construct a string referencing an existing StringImpl.
     UString(StringImpl* impl) : m_impl(impl) { }
@@ -99,9 +99,9 @@ public:
 
     bool is8Bit() const { return m_impl->is8Bit(); }
 
-    CString ascii() const;
+    JS_EXPORT_PRIVATE CString ascii() const;
     CString latin1() const;
-    CString utf8(bool strict = false) const;
+    JS_EXPORT_PRIVATE CString utf8(bool strict = false) const;
 
     UChar operator[](unsigned index) const
     {
@@ -112,11 +112,11 @@ public:
         return m_impl->characters16()[index];
     }
 
-    static UString number(int);
-    static UString number(unsigned);
-    static UString number(long);
+    JS_EXPORT_PRIVATE static UString number(int);
+    JS_EXPORT_PRIVATE static UString number(unsigned);
+    JS_EXPORT_PRIVATE static UString number(long);
     static UString number(long long);
-    static UString number(double);
+    JS_EXPORT_PRIVATE static UString number(double);
 
     // Find a single character or string, also with match function & latin1 forms.
     size_t find(UChar c, unsigned start = 0) const
@@ -132,7 +132,7 @@ public:
     size_t reverseFind(const UString& str, unsigned start = UINT_MAX) const
         { return m_impl ? m_impl->reverseFind(str.impl(), start) : notFound; }
 
-    UString substringSharingImpl(unsigned pos, unsigned len = UINT_MAX) const;
+    JS_EXPORT_PRIVATE UString substringSharingImpl(unsigned pos, unsigned len = UINT_MAX) const;
 
 private:
     RefPtr<StringImpl> m_impl;
@@ -189,10 +189,10 @@ inline bool operator!=(const UString& s1, const UString& s2)
     return !JSC::operator==(s1, s2);
 }
 
-bool operator<(const UString& s1, const UString& s2);
-bool operator>(const UString& s1, const UString& s2);
+JS_EXPORT_PRIVATE bool operator<(const UString& s1, const UString& s2);
+JS_EXPORT_PRIVATE bool operator>(const UString& s1, const UString& s2);
 
-bool operator==(const UString& s1, const char* s2);
+JS_EXPORT_PRIVATE bool operator==(const UString& s1, const char* s2);
 
 inline bool operator!=(const UString& s1, const char* s2)
 {
index 525fc09..a7bd7a1 100644 (file)
@@ -40,8 +40,8 @@ class JSGlobalObject;
 template<class T> class WriteBarrierBase;
 template<> class WriteBarrierBase<JSValue>;
 
-void slowValidateCell(JSCell*);
-void slowValidateCell(JSGlobalObject*);
+JS_EXPORT_PRIVATE void slowValidateCell(JSCell*);
+JS_EXPORT_PRIVATE void slowValidateCell(JSGlobalObject*);
     
 #if ENABLE(GC_VALIDATION)
 template<class T> inline void validateCell(T cell)
index ccb7fd3..ebe6d80 100644 (file)
@@ -65,10 +65,10 @@ class ArrayBufferView : public RefCounted<ArrayBufferView> {
 
     virtual unsigned byteLength() const = 0;
 
-    virtual ~ArrayBufferView();
+    WTF_EXPORT_PRIVATE virtual ~ArrayBufferView();
 
   protected:
-    ArrayBufferView(PassRefPtr<ArrayBuffer>, unsigned byteOffset);
+    WTF_EXPORT_PRIVATE ArrayBufferView(PassRefPtr<ArrayBuffer>, unsigned byteOffset);
 
     inline bool setImpl(ArrayBufferView*, unsigned byteOffset);
 
@@ -118,7 +118,7 @@ class ArrayBufferView : public RefCounted<ArrayBufferView> {
         *numElements = std::min(remainingElements, *numElements);
     }
 
-    virtual void neuter();
+    WTF_EXPORT_PRIVATE virtual void neuter();
 
     // This is the address of the ArrayBuffer's storage, plus the byte offset.
     void* m_baseAddress;
index 6964a33..f68d032 100644 (file)
@@ -83,7 +83,7 @@ namespace WTF {
             }
         }
 
-        static PassRefPtr<ByteArray> create(size_t size);
+        WTF_EXPORT_PRIVATE static PassRefPtr<ByteArray> create(size_t size);
 
         static size_t offsetOfSize() { return OBJECT_OFFSETOF(ByteArray, m_size); }
         static size_t offsetOfData() { return OBJECT_OFFSETOF(ByteArray, m_data); }
index 348242e..2262b6c 100644 (file)
@@ -31,8 +31,8 @@
 namespace WTF {
 
 #if USE(OS_RANDOMNESS)
-uint32_t cryptographicallyRandomNumber();
-void cryptographicallyRandomValues(void* buffer, size_t length);
+WTF_EXPORT_PRIVATE uint32_t cryptographicallyRandomNumber();
+WTF_EXPORT_PRIVATE void cryptographicallyRandomValues(void* buffer, size_t length);
 #endif
 
 }
index 71775c2..ee49f8d 100644 (file)
@@ -39,7 +39,7 @@ namespace WTF {
 // Returns the current UTC time in seconds, counted from January 1, 1970.
 // Precision varies depending on platform but is usually as good or better
 // than a millisecond.
-double currentTime();
+WTF_EXPORT_PRIVATE double currentTime();
 
 // Same thing, in milliseconds.
 inline double currentTimeMS()
@@ -60,7 +60,7 @@ inline void getLocalTime(const time_t* localTime, struct tm* localTM)
 
 // Provides a monotonically increasing time in seconds since an arbitrary point in the past.
 // On unsupported platforms, this function only guarantees the result will be non-decreasing.
-double monotonicallyIncreasingTime();
+WTF_EXPORT_PRIVATE double monotonicallyIncreasingTime();
 
 } // namespace WTF
 
index 114acf8..fc1a8d8 100644 (file)
@@ -61,7 +61,7 @@ int equivalentYearForDST(int year);
 
 // Not really math related, but this is currently the only shared place to put these.
 double parseES5DateFromNullTerminatedCharacters(const char* dateString);
-double parseDateFromNullTerminatedCharacters(const char* dateString);
+WTF_EXPORT_PRIVATE double parseDateFromNullTerminatedCharacters(const char* dateString);
 double parseDateFromNullTerminatedCharacters(const char* dateString, bool& haveTZ, int& offset);
 double timeClip(double);
 // dayOfWeek: [0, 6] 0 being Monday, day: [1, 31], month: [0, 11], year: ex: 2011, hours: [0, 23], minutes: [0, 59], seconds: [0, 59], utcOffset: [-720,720]. 
@@ -89,18 +89,18 @@ const double msPerMonth = 2592000000.0;
 bool isLeapYear(int year);
 
 // Returns the number of days from 1970-01-01 to the specified date.
-double dateToDaysFrom1970(int year, int month, int day);
-int msToYear(double ms);
+WTF_EXPORT_PRIVATE double dateToDaysFrom1970(int year, int month, int day);
+WTF_EXPORT_PRIVATE int msToYear(double ms);
 double msToDays(double ms);
 int msToMinutes(double ms);
 int msToHours(double ms);
-int dayInYear(double ms, int year);
-int monthFromDayInYear(int dayInYear, bool leapYear);
-int dayInMonthFromDayInYear(int dayInYear, bool leapYear);
+WTF_EXPORT_PRIVATE int dayInYear(double ms, int year);
+WTF_EXPORT_PRIVATE int monthFromDayInYear(int dayInYear, bool leapYear);
+WTF_EXPORT_PRIVATE int dayInMonthFromDayInYear(int dayInYear, bool leapYear);
 
 // Returns offset milliseconds for UTC and DST.
-int32_t calculateUTCOffset();
-double calculateDSTOffset(double ms, double utcOffset);
+WTF_EXPORT_PRIVATE int32_t calculateUTCOffset();
+WTF_EXPORT_PRIVATE double calculateDSTOffset(double ms, double utcOffset);
 
 } // namespace WTF
 
index ac7b800..61effcd 100644 (file)
@@ -81,11 +81,11 @@ public:
         ASSERT(m_significand[0] != '0' || !m_exponent);
     }
 
-    unsigned bufferLengthForStringDecimal() const;
-    unsigned bufferLengthForStringExponential() const;
+    WTF_EXPORT_PRIVATE unsigned bufferLengthForStringDecimal() const;
+    WTF_EXPORT_PRIVATE unsigned bufferLengthForStringExponential() const;
 
-    unsigned toStringDecimal(UChar* buffer, unsigned bufferLength) const;
-    unsigned toStringExponential(UChar* buffer, unsigned bufferLength) const;
+    WTF_EXPORT_PRIVATE unsigned toStringDecimal(UChar* buffer, unsigned bufferLength) const;
+    WTF_EXPORT_PRIVATE unsigned toStringExponential(UChar* buffer, unsigned bufferLength) const;
 
     bool sign() const { return m_sign; }
     int exponent() const { return m_exponent; }
index 5c68450..6b92f55 100644 (file)
@@ -182,7 +182,7 @@ namespace WTF {
 
 namespace Internal {
 #if !ENABLE(WTF_MALLOC_VALIDATION)
-void fastMallocMatchFailed(void*);
+WTF_EXPORT_PRIVATE void fastMallocMatchFailed(void*);
 #else
 COMPILE_ASSERT(((sizeof(ValidationHeader) % sizeof(AllocAlignmentInteger)) == 0), ValidationHeader_must_produce_correct_alignment);
 #endif
@@ -400,7 +400,7 @@ size_t fastMallocSize(const void* p)
 #if OS(DARWIN)
 // This symbol is present in the JavaScriptCore exports file even when FastMalloc is disabled.
 // It will never be used in this case, so it's type and value are less interesting than its presence.
-extern "C" const int jscore_fastmalloc_introspection = 0;
+extern "C" WTF_EXPORT_PRIVATE const int jscore_fastmalloc_introspection = 0;
 #endif
 
 #else // FORCE_SYSTEM_MALLOC
index b4f74e4..b115908 100644 (file)
 namespace WTF {
 
     // These functions call CRASH() if an allocation fails.
-    void* fastMalloc(size_t);
-    void* fastZeroedMalloc(size_t);
-    void* fastCalloc(size_t numElements, size_t elementSize);
-    void* fastRealloc(void*, size_t);
-    char* fastStrDup(const char*);
-    size_t fastMallocSize(const void*);
+    WTF_EXPORT_PRIVATE void* fastMalloc(size_t);
+    WTF_EXPORT_PRIVATE void* fastZeroedMalloc(size_t);
+    WTF_EXPORT_PRIVATE void* fastCalloc(size_t numElements, size_t elementSize);
+    WTF_EXPORT_PRIVATE void* fastRealloc(void*, size_t);
+    WTF_EXPORT_PRIVATE char* fastStrDup(const char*);
+    WTF_EXPORT_PRIVATE size_t fastMallocSize(const void*);
 
     struct TryMallocReturnValue {
         TryMallocReturnValue(void* data)
@@ -68,26 +68,26 @@ namespace WTF {
         return returnValue;
     }
 
-    TryMallocReturnValue tryFastMalloc(size_t n);
+    WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastMalloc(size_t n);
     TryMallocReturnValue tryFastZeroedMalloc(size_t n);
-    TryMallocReturnValue tryFastCalloc(size_t n_elements, size_t element_size);
-    TryMallocReturnValue tryFastRealloc(void* p, size_t n);
+    WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastCalloc(size_t n_elements, size_t element_size);
+    WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastRealloc(void* p, size_t n);
 
-    void fastFree(void*);
+    WTF_EXPORT_PRIVATE void fastFree(void*);
 
 #ifndef NDEBUG    
     void fastMallocForbid();
     void fastMallocAllow();
 #endif
 
-    void releaseFastMallocFreeMemory();
+    WTF_EXPORT_PRIVATE void releaseFastMallocFreeMemory();
     
     struct FastMallocStatistics {
         size_t reservedVMBytes;
         size_t committedVMBytes;
         size_t freeListBytes;
     };
-    FastMallocStatistics fastMallocStatistics();
+    WTF_EXPORT_PRIVATE FastMallocStatistics fastMallocStatistics();
 
     // This defines a type which holds an unsigned integer and is the same
     // size as the minimally aligned memory allocation.
index 3caa810..ef027cc 100644 (file)
@@ -37,16 +37,16 @@ namespace WTF {
 
 class MD5 {
 public:
-    MD5();
+    WTF_EXPORT_PRIVATE MD5();
 
     void addBytes(const Vector<uint8_t>& input)
     {
         addBytes(input.data(), input.size());
     }
-    void addBytes(const uint8_t* input, size_t length);
+    WTF_EXPORT_PRIVATE void addBytes(const uint8_t* input, size_t length);
 
     // checksum has a side effect of resetting the state of the object.
-    void checksum(Vector<uint8_t, 16>&);
+    WTF_EXPORT_PRIVATE void checksum(Vector<uint8_t, 16>&);
 
 private:
     uint32_t m_buf[4];
index c153d1e..ff76a5f 100644 (file)
@@ -40,21 +40,21 @@ typedef uint32_t ThreadIdentifier;
 typedef void MainThreadFunction(void*);
 
 // Must be called from the main thread.
-void initializeMainThread();
+WTF_EXPORT_PRIVATE void initializeMainThread();
 
-void callOnMainThread(MainThreadFunction*, void* context);
-void callOnMainThreadAndWait(MainThreadFunction*, void* context);
-void cancelCallOnMainThread(MainThreadFunction*, void* context);
+WTF_EXPORT_PRIVATE void callOnMainThread(MainThreadFunction*, void* context);
+WTF_EXPORT_PRIVATE void callOnMainThreadAndWait(MainThreadFunction*, void* context);
+WTF_EXPORT_PRIVATE void cancelCallOnMainThread(MainThreadFunction*, void* context);
 
 template<typename> class Function;
-void callOnMainThread(const Function<void ()>&);
+WTF_EXPORT_PRIVATE void callOnMainThread(const Function<void ()>&);
     
-void setMainThreadCallbacksPaused(bool paused);
+WTF_EXPORT_PRIVATE void setMainThreadCallbacksPaused(bool paused);
 
-bool isMainThread();
+WTF_EXPORT_PRIVATE bool isMainThread();
 #if ENABLE(PARALLEL_GC)
 void registerGCThread();
-bool isMainThreadOrGCThread();
+WTF_EXPORT_PRIVATE bool isMainThreadOrGCThread();
 #elif PLATFORM(MAC)
 bool isMainThreadOrGCThread();
 #else
@@ -70,7 +70,7 @@ void dispatchFunctionsFromMainThread();
 // This version of initializeMainThread sets up the main thread as corresponding
 // to the process's main thread, and not necessarily the thread that calls this
 // function. It should only be used as a legacy aid for Mac WebKit.
-void initializeMainThreadToProcessMainThread();
+WTF_EXPORT_PRIVATE void initializeMainThreadToProcessMainThread();
 void initializeMainThreadToProcessMainThreadPlatform();
 #endif
 
index cf971b7..a337039 100644 (file)
@@ -47,11 +47,11 @@ class MetaAllocator {
     WTF_MAKE_NONCOPYABLE(MetaAllocator);
 public:
     
-    MetaAllocator(size_t allocationGranule);
+    WTF_EXPORT_PRIVATE MetaAllocator(size_t allocationGranule);
     
     virtual ~MetaAllocator();
     
-    PassRefPtr<MetaAllocatorHandle> allocate(size_t sizeInBytes);
+    WTF_EXPORT_PRIVATE PassRefPtr<MetaAllocatorHandle> allocate(size_t sizeInBytes);
     
     // Non-atomic methods for getting allocator statistics.
     size_t bytesAllocated() { return m_bytesAllocated; }
@@ -69,11 +69,11 @@ public:
     // Add more free space to the allocator. Call this directly from
     // the constructor if you wish to operate the allocator within a
     // fixed pool.
-    void addFreshFreeSpace(void* start, size_t sizeInBytes);
+    WTF_EXPORT_PRIVATE void addFreshFreeSpace(void* start, size_t sizeInBytes);
 
     // This is meant only for implementing tests. Never call this in release
     // builds.
-    size_t debugFreeSpaceSize();
+    WTF_EXPORT_PRIVATE size_t debugFreeSpaceSize();
     
 #if ENABLE(META_ALLOCATOR_PROFILE)
     void dumpProfile();
@@ -127,7 +127,7 @@ private:
     size_t roundUp(size_t sizeInBytes);
     
     FreeSpaceNode* allocFreeSpaceNode();
-    void freeFreeSpaceNode(FreeSpaceNode*);
+    WTF_EXPORT_PRIVATE void freeFreeSpaceNode(FreeSpaceNode*);
     
     size_t m_allocationGranule;
     unsigned m_logAllocationGranule;
index 5a32081..9310952 100644 (file)
@@ -50,7 +50,7 @@ private:
     }
     
 public:
-    ~MetaAllocatorHandle();
+    WTF_EXPORT_PRIVATE ~MetaAllocatorHandle();
     
     static PassRefPtr<MetaAllocatorHandle> createSelfManagedHandle(void* start, size_t sizeInBytes)
     {
@@ -72,7 +72,7 @@ public:
         return m_sizeInBytes;
     }
         
-    void shrink(size_t newSizeInBytes);
+    WTF_EXPORT_PRIVATE void shrink(size_t newSizeInBytes);
     
     bool isManaged()
     {
index bf9f049..be791a8 100644 (file)
@@ -46,7 +46,7 @@ public:
     // releaseDecommitted should be called on a region of VM allocated by a single reservation,
     // the memory must all currently be in a decommitted state.
     static void* reserveUncommitted(size_t, Usage = UnknownUsage, bool writable = true, bool executable = false, bool includesGuardPages = false);
-    static void releaseDecommitted(void*, size_t);
+    WTF_EXPORT_PRIVATE static void releaseDecommitted(void*, size_t);
 
     // These methods are symmetric; they commit or decommit a region of VM (uncommitted VM should
     // never be accessed, since the OS may not have attached physical memory for these regions).
@@ -57,7 +57,7 @@ public:
     // These methods are symmetric; reserveAndCommit allocates VM in an committed state,
     // decommitAndRelease should be called on a region of VM allocated by a single reservation,
     // the memory must all currently be in a committed state.
-    static void* reserveAndCommit(size_t, Usage = UnknownUsage, bool writable = true, bool executable = false, bool includesGuardPages = false);
+    WTF_EXPORT_PRIVATE static void* reserveAndCommit(size_t, Usage = UnknownUsage, bool writable = true, bool executable = false, bool includesGuardPages = false);
     static void decommitAndRelease(void* base, size_t size);
 
     // These methods are akin to reserveAndCommit/decommitAndRelease, above - however rather than
index e17c546..3c348a0 100644 (file)
@@ -28,7 +28,7 @@
 
 namespace WTF {
 
-size_t pageSize();
+WTF_EXPORT_PRIVATE size_t pageSize();
 inline bool isPageAligned(void* address) { return !(reinterpret_cast<intptr_t>(address) & (pageSize() - 1)); }
 inline bool isPageAligned(size_t size) { return !(size & (pageSize() - 1)); }
 inline bool isPowerOfTwo(size_t size) { return !(size & (size - 1)); }
index f2e7e8f..76b2235 100644 (file)
@@ -30,7 +30,7 @@ namespace WTF {
 
     // Returns a pseudo-random number in the range [0, 1), attempts to be
     // cryptographically secure if possible on the target platform
-    double randomNumber();
+    WTF_EXPORT_PRIVATE double randomNumber();
 
 }
 
index 22c7506..476b173 100644 (file)
 namespace WTF {
     
     struct RefCountedLeakCounter {
-        static void suppressMessages(const char*);
-        static void cancelMessageSuppression(const char*);
+        WTF_EXPORT_PRIVATE static void suppressMessages(const char*);
+        WTF_EXPORT_PRIVATE static void cancelMessageSuppression(const char*);
         
-        explicit RefCountedLeakCounter(const char* description);
-        ~RefCountedLeakCounter();
+        WTF_EXPORT_PRIVATE explicit RefCountedLeakCounter(const char* description);
+        WTF_EXPORT_PRIVATE ~RefCountedLeakCounter();
 
-        void increment();
-        void decrement();
+        WTF_EXPORT_PRIVATE void increment();
+        WTF_EXPORT_PRIVATE void decrement();
 
 #ifndef NDEBUG
     private:
index dad6dc8..e8cc802 100644 (file)
@@ -37,16 +37,16 @@ namespace WTF {
 
 class SHA1 {
 public:
-    SHA1();
+    WTF_EXPORT_PRIVATE SHA1();
 
     void addBytes(const Vector<uint8_t>& input)
     {
         addBytes(input.data(), input.size());
     }
-    void addBytes(const uint8_t* input, size_t length);
+    WTF_EXPORT_PRIVATE void addBytes(const uint8_t* input, size_t length);
 
     // computeHash has a side effect of resetting the state of the object.
-    void computeHash(Vector<uint8_t, 20>&);
+    WTF_EXPORT_PRIVATE void computeHash(Vector<uint8_t, 20>&);
 
 private:
     void finalize();
index f2e0565..d8dbbae 100644 (file)
@@ -89,7 +89,7 @@ ThreadIdentifier createThread(ThreadFunction entryPoint, void* data, const char*
 // This function is deprecated but needs to be kept around for backward
 // compatibility. Use the 3-argument version of createThread above.
 
-ThreadIdentifier createThread(ThreadFunction entryPoint, void* data);
+WTF_EXPORT_PRIVATE ThreadIdentifier createThread(ThreadFunction entryPoint, void* data);
 
 ThreadIdentifier createThread(ThreadFunction entryPoint, void* data)
 {
index 3a89757..1dee5da 100644 (file)
@@ -83,11 +83,11 @@ typedef void* (*ThreadFunction)(void* argument);
 // This function must be called from the main thread. It is safe to call it repeatedly.
 // Darwin is an exception to this rule: it is OK to call it from any thread, the only 
 // requirement is that the calls are not reentrant.
-void initializeThreading();
+WTF_EXPORT_PRIVATE void initializeThreading();
 
 // Returns 0 if thread creation failed.
 // The thread name must be a literal since on some platforms it's passed in to the thread.
-ThreadIdentifier createThread(ThreadFunction, void*, const char* threadName);
+WTF_EXPORT_PRIVATE ThreadIdentifier createThread(ThreadFunction, void*, const char* threadName);
 
 // Internal platform-specific createThread implementation.
 ThreadIdentifier createThreadInternal(ThreadFunction, void*, const char* threadName);
@@ -96,14 +96,14 @@ ThreadIdentifier createThreadInternal(ThreadFunction, void*, const char* threadN
 // Helpful for platforms where the thread name must be set from within the thread.
 void initializeCurrentThreadInternal(const char* threadName);
 
-ThreadIdentifier currentThread();
-int waitForThreadCompletion(ThreadIdentifier, void**);
-void detachThread(ThreadIdentifier);
+WTF_EXPORT_PRIVATE ThreadIdentifier currentThread();
+WTF_EXPORT_PRIVATE int waitForThreadCompletion(ThreadIdentifier, void**);
+WTF_EXPORT_PRIVATE void detachThread(ThreadIdentifier);
 
-void yield();
+WTF_EXPORT_PRIVATE void yield();
 
-void lockAtomicallyInitializedStaticMutex();
-void unlockAtomicallyInitializedStaticMutex();
+WTF_EXPORT_PRIVATE void lockAtomicallyInitializedStaticMutex();
+WTF_EXPORT_PRIVATE void unlockAtomicallyInitializedStaticMutex();
 
 } // namespace WTF
 
index 1bed5d3..2ac42c8 100644 (file)
@@ -82,12 +82,12 @@ typedef void* PlatformCondition;
 class Mutex {
     WTF_MAKE_NONCOPYABLE(Mutex); WTF_MAKE_FAST_ALLOCATED;
 public:
-    Mutex();
-    ~Mutex();
+    WTF_EXPORT_PRIVATE Mutex();
+    WTF_EXPORT_PRIVATE ~Mutex();
 
-    void lock();
-    bool tryLock();
-    void unlock();
+    WTF_EXPORT_PRIVATE void lock();
+    WTF_EXPORT_PRIVATE bool tryLock();
+    WTF_EXPORT_PRIVATE void unlock();
 
 public:
     PlatformMutex& impl() { return m_mutex; }
@@ -118,15 +118,15 @@ private:
 class ThreadCondition {
     WTF_MAKE_NONCOPYABLE(ThreadCondition);
 public:
-    ThreadCondition();
-    ~ThreadCondition();
+    WTF_EXPORT_PRIVATE ThreadCondition();
+    WTF_EXPORT_PRIVATE ~ThreadCondition();
     
-    void wait(Mutex& mutex);
+    WTF_EXPORT_PRIVATE void wait(Mutex& mutex);
     // Returns true if the condition was signaled before absoluteTime, false if the absoluteTime was reached or is in the past.
     // The absoluteTime is in seconds, starting on January 1, 1970. The time is assumed to use the same time zone as WTF::currentTime().
-    bool timedWait(Mutex&, double absoluteTime);
-    void signal();
-    void broadcast();
+    WTF_EXPORT_PRIVATE bool timedWait(Mutex&, double absoluteTime);
+    WTF_EXPORT_PRIVATE void signal();
+    WTF_EXPORT_PRIVATE void broadcast();
     
 private:
     PlatformCondition m_condition;
index 81b817f..b02d10d 100644 (file)
@@ -78,8 +78,8 @@ typedef void (*AtomicStringTableDestructor)(AtomicStringTable*);
 class WTFThreadData {
     WTF_MAKE_NONCOPYABLE(WTFThreadData);
 public:
-    WTFThreadData();
-    ~WTFThreadData();
+    WTF_EXPORT_PRIVATE WTFThreadData();
+    WTF_EXPORT_PRIVATE ~WTFThreadData();
 
     AtomicStringTable* atomicStringTable()
     {
index df33e2c..d27c592 100644 (file)
@@ -31,19 +31,19 @@ extern WTF::Mutex* s_dtoaP5Mutex;
 
 typedef char DtoaBuffer[80];
 
-void dtoa(DtoaBuffer result, double dd, bool& sign, int& exponent, unsigned& precision);
-void dtoaRoundSF(DtoaBuffer result, double dd, int ndigits, bool& sign, int& exponent, unsigned& precision);
-void dtoaRoundDP(DtoaBuffer result, double dd, int ndigits, bool& sign, int& exponent, unsigned& precision);
+WTF_EXPORT_PRIVATE void dtoa(DtoaBuffer result, double dd, bool& sign, int& exponent, unsigned& precision);
+WTF_EXPORT_PRIVATE void dtoaRoundSF(DtoaBuffer result, double dd, int ndigits, bool& sign, int& exponent, unsigned& precision);
+WTF_EXPORT_PRIVATE void dtoaRoundDP(DtoaBuffer result, double dd, int ndigits, bool& sign, int& exponent, unsigned& precision);
 
 // s00: input string. Must not be 0 and must be terminated by 0.
 // se: *se will have the last consumed character position + 1.
-double strtod(const char* s00, char** se);
+WTF_EXPORT_PRIVATE double strtod(const char* s00, char** se);
 
 // Size = 80 for sizeof(DtoaBuffer) + some sign bits, decimal point, 'e', exponent digits.
 const unsigned NumberToStringBufferLength = 96;
 typedef char NumberToStringBuffer[NumberToStringBufferLength];
 typedef UChar NumberToUStringBuffer[NumberToStringBufferLength];
-const char* numberToString(double, NumberToStringBuffer);
+WTF_EXPORT_PRIVATE const char* numberToString(double, NumberToStringBuffer);
 const char* numberToFixedPrecisionString(double, unsigned significantFigures, NumberToStringBuffer, bool truncateTrailingZeros = false);
 const char* numberToFixedWidthString(double, unsigned decimalPlaces, NumberToStringBuffer);
 
index 43b38d1..4c44f3d 100644 (file)
@@ -38,7 +38,7 @@ struct AtomicStringHash;
 
 class AtomicString {
 public:
-    static void init();
+    WTF_EXPORT_PRIVATE static void init();
 
     AtomicString() { }
     AtomicString(const LChar* s) : m_string(add(s)) { }
@@ -54,7 +54,7 @@ public:
     AtomicString(WTF::HashTableDeletedValueType) : m_string(WTF::HashTableDeletedValue) { }
     bool isHashTableDeletedValue() const { return m_string.isHashTableDeletedValue(); }
 
-    static AtomicStringImpl* find(const UChar* s, unsigned length, unsigned existingHash);
+    WTF_EXPORT_PRIVATE static AtomicStringImpl* find(const UChar* s, unsigned length, unsigned existingHash);
 
     operator const String&() const { return m_string; }
     const String& string() const { return m_string; };
@@ -83,7 +83,7 @@ public:
     bool endsWith(const String& s, bool caseSensitive = true) const
         { return m_string.endsWith(s, caseSensitive); }
     
-    AtomicString lower() const;
+    WTF_EXPORT_PRIVATE AtomicString lower() const;
     AtomicString upper() const { return AtomicString(impl()->upper()); }
     
     int toInt(bool* ok = 0) const { return m_string.toInt(ok); }
@@ -120,20 +120,20 @@ public:
 private:
     String m_string;
     
-    static PassRefPtr<StringImpl> add(const LChar*);
+    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> add(const LChar*);
     ALWAYS_INLINE static PassRefPtr<StringImpl> add(const char* s) { return add(reinterpret_cast<const LChar*>(s)); };
-    static PassRefPtr<StringImpl> add(const UChar*, unsigned length);
+    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> add(const UChar*, unsigned length);
     ALWAYS_INLINE static PassRefPtr<StringImpl> add(const char* s, unsigned length) { return add(reinterpret_cast<const char*>(s), length); };
-    static PassRefPtr<StringImpl> add(const UChar*, unsigned length, unsigned existingHash);
-    static PassRefPtr<StringImpl> add(const UChar*);
+    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> add(const UChar*, unsigned length, unsigned existingHash);
+    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> add(const UChar*);
     ALWAYS_INLINE PassRefPtr<StringImpl> add(StringImpl* r)
     {
         if (!r || r->isAtomic())
             return r;
         return addSlowCase(r);
     }
-    static PassRefPtr<StringImpl> addSlowCase(StringImpl*);
-    static AtomicString fromUTF8Internal(const char*, const char*);
+    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> addSlowCase(StringImpl*);
+    WTF_EXPORT_PRIVATE static AtomicString fromUTF8Internal(const char*, const char*);
 };
 
 inline bool operator==(const AtomicString& a, const AtomicString& b) { return a.impl() == b.impl(); }
index 343a7a5..d43ad4b 100644 (file)
@@ -52,16 +52,16 @@ private:
 class CString {
 public:
     CString() { }
-    CString(const char*);
-    CString(const char*, size_t length);
+    WTF_EXPORT_PRIVATE CString(const char*);
+    WTF_EXPORT_PRIVATE CString(const char*, size_t length);
     CString(CStringBuffer* buffer) : m_buffer(buffer) { }
-    static CString newUninitialized(size_t length, char*& characterBuffer);
+    WTF_EXPORT_PRIVATE static CString newUninitialized(size_t length, char*& characterBuffer);
 
     const char* data() const
     {
         return m_buffer ? m_buffer->data() : 0;
     }
-    char* mutableData();
+    WTF_EXPORT_PRIVATE char* mutableData();
     size_t length() const
     {
         return m_buffer ? m_buffer->length() - 1 : 0;
@@ -77,7 +77,7 @@ private:
     RefPtr<CStringBuffer> m_buffer;
 };
 
-bool operator==(const CString& a, const CString& b);
+WTF_EXPORT_PRIVATE bool operator==(const CString& a, const CString& b);
 inline bool operator!=(const CString& a, const CString& b) { return !(a == b); }
 
 } // namespace WTF
index da1e832..bf7aed4 100644 (file)
@@ -41,8 +41,8 @@ public:
     {
     }
 
-    void append(const UChar*, unsigned);
-    void append(const LChar*, unsigned);
+    WTF_EXPORT_PRIVATE void append(const UChar*, unsigned);
+    WTF_EXPORT_PRIVATE void append(const LChar*, unsigned);
 
     ALWAYS_INLINE void append(const char* characters, unsigned length) { append(reinterpret_cast<const LChar*>(characters), length); }
 
@@ -127,11 +127,11 @@ public:
 
     bool isEmpty() const { return !length(); }
 
-    void reserveCapacity(unsigned newCapacity);
+    WTF_EXPORT_PRIVATE void reserveCapacity(unsigned newCapacity);
 
-    void resize(unsigned newSize);
+    WTF_EXPORT_PRIVATE void resize(unsigned newSize);
 
-    void shrinkToFit();
+    WTF_EXPORT_PRIVATE void shrinkToFit();
 
     UChar operator[](unsigned i) const
     {
@@ -200,7 +200,7 @@ private:
     CharType* appendUninitializedSlow(unsigned length);
     template <typename CharType>
     ALWAYS_INLINE CharType * getBufferCharacters();
-    void reifyString();
+    WTF_EXPORT_PRIVATE void reifyString();
 
     unsigned m_length;
     String m_string;
index 003c44c..a2fe53d 100644 (file)
@@ -190,12 +190,12 @@ private:
     }
 
 public:
-    ~StringImpl();
+    WTF_EXPORT_PRIVATE ~StringImpl();
 
-    static PassRefPtr<StringImpl> create(const UChar*, unsigned length);
+    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> create(const UChar*, unsigned length);
     static PassRefPtr<StringImpl> create(const LChar*, unsigned length);
     ALWAYS_INLINE static PassRefPtr<StringImpl> create(const char* s, unsigned length) { return create(reinterpret_cast<const LChar*>(s), length); }
-    static PassRefPtr<StringImpl> create(const LChar*);
+    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> create(const LChar*);
     ALWAYS_INLINE static PassRefPtr<StringImpl> create(const char* s) { return create(reinterpret_cast<const LChar*>(s)); }
 
     static ALWAYS_INLINE PassRefPtr<StringImpl> create8(PassRefPtr<StringImpl> rep, unsigned offset, unsigned length)
@@ -226,7 +226,7 @@ public:
     }
 
     static PassRefPtr<StringImpl> createUninitialized(unsigned length, LChar*& data);
-    static PassRefPtr<StringImpl> createUninitialized(unsigned length, UChar*& data);
+    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> createUninitialized(unsigned length, UChar*& data);
     template <typename T> static ALWAYS_INLINE PassRefPtr<StringImpl> tryCreateUninitialized(unsigned length, T*& output)
     {
         if (!length) {
@@ -275,7 +275,7 @@ public:
     }
 
     static PassRefPtr<StringImpl> adopt(StringBuffer<LChar>& buffer);
-    static PassRefPtr<StringImpl> adopt(StringBuffer<UChar>& buffer);
+    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> adopt(StringBuffer<UChar>& buffer);
 
     unsigned length() const { return m_length; }
     bool is8Bit() const { return m_hashAndFlags & s_hashFlag8BitBuffer; }
@@ -308,7 +308,7 @@ public:
     }
 
     bool has16BitShadow() const { return m_hashAndFlags & s_hashFlagHas16BitShadow; }
-    void upconvertCharacters(unsigned, unsigned) const;
+    WTF_EXPORT_PRIVATE void upconvertCharacters(unsigned, unsigned) const;
     bool isIdentifier() const { return m_hashAndFlags & s_hashFlagIsIdentifier; }
     void setIsIdentifier(bool isIdentifier)
     {
@@ -393,7 +393,7 @@ public:
         m_refCount -= s_refCountIncrement;
     }
 
-    static StringImpl* empty();
+    WTF_EXPORT_PRIVATE static StringImpl* empty();
 
     // FIXME: Does this really belong in StringImpl?
     template <typename T> static void copyChars(T* destination, const T* source, unsigned numCharacters)
@@ -428,7 +428,7 @@ public:
     // its own copy of the string.
     PassRefPtr<StringImpl> isolatedCopy() const;
 
-    PassRefPtr<StringImpl> substring(unsigned pos, unsigned len = UINT_MAX);
+    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> substring(unsigned pos, unsigned len = UINT_MAX);
 
     UChar operator[](unsigned i) const
     {
@@ -437,9 +437,9 @@ public:
             return m_data8[i];
         return m_data16[i];
     }
-    UChar32 characterStartingAt(unsigned);
+    WTF_EXPORT_PRIVATE UChar32 characterStartingAt(unsigned);
 
-    bool containsOnlyWhitespace();
+    WTF_EXPORT_PRIVATE bool containsOnlyWhitespace();
 
     int toIntStrict(bool* ok = 0, int base = 10);
     unsigned toUIntStrict(bool* ok = 0, int base = 10);
@@ -447,7 +447,7 @@ public:
     uint64_t toUInt64Strict(bool* ok = 0, int base = 10);
     intptr_t toIntPtrStrict(bool* ok = 0, int base = 10);
 
-    int toInt(bool* ok = 0); // ignores trailing garbage
+    WTF_EXPORT_PRIVATE int toInt(bool* ok = 0); // ignores trailing garbage
     unsigned toUInt(bool* ok = 0); // ignores trailing garbage
     int64_t toInt64(bool* ok = 0); // ignores trailing garbage
     uint64_t toUInt64(bool* ok = 0); // ignores trailing garbage
@@ -456,44 +456,44 @@ public:
     double toDouble(bool* ok = 0, bool* didReadNumber = 0);
     float toFloat(bool* ok = 0, bool* didReadNumber = 0);
 
-    PassRefPtr<StringImpl> lower();
-    PassRefPtr<StringImpl> upper();
+    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> lower();
+    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> upper();
 
-    PassRefPtr<StringImpl> fill(UChar);
+    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> fill(UChar);
     // FIXME: Do we need fill(char) or can we just do the right thing if UChar is ASCII?
     PassRefPtr<StringImpl> foldCase();
 
     PassRefPtr<StringImpl> stripWhiteSpace();
     PassRefPtr<StringImpl> stripWhiteSpace(IsWhiteSpaceFunctionPtr);
-    PassRefPtr<StringImpl> simplifyWhiteSpace();
+    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> simplifyWhiteSpace();
     PassRefPtr<StringImpl> simplifyWhiteSpace(IsWhiteSpaceFunctionPtr);
 
     PassRefPtr<StringImpl> removeCharacters(CharacterMatchFunctionPtr);
     template <typename CharType>
     ALWAYS_INLINE PassRefPtr<StringImpl> removeCharacters(const CharType* characters, CharacterMatchFunctionPtr);
 
-    size_t find(UChar, unsigned index = 0);
-    size_t find(CharacterMatchFunctionPtr, unsigned index = 0);
+    WTF_EXPORT_PRIVATE size_t find(UChar, unsigned index = 0);
+    WTF_EXPORT_PRIVATE size_t find(CharacterMatchFunctionPtr, unsigned index = 0);
     size_t find(const LChar*, unsigned index = 0);
     ALWAYS_INLINE size_t find(const char* s, unsigned index = 0) { return find(reinterpret_cast<const LChar*>(s), index); };
-    size_t find(StringImpl*, unsigned index = 0);
+    WTF_EXPORT_PRIVATE size_t find(StringImpl*, unsigned index = 0);
     size_t findIgnoringCase(const LChar*, unsigned index = 0);
     ALWAYS_INLINE size_t findIgnoringCase(const char* s, unsigned index = 0) { return findIgnoringCase(reinterpret_cast<const LChar*>(s), index); };
-    size_t findIgnoringCase(StringImpl*, unsigned index = 0);
+    WTF_EXPORT_PRIVATE size_t findIgnoringCase(StringImpl*, unsigned index = 0);
 
-    size_t reverseFind(UChar, unsigned index = UINT_MAX);
-    size_t reverseFind(StringImpl*, unsigned index = UINT_MAX);
-    size_t reverseFindIgnoringCase(StringImpl*, unsigned index = UINT_MAX);
+    WTF_EXPORT_PRIVATE size_t reverseFind(UChar, unsigned index = UINT_MAX);
+    WTF_EXPORT_PRIVATE size_t reverseFind(StringImpl*, unsigned index = UINT_MAX);
+    WTF_EXPORT_PRIVATE size_t reverseFindIgnoringCase(StringImpl*, unsigned index = UINT_MAX);
 
     bool startsWith(StringImpl* str, bool caseSensitive = true) { return (caseSensitive ? reverseFind(str, 0) : reverseFindIgnoringCase(str, 0)) == 0; }
-    bool endsWith(StringImpl*, bool caseSensitive = true);
+    WTF_EXPORT_PRIVATE bool endsWith(StringImpl*, bool caseSensitive = true);
 
-    PassRefPtr<StringImpl> replace(UChar, UChar);
-    PassRefPtr<StringImpl> replace(UChar, StringImpl*);
-    PassRefPtr<StringImpl> replace(StringImpl*, StringImpl*);
-    PassRefPtr<StringImpl> replace(unsigned index, unsigned len, StringImpl*);
+    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> replace(UChar, UChar);
+    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> replace(UChar, StringImpl*);
+    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> replace(StringImpl*, StringImpl*);
+    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> replace(unsigned index, unsigned len, StringImpl*);
 
-    WTF::Unicode::Direction defaultWritingDirection(bool* hasStrongDirectionality = 0);
+    WTF_EXPORT_PRIVATE WTF::Unicode::Direction defaultWritingDirection(bool* hasStrongDirectionality = 0);
 
 #if USE(CF)
     CFStringRef createCFString();
@@ -510,8 +510,8 @@ private:
     bool isStatic() const { return m_refCount & s_refCountFlagIsStaticString; }
     template <class UCharPredicate> PassRefPtr<StringImpl> stripMatchedCharacters(UCharPredicate);
     template <typename CharType, class UCharPredicate> PassRefPtr<StringImpl> simplifyMatchedCharactersToSpace(UCharPredicate);
-    NEVER_INLINE const UChar* getData16SlowCase() const;
-    NEVER_INLINE unsigned hashSlowCase() const;
+    WTF_EXPORT_PRIVATE NEVER_INLINE const UChar* getData16SlowCase() const;
+    WTF_EXPORT_PRIVATE NEVER_INLINE unsigned hashSlowCase() const;
 
     // The bottom bit in the ref count indicates a static (immortal) string.
     static const unsigned s_refCountFlagIsStaticString = 0x1;
@@ -550,14 +550,14 @@ ALWAYS_INLINE const LChar* StringImpl::getCharacters<LChar>() const { return cha
 template <>
 ALWAYS_INLINE const UChar* StringImpl::getCharacters<UChar>() const { return characters16(); }
 
-bool equal(const StringImpl*, const StringImpl*);
-bool equal(const StringImpl*, const LChar*);
+WTF_EXPORT_PRIVATE bool equal(const StringImpl*, const StringImpl*);
+WTF_EXPORT_PRIVATE bool equal(const StringImpl*, const LChar*);
 inline bool equal(const StringImpl* a, const char* b) { return equal(a, reinterpret_cast<const LChar*>(b)); }
-bool equal(const StringImpl*, const LChar*, unsigned);
+WTF_EXPORT_PRIVATE bool equal(const StringImpl*, const LChar*, unsigned);
 inline bool equal(const StringImpl* a, const char* b, unsigned length) { return equal(a, reinterpret_cast<const LChar*>(b), length); }
 inline bool equal(const LChar* a, StringImpl* b) { return equal(b, a); }
 inline bool equal(const char* a, StringImpl* b) { return equal(b, reinterpret_cast<const LChar*>(a)); }
-bool equal(const StringImpl*, const UChar*, unsigned);
+WTF_EXPORT_PRIVATE bool equal(const StringImpl*, const UChar*, unsigned);
 
 // Do comparisons 8 or 4 bytes-at-a-time on architectures where it's safe.
 #if CPU(X86_64)
@@ -715,15 +715,15 @@ ALWAYS_INLINE bool equal(const UChar* a, const LChar* b, unsigned length)
     return true;
 }
 
-bool equalIgnoringCase(StringImpl*, StringImpl*);
-bool equalIgnoringCase(StringImpl*, const LChar*);
+WTF_EXPORT_PRIVATE bool equalIgnoringCase(StringImpl*, StringImpl*);
+WTF_EXPORT_PRIVATE bool equalIgnoringCase(StringImpl*, const LChar*);
 inline bool equalIgnoringCase(const LChar* a, StringImpl* b) { return equalIgnoringCase(b, a); }
-bool equalIgnoringCase(const UChar*, const LChar*, unsigned);
+WTF_EXPORT_PRIVATE bool equalIgnoringCase(const UChar*, const LChar*, unsigned);
 inline bool equalIgnoringCase(const UChar* a, const char* b, unsigned length) { return equalIgnoringCase(a, reinterpret_cast<const LChar*>(b), length); }
 inline bool equalIgnoringCase(const LChar* a, const UChar* b, unsigned length) { return equalIgnoringCase(b, a, length); }
 inline bool equalIgnoringCase(const char* a, const UChar* b, unsigned length) { return equalIgnoringCase(b, reinterpret_cast<const LChar*>(a), length); }
 
-bool equalIgnoringNullity(StringImpl*, StringImpl*);
+WTF_EXPORT_PRIVATE bool equalIgnoringNullity(StringImpl*, StringImpl*);
 
 template<size_t inlineCapacity>
 bool equalIgnoringNullity(const Vector<UChar, inlineCapacity>& a, StringImpl* b)
@@ -735,7 +735,7 @@ bool equalIgnoringNullity(const Vector<UChar, inlineCapacity>& a, StringImpl* b)
     return !memcmp(a.data(), b->characters(), b->length());
 }
 
-int codePointCompare(const StringImpl*, const StringImpl*);
+WTF_EXPORT_PRIVATE int codePointCompare(const StringImpl*, const StringImpl*);
 
 static inline bool isSpaceOrNewline(UChar c)
 {
index 3cecc0a..eb45c7f 100644 (file)
@@ -74,7 +74,7 @@ intptr_t charactersToIntPtrStrict(const LChar*, size_t, bool* ok = 0, int base =
 intptr_t charactersToIntPtrStrict(const UChar*, size_t, bool* ok = 0, int base = 10);
 
 int charactersToInt(const LChar*, size_t, bool* ok = 0); // ignores trailing garbage
-int charactersToInt(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
+WTF_EXPORT_PRIVATE int charactersToInt(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
 unsigned charactersToUInt(const LChar*, size_t, bool* ok = 0); // ignores trailing garbage
 unsigned charactersToUInt(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
 int64_t charactersToInt64(const LChar*, size_t, bool* ok = 0); // ignores trailing garbage
@@ -87,7 +87,7 @@ intptr_t charactersToIntPtr(const UChar*, size_t, bool* ok = 0); // ignores trai
 WTF_EXPORT_PRIVATE double charactersToDouble(const LChar*, size_t, bool* ok = 0, bool* didReadNumber = 0);
 WTF_EXPORT_PRIVATE double charactersToDouble(const UChar*, size_t, bool* ok = 0, bool* didReadNumber = 0);
 float charactersToFloat(const LChar*, size_t, bool* ok = 0, bool* didReadNumber = 0);
-float charactersToFloat(const UChar*, size_t, bool* ok = 0, bool* didReadNumber = 0);
+WTF_EXPORT_PRIVATE float charactersToFloat(const UChar*, size_t, bool* ok = 0, bool* didReadNumber = 0);
 
 enum FloatConversionFlags {
     ShouldRoundSignificantFigures = 1 << 0,
index 00ab16e..7994ff8 100644 (file)
@@ -45,13 +45,13 @@ namespace WTF {
     public:
         enum Result { Equal = 0, Greater = 1, Less = -1 };
 
-        Collator(const char* locale); // Parsing is lenient; e.g. language identifiers (such as "en-US") are accepted, too.
-        ~Collator();
-        void setOrderLowerFirst(bool);
+        WTF_EXPORT_PRIVATE Collator(const char* locale); // Parsing is lenient; e.g. language identifiers (such as "en-US") are accepted, too.
+        WTF_EXPORT_PRIVATE ~Collator();
+        WTF_EXPORT_PRIVATE void setOrderLowerFirst(bool);
 
         static PassOwnPtr<Collator> userDefault();
 
-        Result collate(const ::UChar*, size_t, const ::UChar*, size_t) const;
+        WTF_EXPORT_PRIVATE Result collate(const ::UChar*, size_t, const ::UChar*, size_t) const;
 
     private:
 #if USE(ICU_UNICODE) && !UCONFIG_NO_COLLATION
index bd3dd8a..bc2497b 100644 (file)
@@ -62,7 +62,7 @@ namespace Unicode {
     // to the replacement character; otherwise (when the flag is set to strict)
     // they constitute an error.
 
-    ConversionResult convertUTF8ToUTF16(
+    WTF_EXPORT_PRIVATE ConversionResult convertUTF8ToUTF16(
                     const char** sourceStart, const char* sourceEnd, 
                     UChar** targetStart, UChar* targetEnd, bool strict = true);
 
@@ -70,7 +70,7 @@ namespace Unicode {
                     const LChar** sourceStart, const LChar* sourceEnd, 
                     char** targetStart, char* targetEnd);
 
-    ConversionResult convertUTF16ToUTF8(
+    WTF_EXPORT_PRIVATE ConversionResult convertUTF16ToUTF8(
                     const UChar** sourceStart, const UChar* sourceEnd, 
                     char** targetStart, char* targetEnd, bool strict = true);
 
index 501afac..3495fc7 100644 (file)
@@ -62,8 +62,8 @@ enum YarrCharSize {
     Char16
 };
 
-PassOwnPtr<BytecodePattern> byteCompile(YarrPattern&, BumpPointerAllocator*);
-int interpret(BytecodePattern*, const UString& input, unsigned start, unsigned length, int* output);
+JS_EXPORT_PRIVATE PassOwnPtr<BytecodePattern> byteCompile(YarrPattern&, BumpPointerAllocator*);
+JS_EXPORT_PRIVATE int interpret(BytecodePattern*, const UString& input, unsigned start, unsigned length, int* output);
 
 } } // namespace JSC::Yarr
 
index 2cbb795..a31deee 100644 (file)
@@ -316,7 +316,7 @@ struct TermChain {
 };
 
 struct YarrPattern {
-    YarrPattern(const UString& pattern, bool ignoreCase, bool multiline, const char** error);
+    JS_EXPORT_PRIVATE YarrPattern(const UString& pattern, bool ignoreCase, bool multiline, const char** error);
 
     ~YarrPattern()
     {