Changeset 104900 in webkit


Ignore:
Timestamp:
Jan 12, 2012 11:23:44 PM (12 years ago)
Author:
morrita@google.com
Message:

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:
Location:
trunk/Source/JavaScriptCore
Files:
88 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/JavaScriptCore/API/OpaqueJSString.h

    r98316 r104900  
    4747    }
    4848
    49     static PassRefPtr<OpaqueJSString> create(const JSC::UString&);
     49    JS_EXPORT_PRIVATE static PassRefPtr<OpaqueJSString> create(const JSC::UString&);
    5050
    5151    UChar* characters() { return this ? m_characters : 0; }

  • trunk/Source/JavaScriptCore/ChangeLog

    r104899 r104900  
     12012-01-12  Hajime Morrita  <morrita@chromium.org>
     2
     3        JavaScriptCore: Mark all exported symbols in the header file automatically.
     4        https://bugs.webkit.org/show_bug.cgi?id=72855
     5
     6        Reviewed by Darin Adler.
     7
     8        Added WTF_EXPORT_PRIVATE and JS_EXPORT_PRIVATE based on JavaScriptCore.exp files.
     9        The change is generated by a tool calledListExportables (https://github.com/omo/ListExportables)
     10
     11        * API/OpaqueJSString.h:
     12        * bytecode/CodeBlock.h:
     13        * bytecode/SamplingTool.h:
     14        * debugger/Debugger.h:
     15        * debugger/DebuggerActivation.h:
     16        * debugger/DebuggerCallFrame.h:
     17        * heap/AllocationSpace.h:
     18        * heap/HandleHeap.h:
     19        * heap/Heap.h:
     20        * heap/MachineStackMarker.h:
     21        * heap/MarkStack.h:
     22        * heap/VTableSpectrum.h:
     23        * heap/WriteBarrierSupport.h:
     24        * parser/Nodes.h:
     25        * parser/ParserArena.h:
     26        * profiler/Profile.h:
     27        * runtime/ArgList.h:
     28        * runtime/CallData.h:
     29        * runtime/Completion.h:
     30        * runtime/ConstructData.h:
     31        * runtime/DateInstance.h:
     32        * runtime/Error.h:
     33        * runtime/ExceptionHelpers.h:
     34        * runtime/FunctionConstructor.h:
     35        * runtime/Identifier.h:
     36        * runtime/InitializeThreading.h:
     37        * runtime/InternalFunction.h:
     38        * runtime/JSArray.h:
     39        * runtime/JSByteArray.h:
     40        * runtime/JSCell.h:
     41        * runtime/JSFunction.h:
     42        * runtime/JSGlobalData.cpp:
     43        * runtime/JSGlobalData.h:
     44        * runtime/JSGlobalObject.h:
     45        * runtime/JSGlobalThis.h:
     46        * runtime/JSLock.h:
     47        * runtime/JSObject.h:
     48        * runtime/JSString.h:
     49        * runtime/JSValue.h:
     50        * runtime/JSVariableObject.h:
     51        * runtime/Lookup.h:
     52        * runtime/MemoryStatistics.h:
     53        * runtime/ObjectPrototype.h:
     54        * runtime/Options.h:
     55        * runtime/PropertyDescriptor.h:
     56        * runtime/PropertyNameArray.h:
     57        * runtime/PropertySlot.h:
     58        * runtime/RegExp.h:
     59        * runtime/RegExpObject.h:
     60        * runtime/SamplingCounter.h:
     61        * runtime/SmallStrings.h:
     62        * runtime/StringObject.h:
     63        * runtime/Structure.h:
     64        * runtime/TimeoutChecker.h:
     65        * runtime/UString.h:
     66        * runtime/WriteBarrier.h:
     67        * wtf/ArrayBufferView.h:
     68        * wtf/ByteArray.h:
     69        * wtf/CryptographicallyRandomNumber.h:
     70        * wtf/CurrentTime.h:
     71        * wtf/DateMath.h:
     72        * wtf/DecimalNumber.h:
     73        * wtf/FastMalloc.cpp:
     74        * wtf/FastMalloc.h:
     75        * wtf/MD5.h:
     76        * wtf/MainThread.h:
     77        * wtf/MetaAllocator.h:
     78        * wtf/MetaAllocatorHandle.h:
     79        * wtf/OSAllocator.h:
     80        * wtf/PageBlock.h:
     81        * wtf/RandomNumber.h:
     82        * wtf/RefCountedLeakCounter.h:
     83        * wtf/SHA1.h:
     84        * wtf/Threading.cpp:
     85        * wtf/Threading.h:
     86        * wtf/ThreadingPrimitives.h:
     87        * wtf/WTFThreadData.h:
     88        * wtf/dtoa.h:
     89        * wtf/text/AtomicString.h:
     90        * wtf/text/CString.h:
     91        * wtf/text/StringBuilder.h:
     92        * wtf/text/StringImpl.h:
     93        * wtf/text/WTFString.h:
     94        * wtf/unicode/Collator.h:
     95        * wtf/unicode/UTF8.h:
     96        * yarr/Yarr.h:
     97        * yarr/YarrPattern.h:
     98
    1992012-01-12  MORITA Hajime  <morrita@google.com>
    2100

  • trunk/Source/JavaScriptCore/bytecode/CodeBlock.h

    r104787 r104900  
    9595
    9696    public:
    97         virtual ~CodeBlock();
     97        JS_EXPORT_PRIVATE virtual ~CodeBlock();
    9898       
    9999        int numParameters() const { return m_numParameters; }

  • trunk/Source/JavaScriptCore/bytecode/SamplingTool.h

    r101946 r104900  
    4646    class SamplingFlags {
    4747    public:
    48         static void start();
    49         static void stop();
     48        JS_EXPORT_PRIVATE static void start();
     49        JS_EXPORT_PRIVATE static void stop();
    5050
    5151#if ENABLE(SAMPLING_FLAGS)
    … …  
    9090#endif
    9191    private:
    92         static uint32_t s_flags;
     92        JS_EXPORTDATA static uint32_t s_flags;
    9393#if ENABLE(SAMPLING_FLAGS)
    9494        static uint64_t s_flagCounts[33];
    … …  
    175175    public:
    176176        SamplingRegion(const char*) { }
    177         void dump();
     177        JS_EXPORT_PRIVATE void dump();
    178178    };
    179179#endif // ENABLE(SAMPLING_REGIONS)
    … …  
    221221        static ThreadIdentifier s_samplingThread;
    222222
    223         static void start(unsigned hertz=10000);
    224         static void stop();
     223        JS_EXPORT_PRIVATE static void start(unsigned hertz=10000);
     224        JS_EXPORT_PRIVATE static void stop();
    225225
    226226        static void* threadStartFunc(void*);
    … …  
    295295        }
    296296
    297         void setup();
     297        JS_EXPORT_PRIVATE void setup();
    298298        void dump(ExecState*);
    299299

  • trunk/Source/JavaScriptCore/debugger/Debugger.h

    r88370 r104900  
    5959
    6060    // This function exists only for backwards compatibility with existing WebScriptDebugger clients.
    61     JSValue evaluateInGlobalCallFrame(const UString&, JSValue& exception, JSGlobalObject*);
     61    JS_EXPORT_PRIVATE JSValue evaluateInGlobalCallFrame(const UString&, JSValue& exception, JSGlobalObject*);
    6262
    6363} // namespace JSC

  • trunk/Source/JavaScriptCore/debugger/DebuggerActivation.h

    r104899 r104900  
    5353        static void defineSetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* setterFunction, unsigned attributes);
    5454
    55         static const ClassInfo s_info;
     55        JS_EXPORTDATA static const ClassInfo s_info;
    5656
    5757        static Structure* createStructure(JSGlobalData& globalData, JSGlobalObject* globalObject, JSValue prototype)
    … …  
    6363        static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesVisitChildren | JSObject::StructureFlags;
    6464
    65         void finishCreation(JSGlobalData&, JSObject* activation);
     65        JS_EXPORT_PRIVATE void finishCreation(JSGlobalData&, JSObject* activation);
    6666
    6767    private:
    68         DebuggerActivation(JSGlobalData&);
     68        JS_EXPORT_PRIVATE DebuggerActivation(JSGlobalData&);
    6969        WriteBarrier<JSActivation> m_activation;
    7070    };

  • trunk/Source/JavaScriptCore/debugger/DebuggerCallFrame.h

    r95901 r104900  
    5151        JSGlobalObject* dynamicGlobalObject() const { return m_callFrame->dynamicGlobalObject(); }
    5252        ScopeChainNode* scopeChain() const { return m_callFrame->scopeChain(); }
    53         const UString* functionName() const;
     53        JS_EXPORT_PRIVATE const UString* functionName() const;
    5454        JS_EXPORT_PRIVATE UString calculatedFunctionName() const;
    5555        JS_EXPORT_PRIVATE Type type() const;

  • trunk/Source/JavaScriptCore/heap/AllocationSpace.h

    r96373 r104900  
    7373    void* allocate(MarkedSpace::SizeClass&);
    7474    void* tryAllocate(MarkedSpace::SizeClass&);
    75     void* allocateSlowCase(MarkedSpace::SizeClass&);
     75    JS_EXPORT_PRIVATE void* allocateSlowCase(MarkedSpace::SizeClass&);
    7676    MarkedBlock* allocateBlock(size_t cellSize, AllocationEffort);
    7777   

  • trunk/Source/JavaScriptCore/heap/HandleHeap.h

    r103243 r104900  
    4141class SlotVisitor;
    4242
    43 class WeakHandleOwner {
     43class JS_EXPORT_PRIVATE WeakHandleOwner {
    4444public:
    4545    virtual ~WeakHandleOwner();
    … …  
    6666    void finalizeWeakHandles();
    6767
    68     void writeBarrier(HandleSlot, const JSValue&);
     68    JS_EXPORT_PRIVATE void writeBarrier(HandleSlot, const JSValue&);
    6969
    7070#if !ASSERT_DISABLED
    … …  
    112112    static Node* toNode(HandleSlot);
    113113
    114     void grow();
     114    JS_EXPORT_PRIVATE void grow();
    115115   
    116116#if ENABLE(GC_VALIDATION) || !ASSERT_DISABLED

  • trunk/Source/JavaScriptCore/heap/Heap.h

    r100556 r104900  
    7979        Heap(JSGlobalData*, HeapSize);
    8080        ~Heap();
    81         void destroy(); // JSGlobalData must call destroy() before ~Heap().
     81        JS_EXPORT_PRIVATE void destroy(); // JSGlobalData must call destroy() before ~Heap().
    8282
    8383        JSGlobalData* globalData() const { return m_globalData; }
    … …  
    8585        MachineThreads& machineThreads() { return m_machineThreads; }
    8686
    87         GCActivityCallback* activityCallback();
    88         void setActivityCallback(PassOwnPtr<GCActivityCallback>);
     87        JS_EXPORT_PRIVATE GCActivityCallback* activityCallback();
     88        JS_EXPORT_PRIVATE void setActivityCallback(PassOwnPtr<GCActivityCallback>);
    8989
    9090        // true if an allocation or collection is in progress
    … …  
    9595
    9696        typedef void (*Finalizer)(JSCell*);
    97         void addFinalizer(JSCell*, Finalizer);
     97        JS_EXPORT_PRIVATE void addFinalizer(JSCell*, Finalizer);
    9898
    9999        void notifyIsSafeToCollect() { m_isSafeToCollect = true; }
    100         void collectAllGarbage();
     100        JS_EXPORT_PRIVATE void collectAllGarbage();
    101101
    102102        void reportExtraMemoryCost(size_t cost);
    103103
    104         void protect(JSValue);
    105         bool unprotect(JSValue); // True when the protect count drops to 0.
     104        JS_EXPORT_PRIVATE void protect(JSValue);
     105        JS_EXPORT_PRIVATE bool unprotect(JSValue); // True when the protect count drops to 0.
    106106       
    107107        void jettisonDFGCodeBlock(PassOwnPtr<CodeBlock>);
    108108
    109         size_t size();
    110         size_t capacity();
    111         size_t objectCount();
    112         size_t globalObjectCount();
    113         size_t protectedObjectCount();
    114         size_t protectedGlobalObjectCount();
    115         PassOwnPtr<TypeCountSet> protectedObjectTypeCounts();
    116         PassOwnPtr<TypeCountSet> objectTypeCounts();
     109        JS_EXPORT_PRIVATE size_t size();
     110        JS_EXPORT_PRIVATE size_t capacity();
     111        JS_EXPORT_PRIVATE size_t objectCount();
     112        JS_EXPORT_PRIVATE size_t globalObjectCount();
     113        JS_EXPORT_PRIVATE size_t protectedObjectCount();
     114        JS_EXPORT_PRIVATE size_t protectedGlobalObjectCount();
     115        JS_EXPORT_PRIVATE PassOwnPtr<TypeCountSet> protectedObjectTypeCounts();
     116        JS_EXPORT_PRIVATE PassOwnPtr<TypeCountSet> objectTypeCounts();
    117117
    118118        void pushTempSortVector(Vector<ValueStringPair>*);
    … …  
    142142        };
    143143
    144         bool isValidAllocation(size_t);
    145         void reportExtraMemoryCostSlowCase(size_t);
     144        JS_EXPORT_PRIVATE bool isValidAllocation(size_t);
     145        JS_EXPORT_PRIVATE void reportExtraMemoryCostSlowCase(size_t);
    146146
    147147        // Call this function before any operation that needs to know which cells

  • trunk/Source/JavaScriptCore/heap/MachineStackMarker.h

    r95510 r104900  
    4141
    4242        void makeUsableFromMultipleThreads();
    43         void addCurrentThread(); // Only needs to be called by clients that can use the same heap from multiple threads.
     43        JS_EXPORT_PRIVATE void addCurrentThread(); // Only needs to be called by clients that can use the same heap from multiple threads.
    4444
    4545    private:

  • trunk/Source/JavaScriptCore/heap/MarkStack.h

    r103083 r104900  
    112112        MarkStackSegment* m_topSegment;
    113113       
    114         void expand();
     114        JS_EXPORT_PRIVATE void expand();
    115115       
    116116        MarkStackSegmentAllocator& m_allocator;
    … …  
    242242
    243243    protected:
    244         static void validate(JSCell*);
     244        JS_EXPORT_PRIVATE static void validate(JSCell*);
    245245
    246246        void append(JSValue*);
    … …  
    251251        void internalAppend(JSValue);
    252252       
    253         void mergeOpaqueRoots();
     253        JS_EXPORT_PRIVATE void mergeOpaqueRoots();
    254254       
    255255        void mergeOpaqueRootsIfNecessary()

  • trunk/Source/JavaScriptCore/heap/VTableSpectrum.h

    r99382 r104900  
    4040   
    4141    void countVPtr(void*);
    42     void count(JSCell*);
     42    JS_EXPORT_PRIVATE void count(JSCell*);
    4343   
    4444    void dump(FILE* output, const char* comment);

  • trunk/Source/JavaScriptCore/heap/WriteBarrierSupport.h

    r95901 r104900  
    8282#else
    8383    // These are necessary to work around not having conditional exports.
    84     static char usesWithBarrierFromCpp;
    85     static char usesWithoutBarrierFromCpp;
     84    JS_EXPORTDATA static char usesWithBarrierFromCpp;
     85    JS_EXPORTDATA static char usesWithoutBarrierFromCpp;
    8686#endif // ENABLE(WRITE_BARRIER_PROFILING)
    8787

  • trunk/Source/JavaScriptCore/parser/Nodes.h

    r98887 r104900  
    182182
    183183    public:
    184         void setLoc(int firstLine, int lastLine);
     184        JS_EXPORT_PRIVATE void setLoc(int firstLine, int lastLine);
    185185        int firstLine() const { return lineNo(); }
    186186        int lastLine() const { return m_lastLine; }

  • trunk/Source/JavaScriptCore/parser/ParserArena.h

    r99436 r104900  
    160160
    161161        bool isEmpty() const;
    162         void reset();
     162        JS_EXPORT_PRIVATE void reset();
    163163
    164164        IdentifierArena& identifierArena() { return *m_identifierArena; }

  • trunk/Source/JavaScriptCore/profiler/Profile.h

    r95901 r104900  
    4545        unsigned int uid() const { return m_uid; }
    4646
    47         void forEach(void (ProfileNode::*)());
     47        JS_EXPORT_PRIVATE void forEach(void (ProfileNode::*)());
    4848
    49         void focus(const ProfileNode*);
    50         void exclude(const ProfileNode*);
    51         void restoreAll();
     49        JS_EXPORT_PRIVATE void focus(const ProfileNode*);
     50        JS_EXPORT_PRIVATE void exclude(const ProfileNode*);
     51        JS_EXPORT_PRIVATE void restoreAll();
    5252
    5353#ifndef NDEBUG

  • trunk/Source/JavaScriptCore/runtime/ArgList.h

    r102728 r104900  
    103103
    104104    private:
    105         void slowAppend(JSValue);
     105        JS_EXPORT_PRIVATE void slowAppend(JSValue);
    106106       
    107107        EncodedJSValue& slotFor(int item) const
    … …  
    172172        size_t size() const { return m_argCount; }
    173173       
    174         void getSlice(int startIndex, ArgList& result) const;
     174        JS_EXPORT_PRIVATE void getSlice(int startIndex, ArgList& result) const;
    175175
    176176    private:

  • trunk/Source/JavaScriptCore/runtime/CallData.h

    r95901 r104900  
    5858    };
    5959
    60     JSValue call(ExecState*, JSValue functionObject, CallType, const CallData&, JSValue thisValue, const ArgList&);
     60    JS_EXPORT_PRIVATE JSValue call(ExecState*, JSValue functionObject, CallType, const CallData&, JSValue thisValue, const ArgList&);
    6161
    6262} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/Completion.h

    r94811 r104900  
    3232    class SourceCode;
    3333
    34     bool checkSyntax(ExecState*, const SourceCode&, JSValue* exception = 0);
    35     JSValue evaluate(ExecState*, ScopeChainNode*, const SourceCode&, JSValue thisValue = JSValue(), JSValue* exception = 0);
     34    JS_EXPORT_PRIVATE bool checkSyntax(ExecState*, const SourceCode&, JSValue* exception = 0);
     35    JS_EXPORT_PRIVATE JSValue evaluate(ExecState*, ScopeChainNode*, const SourceCode&, JSValue thisValue = JSValue(), JSValue* exception = 0);
    3636
    3737} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/ConstructData.h

    r95901 r104900  
    5757    };
    5858
    59     JSObject* construct(ExecState*, JSValue constructor, ConstructType, const ConstructData&, const ArgList&);
     59    JS_EXPORT_PRIVATE JSObject* construct(ExecState*, JSValue constructor, ConstructType, const ConstructData&, const ArgList&);
    6060
    6161} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/DateInstance.h

    r103243 r104900  
    3232    class DateInstance : public JSWrapperObject {
    3333    protected:
    34         DateInstance(ExecState*, Structure*);
     34        JS_EXPORT_PRIVATE DateInstance(ExecState*, Structure*);
    3535        void finishCreation(JSGlobalData&);
    36         void finishCreation(JSGlobalData&, double);
     36        JS_EXPORT_PRIVATE void finishCreation(JSGlobalData&, double);
    3737
    3838        static void destroy(JSCell*);

  • trunk/Source/JavaScriptCore/runtime/Error.h

    r103958 r104900  
    4747    JSObject* createURIError(JSGlobalObject*, const UString&);
    4848    // ExecState wrappers.
    49     JSObject* createError(ExecState*, const UString&);
     49    JS_EXPORT_PRIVATE JSObject* createError(ExecState*, const UString&);
    5050    JSObject* createEvalError(ExecState*, const UString&);
    51     JSObject* createRangeError(ExecState*, const UString&);
    52     JSObject* createReferenceError(ExecState*, const UString&);
    53     JSObject* createSyntaxError(ExecState*, const UString&);
    54     JSObject* createTypeError(ExecState*, const UString&);
     51    JS_EXPORT_PRIVATE JSObject* createRangeError(ExecState*, const UString&);
     52    JS_EXPORT_PRIVATE JSObject* createReferenceError(ExecState*, const UString&);
     53    JS_EXPORT_PRIVATE JSObject* createSyntaxError(ExecState*, const UString&);
     54    JS_EXPORT_PRIVATE JSObject* createTypeError(ExecState*, const UString&);
    5555    JSObject* createURIError(ExecState*, const UString&);
    5656
    … …  
    6262
    6363    // Methods to throw Errors.
    64     JSValue throwError(ExecState*, JSValue);
    65     JSObject* throwError(ExecState*, JSObject*);
     64    JS_EXPORT_PRIVATE JSValue throwError(ExecState*, JSValue);
     65    JS_EXPORT_PRIVATE JSObject* throwError(ExecState*, JSObject*);
    6666
    6767    // Convenience wrappers, create an throw an exception with a default message.
    68     JSObject* throwTypeError(ExecState*);
    69     JSObject* throwSyntaxError(ExecState*);
     68    JS_EXPORT_PRIVATE JSObject* throwTypeError(ExecState*);
     69    JS_EXPORT_PRIVATE JSObject* throwSyntaxError(ExecState*);
    7070
    7171    // Convenience wrappers, wrap result as an EncodedJSValue.

  • trunk/Source/JavaScriptCore/runtime/ExceptionHelpers.h

    r103243 r104900  
    3434namespace JSC {
    3535
    36 JSObject* createInterruptedExecutionException(JSGlobalData*);
     36JS_EXPORT_PRIVATE JSObject* createInterruptedExecutionException(JSGlobalData*);
    3737bool isInterruptedExecutionException(JSObject*);
    3838bool isInterruptedExecutionException(JSValue);
    … …  
    4040JSObject* createTerminatedExecutionException(JSGlobalData*);
    4141bool isTerminatedExecutionException(JSObject*);
    42 bool isTerminatedExecutionException(JSValue);
     42JS_EXPORT_PRIVATE bool isTerminatedExecutionException(JSValue);
    4343
    44 JSObject* createStackOverflowError(ExecState*);
     44JS_EXPORT_PRIVATE JSObject* createStackOverflowError(ExecState*);
    4545JSObject* createStackOverflowError(JSGlobalObject*);
    4646JSObject* createOutOfMemoryError(JSGlobalObject*);

  • trunk/Source/JavaScriptCore/runtime/FunctionConstructor.h

    r103243 r104900  
    6060    JSObject* constructFunction(ExecState*, JSGlobalObject*, const ArgList&);
    6161
    62     JSObject* constructFunctionSkippingEvalEnabledCheck(ExecState*, JSGlobalObject*, const ArgList&, const Identifier&, const UString&, const WTF::TextPosition&);
     62    JS_EXPORT_PRIVATE JSObject* constructFunctionSkippingEvalEnabledCheck(ExecState*, JSGlobalObject*, const ArgList&, const Identifier&, const UString&, const WTF::TextPosition&);
    6363
    6464} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/Identifier.h

    r100510 r104900  
    5757        static Identifier createLCharFromUChar(JSGlobalData* globalData, const UChar* s, int length) { return Identifier(globalData, add8(globalData, s, length)); }
    5858
    59         static Identifier from(ExecState* exec, unsigned y);
    60         static Identifier from(ExecState* exec, int y);
     59        JS_EXPORT_PRIVATE static Identifier from(ExecState* exec, unsigned y);
     60        JS_EXPORT_PRIVATE static Identifier from(ExecState* exec, int y);
    6161        static Identifier from(ExecState* exec, double y);
    6262        static Identifier from(JSGlobalData*, unsigned y);
    … …  
    6464        static Identifier from(JSGlobalData*, double y);
    6565
    66         static uint32_t toUInt32(const UString&, bool& ok);
     66        JS_EXPORT_PRIVATE static uint32_t toUInt32(const UString&, bool& ok);
    6767        uint32_t toUInt32(bool& ok) const { return toUInt32(m_string, ok); }
    6868        unsigned toArrayIndex(bool& ok) const;
    … …  
    8585        static bool equal(const StringImpl* a, const StringImpl* b) { return ::equal(a, b); }
    8686
    87         static PassRefPtr<StringImpl> add(ExecState*, const char*); // Only to be used with string literals.
     87        JS_EXPORT_PRIVATE static PassRefPtr<StringImpl> add(ExecState*, const char*); // Only to be used with string literals.
    8888        static PassRefPtr<StringImpl> add(JSGlobalData*, const char*); // Only to be used with string literals.
    8989
    … …  
    120120        }
    121121
    122         static PassRefPtr<StringImpl> addSlowCase(ExecState*, StringImpl* r);
    123         static PassRefPtr<StringImpl> addSlowCase(JSGlobalData*, StringImpl* r);
    124 
    125         static void checkCurrentIdentifierTable(ExecState*);
    126         static void checkCurrentIdentifierTable(JSGlobalData*);
     122        JS_EXPORT_PRIVATE static PassRefPtr<StringImpl> addSlowCase(ExecState*, StringImpl* r);
     123        JS_EXPORT_PRIVATE static PassRefPtr<StringImpl> addSlowCase(JSGlobalData*, StringImpl* r);
     124
     125        JS_EXPORT_PRIVATE static void checkCurrentIdentifierTable(ExecState*);
     126        JS_EXPORT_PRIVATE static void checkCurrentIdentifierTable(JSGlobalData*);
    127127    };
    128128

  • trunk/Source/JavaScriptCore/runtime/InitializeThreading.h

    r44224 r104900  
    3434    // This function must be called from the main thread. It is safe to call it repeatedly.
    3535    // Darwin is an exception to this rule: it is OK to call this function from any thread, even reentrantly.
    36     void initializeThreading();
     36    JS_EXPORT_PRIVATE void initializeThreading();
    3737
    3838}

  • trunk/Source/JavaScriptCore/runtime/InternalFunction.h

    r103083 r104900  
    3838        static JS_EXPORTDATA const ClassInfo s_info;
    3939
    40         const UString& name(ExecState*);
     40        JS_EXPORT_PRIVATE const UString& name(ExecState*);
    4141        const UString displayName(ExecState*);
    4242        const UString calculatedDisplayName(ExecState*);
    … …  
    5050        static const unsigned StructureFlags = ImplementsHasInstance | JSObject::StructureFlags;
    5151
    52         InternalFunction(JSGlobalObject*, Structure*);
     52        JS_EXPORT_PRIVATE InternalFunction(JSGlobalObject*, Structure*);
    5353
    54         void finishCreation(JSGlobalData&, const Identifier& name);
     54        JS_EXPORT_PRIVATE void finishCreation(JSGlobalData&, const Identifier& name);
    5555
    5656        static CallType getCallData(JSCell*, CallData&);

  • trunk/Source/JavaScriptCore/runtime/JSArray.h

    r104604 r104900  
    128128
    129129    protected:
    130         explicit JSArray(JSGlobalData&, Structure*);
    131 
    132         void finishCreation(JSGlobalData&, unsigned initialLength = 0);
    133         JSArray* tryFinishCreationUninitialized(JSGlobalData&, unsigned initialLength);
     130        JS_EXPORT_PRIVATE explicit JSArray(JSGlobalData&, Structure*);
     131
     132        JS_EXPORT_PRIVATE void finishCreation(JSGlobalData&, unsigned initialLength = 0);
     133        JS_EXPORT_PRIVATE JSArray* tryFinishCreationUninitialized(JSGlobalData&, unsigned initialLength);
    134134   
    135135    public:
    136136        typedef JSNonFinalObject Base;
    137137
    138         ~JSArray();
    139         static void destroy(JSCell*);
     138        JS_EXPORT_PRIVATE ~JSArray();
     139        JS_EXPORT_PRIVATE static void destroy(JSCell*);
    140140
    141141        static JSArray* create(JSGlobalData& globalData, Structure* structure, unsigned initialLength = 0)
    … …  
    157157        }
    158158
    159         static bool defineOwnProperty(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&, bool throwException);
     159        JS_EXPORT_PRIVATE static bool defineOwnProperty(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&, bool throwException);
    160160
    161161        static bool getOwnPropertySlot(JSCell*, ExecState*, const Identifier&, PropertySlot&);
    162         static bool getOwnPropertySlotByIndex(JSCell*, ExecState*, unsigned propertyName, PropertySlot&);
     162        JS_EXPORT_PRIVATE static bool getOwnPropertySlotByIndex(JSCell*, ExecState*, unsigned propertyName, PropertySlot&);
    163163        static bool getOwnPropertyDescriptor(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&);
    164164        static void putByIndex(JSCell*, ExecState*, unsigned propertyName, JSValue);
    … …  
    255255        }
    256256
    257         static void visitChildren(JSCell*, SlotVisitor&);
     257        JS_EXPORT_PRIVATE static void visitChildren(JSCell*, SlotVisitor&);
    258258
    259259    protected:
    … …  
    265265        static void getOwnPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
    266266
    267         void* subclassData() const;
    268         void setSubclassData(void*);
     267        JS_EXPORT_PRIVATE void* subclassData() const;
     268        JS_EXPORT_PRIVATE void setSubclassData(void*);
    269269
    270270    private:

  • trunk/Source/JavaScriptCore/runtime/JSByteArray.h

    r103243 r104900  
    7777
    7878    private:
    79         JSByteArray(ExecState*, Structure*, ByteArray* storage);
     79        JS_EXPORT_PRIVATE JSByteArray(ExecState*, Structure*, ByteArray* storage);
    8080       
    8181    public:
    … …  
    8787        }
    8888
    89         static Structure* createStructure(JSGlobalData&, JSGlobalObject*, JSValue prototype, const JSC::ClassInfo* = &s_info);
     89        JS_EXPORT_PRIVATE static Structure* createStructure(JSGlobalData&, JSGlobalObject*, JSValue prototype, const JSC::ClassInfo* = &s_info);
    9090
    91         static bool getOwnPropertySlot(JSC::JSCell*, JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertySlot&);
    92         static bool getOwnPropertySlotByIndex(JSC::JSCell*, JSC::ExecState*, unsigned propertyName, JSC::PropertySlot&);
    93         static bool getOwnPropertyDescriptor(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&);
    94         static void put(JSC::JSCell*, JSC::ExecState*, const JSC::Identifier& propertyName, JSC::JSValue, JSC::PutPropertySlot&);
    95         static void putByIndex(JSC::JSCell*, JSC::ExecState*, unsigned propertyName, JSC::JSValue);
     91        JS_EXPORT_PRIVATE static bool getOwnPropertySlot(JSC::JSCell*, JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertySlot&);
     92        JS_EXPORT_PRIVATE static bool getOwnPropertySlotByIndex(JSC::JSCell*, JSC::ExecState*, unsigned propertyName, JSC::PropertySlot&);
     93        JS_EXPORT_PRIVATE static bool getOwnPropertyDescriptor(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&);
     94        JS_EXPORT_PRIVATE static void put(JSC::JSCell*, JSC::ExecState*, const JSC::Identifier& propertyName, JSC::JSValue, JSC::PutPropertySlot&);
     95        JS_EXPORT_PRIVATE static void putByIndex(JSC::JSCell*, JSC::ExecState*, unsigned propertyName, JSC::JSValue);
    9696
    97         static void getOwnPropertyNames(JSC::JSObject*, JSC::ExecState*, JSC::PropertyNameArray&, EnumerationMode);
     97        JS_EXPORT_PRIVATE static void getOwnPropertyNames(JSC::JSObject*, JSC::ExecState*, JSC::PropertyNameArray&, EnumerationMode);
    9898
    9999        static JS_EXPORTDATA const ClassInfo s_info;
    … …  
    104104
    105105        ~JSByteArray();
    106         static void destroy(JSCell*);
     106        JS_EXPORT_PRIVATE static void destroy(JSCell*);
    107107
    108108        static size_t offsetOfStorage() { return OBJECT_OFFSETOF(JSByteArray, m_storage); }

  • trunk/Source/JavaScriptCore/runtime/JSCell.h

    r104899 r104900  
    6868    protected:
    6969        JSCell(JSGlobalData&, Structure*);
    70         static void destroy(JSCell*);
     70        JS_EXPORT_PRIVATE static void destroy(JSCell*);
    7171
    7272    public:
    … …  
    8383
    8484        // Extracting the value.
    85         bool getString(ExecState* exec, UString&) const;
    86         UString getString(ExecState* exec) const; // null string if not a string
    87         JSObject* getObject(); // NULL if not an object
     85        JS_EXPORT_PRIVATE bool getString(ExecState* exec, UString&) const;
     86        JS_EXPORT_PRIVATE UString getString(ExecState* exec) const; // null string if not a string
     87        JS_EXPORT_PRIVATE JSObject* getObject(); // NULL if not an object
    8888        const JSObject* getObject() const; // NULL if not an object
    8989       
    90         static CallType getCallData(JSCell*, CallData&);
    91         static ConstructType getConstructData(JSCell*, ConstructData&);
     90        JS_EXPORT_PRIVATE static CallType getCallData(JSCell*, CallData&);
     91        JS_EXPORT_PRIVATE static ConstructType getConstructData(JSCell*, ConstructData&);
    9292
    9393        // Basic conversions.
    94         JSValue toPrimitive(ExecState*, PreferredPrimitiveType) const;
     94        JS_EXPORT_PRIVATE JSValue toPrimitive(ExecState*, PreferredPrimitiveType) const;
    9595        bool getPrimitiveNumber(ExecState*, double& number, JSValue&) const;
    9696        bool toBoolean(ExecState*) const;
    97         double toNumber(ExecState*) const;
    98         UString toString(ExecState*) const;
    99         JSObject* toObject(ExecState*, JSGlobalObject*) const;
     97        JS_EXPORT_PRIVATE double toNumber(ExecState*) const;
     98        JS_EXPORT_PRIVATE UString toString(ExecState*) const;
     99        JS_EXPORT_PRIVATE JSObject* toObject(ExecState*, JSGlobalObject*) const;
    100100
    101101        static void visitChildren(JSCell*, SlotVisitor&);

  • trunk/Source/JavaScriptCore/runtime/JSFunction.h

    r103958 r104900  
    4141    }
    4242
    43     EncodedJSValue JSC_HOST_CALL callHostFunctionAsConstructor(ExecState*);
     43    JS_EXPORT_PRIVATE EncodedJSValue JSC_HOST_CALL callHostFunctionAsConstructor(ExecState*);
    4444
    4545    class JSFunction : public JSNonFinalObject {
    … …  
    5252        typedef JSNonFinalObject Base;
    5353
    54         static JSFunction* create(ExecState*, JSGlobalObject*, int length, const Identifier& name, NativeFunction nativeFunction, NativeFunction nativeConstructor = callHostFunctionAsConstructor);
     54        JS_EXPORT_PRIVATE static JSFunction* create(ExecState*, JSGlobalObject*, int length, const Identifier& name, NativeFunction nativeFunction, NativeFunction nativeConstructor = callHostFunctionAsConstructor);
    5555        static JSFunction* create(ExecState*, JSGlobalObject*, int length, const Identifier& name, NativeExecutable* nativeExecutable);
    5656
    … …  
    6565        static void destroy(JSCell*);
    6666
    67         const UString& name(ExecState*);
     67        JS_EXPORT_PRIVATE const UString& name(ExecState*);
    6868        const UString displayName(ExecState*);
    6969        const UString calculatedDisplayName(ExecState*);
    … …  
    9595        FunctionExecutable* jsExecutable() const;
    9696
    97         const SourceCode* sourceCode() const;
     97        JS_EXPORT_PRIVATE const SourceCode* sourceCode() const;
    9898
    9999        static JS_EXPORTDATA const ClassInfo s_info;
    … …  
    124124        const static unsigned StructureFlags = OverridesGetOwnPropertySlot | ImplementsHasInstance | OverridesVisitChildren | OverridesGetPropertyNames | JSObject::StructureFlags;
    125125
    126         JSFunction(ExecState*, JSGlobalObject*, Structure*);
     126        JS_EXPORT_PRIVATE JSFunction(ExecState*, JSGlobalObject*, Structure*);
    127127        JSFunction(ExecState*, FunctionExecutable*, ScopeChainNode*);
    128128       
    … …  
    141141
    142142    private:
    143         bool isHostFunctionNonInline() const;
     143        JS_EXPORT_PRIVATE bool isHostFunctionNonInline() const;
    144144
    145145        static JSValue argumentsGetter(ExecState*, JSValue, const Identifier&);

  • trunk/Source/JavaScriptCore/runtime/JSGlobalData.cpp

    r103364 r104900  
    102102extern const HashTable numberConstructorTable;
    103103extern const HashTable numberPrototypeTable;
    104 extern const HashTable objectConstructorTable;
     104JS_EXPORTDATA extern const HashTable objectConstructorTable;
    105105extern const HashTable objectPrototypeTable;
    106106extern const HashTable regExpTable;

  • trunk/Source/JavaScriptCore/runtime/JSGlobalData.h

    r104415 r104900  
    135135       
    136136        struct ClientData {
    137             virtual ~ClientData() = 0;
     137            JS_EXPORT_PRIVATE virtual ~ClientData() = 0;
    138138        };
    139139
    … …  
    141141        bool usingAPI() { return globalDataType != Default; }
    142142        static bool sharedInstanceExists();
    143         static JSGlobalData& sharedInstance();
    144 
    145         static PassRefPtr<JSGlobalData> create(ThreadStackType, HeapSize = SmallHeap);
    146         static PassRefPtr<JSGlobalData> createLeaked(ThreadStackType, HeapSize = SmallHeap);
     143        JS_EXPORT_PRIVATE static JSGlobalData& sharedInstance();
     144
     145        JS_EXPORT_PRIVATE static PassRefPtr<JSGlobalData> create(ThreadStackType, HeapSize = SmallHeap);
     146        JS_EXPORT_PRIVATE static PassRefPtr<JSGlobalData> createLeaked(ThreadStackType, HeapSize = SmallHeap);
    147147        static PassRefPtr<JSGlobalData> createContextGroup(ThreadStackType, HeapSize = SmallHeap);
    148         ~JSGlobalData();
     148        JS_EXPORT_PRIVATE ~JSGlobalData();
    149149
    150150        void makeUsableFromMultipleThreads() { heap.machineThreads().makeUsableFromMultipleThreads(); }
    … …  
    309309        CachedTranscendentalFunction<sin> cachedSin;
    310310
    311         void resetDateCache();
    312 
    313         void startSampling();
    314         void stopSampling();
    315         void dumpSampleData(ExecState* exec);
     311        JS_EXPORT_PRIVATE void resetDateCache();
     312
     313        JS_EXPORT_PRIVATE void startSampling();
     314        JS_EXPORT_PRIVATE void stopSampling();
     315        JS_EXPORT_PRIVATE void dumpSampleData(ExecState* exec);
    316316        void recompileAllJSFunctions();
    317317        RegExpCache* regExpCache() { return m_regExpCache; }
    … …  
    319319        void addRegExpToTrace(PassRefPtr<RegExp> regExp);
    320320#endif
    321         void dumpRegExpTrace();
    322         void clearBuiltinStructures();
     321        JS_EXPORT_PRIVATE void dumpRegExpTrace();
     322        JS_EXPORT_PRIVATE void clearBuiltinStructures();
    323323
    324324        bool isCollectorBusy() { return heap.isBusy(); }
    325         void releaseExecutableMemory();
     325        JS_EXPORT_PRIVATE void releaseExecutableMemory();
    326326
    327327#if ENABLE(GC_VALIDATION)

  • trunk/Source/JavaScriptCore/runtime/JSGlobalObject.h

    r104899 r104900  
    193193
    194194    public:
    195         ~JSGlobalObject();
    196         static void destroy(JSCell*);
    197 
    198         static void visitChildren(JSCell*, SlotVisitor&);
    199 
    200         static bool getOwnPropertySlot(JSCell*, ExecState*, const Identifier&, PropertySlot&);
    201         static bool getOwnPropertyDescriptor(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&);
     195        JS_EXPORT_PRIVATE ~JSGlobalObject();
     196        JS_EXPORT_PRIVATE static void destroy(JSCell*);
     197
     198        JS_EXPORT_PRIVATE static void visitChildren(JSCell*, SlotVisitor&);
     199
     200        JS_EXPORT_PRIVATE static bool getOwnPropertySlot(JSCell*, ExecState*, const Identifier&, PropertySlot&);
     201        JS_EXPORT_PRIVATE static bool getOwnPropertyDescriptor(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&);
    202202        bool hasOwnPropertyForWrite(ExecState*, const Identifier&);
    203         static void put(JSCell*, ExecState*, const Identifier&, JSValue, PutPropertySlot&);
    204 
    205         static void putDirectVirtual(JSObject*, ExecState*, const Identifier& propertyName, JSValue, unsigned attributes);
    206 
    207         static void defineGetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* getterFunc, unsigned attributes);
    208         static void defineSetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* setterFunc, unsigned attributes);
     203        JS_EXPORT_PRIVATE static void put(JSCell*, ExecState*, const Identifier&, JSValue, PutPropertySlot&);
     204
     205        JS_EXPORT_PRIVATE static void putDirectVirtual(JSObject*, ExecState*, const Identifier& propertyName, JSValue, unsigned attributes);
     206
     207        JS_EXPORT_PRIVATE static void defineGetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* getterFunc, unsigned attributes);
     208        JS_EXPORT_PRIVATE static void defineSetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* setterFunc, unsigned attributes);
    209209
    210210        // We use this in the code generator as we perform symbol table
    … …  
    284284        ScopeChainNode* globalScopeChain() { return m_globalScopeChain.get(); }
    285285
    286         ExecState* globalExec();
     286        JS_EXPORT_PRIVATE ExecState* globalExec();
    287287
    288288        static bool shouldInterruptScript(const JSGlobalObject*) { return true; }
    … …  
    333333            unsigned attributes;
    334334        };
    335         void addStaticGlobals(GlobalPropertyInfo*, int count);
     335        JS_EXPORT_PRIVATE void addStaticGlobals(GlobalPropertyInfo*, int count);
    336336
    337337    private:
    338338        // FIXME: Fold reset into init.
    339         void init(JSObject* thisValue);
     339        JS_EXPORT_PRIVATE void init(JSObject* thisValue);
    340340        void reset(JSValue prototype);
    341341
    … …  
    343343
    344344        void setRegisters(WriteBarrier<Unknown>* registers, PassOwnArrayPtr<WriteBarrier<Unknown> > registerArray, size_t count);
    345         static void clearRareData(JSCell*);
     345        JS_EXPORT_PRIVATE static void clearRareData(JSCell*);
    346346    };
    347347
    … …  
    489489        WTF_MAKE_NONCOPYABLE(DynamicGlobalObjectScope);
    490490    public:
    491         DynamicGlobalObjectScope(JSGlobalData&, JSGlobalObject*);
     491        JS_EXPORT_PRIVATE DynamicGlobalObjectScope(JSGlobalData&, JSGlobalObject*);
    492492
    493493        ~DynamicGlobalObjectScope()

  • trunk/Source/JavaScriptCore/runtime/JSGlobalThis.h

    r103243 r104900  
    6464    static const unsigned StructureFlags = OverridesVisitChildren | Base::StructureFlags;
    6565
    66     static void visitChildren(JSCell*, SlotVisitor&);
     66    JS_EXPORT_PRIVATE static void visitChildren(JSCell*, SlotVisitor&);
    6767
    6868    WriteBarrier<JSGlobalObject> m_unwrappedObject;

  • trunk/Source/JavaScriptCore/runtime/JSLock.h

    r76248 r104900  
    5757        WTF_MAKE_NONCOPYABLE(JSLock);
    5858    public:
    59         JSLock(ExecState*);
     59        JS_EXPORT_PRIVATE JSLock(ExecState*);
    6060        JSLock(JSGlobalData*);
    6161
    … …  
    8181        }
    8282       
    83         static void lock(JSLockBehavior);
    84         static void unlock(JSLockBehavior);
     83        JS_EXPORT_PRIVATE static void lock(JSLockBehavior);
     84        JS_EXPORT_PRIVATE static void unlock(JSLockBehavior);
    8585        static void lock(ExecState*);
    8686        static void unlock(ExecState*);
    8787
    88         static intptr_t lockCount();
    89         static bool currentThreadIsHoldingLock();
     88        JS_EXPORT_PRIVATE static intptr_t lockCount();
     89        JS_EXPORT_PRIVATE static bool currentThreadIsHoldingLock();
    9090
    9191        JSLockBehavior m_lockBehavior;
    … …  
    9494            WTF_MAKE_NONCOPYABLE(DropAllLocks);
    9595        public:
    96             DropAllLocks(ExecState* exec);
    97             DropAllLocks(JSLockBehavior);
    98             ~DropAllLocks();
     96            JS_EXPORT_PRIVATE DropAllLocks(ExecState* exec);
     97            JS_EXPORT_PRIVATE DropAllLocks(JSLockBehavior);
     98            JS_EXPORT_PRIVATE ~DropAllLocks();
    9999           
    100100        private:

  • trunk/Source/JavaScriptCore/runtime/JSObject.h

    r104899 r104900  
    5656    struct HashTable;
    5757
    58     JSObject* throwTypeError(ExecState*, const UString&);
     58    JS_EXPORT_PRIVATE JSObject* throwTypeError(ExecState*, const UString&);
    5959    extern JS_EXPORTDATA const char* StrictModeReadonlyPropertyWriteError;
    6060
    … …  
    7575        friend class JSCell;
    7676        friend class MarkedBlock;
    77         friend bool setUpStaticFunctionSlot(ExecState* exec, const HashEntry* entry, JSObject* thisObj, const Identifier& propertyName, PropertySlot& slot);
     77        JS_EXPORT_PRIVATE friend bool setUpStaticFunctionSlot(ExecState* exec, const HashEntry* entry, JSObject* thisObj, const Identifier& propertyName, PropertySlot& slot);
    7878
    7979        enum PutMode {
    … …  
    8585        typedef JSCell Base;
    8686
    87         static void destroy(JSCell*);
    88 
    89         static void visitChildren(JSCell*, SlotVisitor&);
    90 
    91         static UString className(const JSObject*);
     87        JS_EXPORT_PRIVATE static void destroy(JSCell*);
     88
     89        JS_EXPORT_PRIVATE static void visitChildren(JSCell*, SlotVisitor&);
     90
     91        JS_EXPORT_PRIVATE static UString className(const JSObject*);
    9292
    9393        static void finalize(JSCell*);
    … …  
    104104        bool getPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
    105105        bool getPropertySlot(ExecState*, unsigned propertyName, PropertySlot&);
    106         bool getPropertyDescriptor(ExecState*, const Identifier& propertyName, PropertyDescriptor&);
     106        JS_EXPORT_PRIVATE bool getPropertyDescriptor(ExecState*, const Identifier& propertyName, PropertyDescriptor&);
    107107
    108108        static bool getOwnPropertySlot(JSCell*, ExecState*, const Identifier& propertyName, PropertySlot&);
    109         static bool getOwnPropertySlotByIndex(JSCell*, ExecState*, unsigned propertyName, PropertySlot&);
    110         static bool getOwnPropertyDescriptor(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&);
    111 
    112         static void put(JSCell*, ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
    113         static void putByIndex(JSCell*, ExecState*, unsigned propertyName, JSValue);
     109        JS_EXPORT_PRIVATE static bool getOwnPropertySlotByIndex(JSCell*, ExecState*, unsigned propertyName, PropertySlot&);
     110        JS_EXPORT_PRIVATE static bool getOwnPropertyDescriptor(JSObject*, ExecState*, const Identifier&, PropertyDescriptor&);
     111
     112        JS_EXPORT_PRIVATE static void put(JSCell*, ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
     113        JS_EXPORT_PRIVATE static void putByIndex(JSCell*, ExecState*, unsigned propertyName, JSValue);
    114114
    115115        // putDirect is effectively an unchecked vesion of 'defineOwnProperty':
    … …  
    117117        //  - accessors are not called.
    118118        //  - attributes will be respected (after the call the property will exist with the given attributes)
    119         static void putDirectVirtual(JSObject*, ExecState*, const Identifier& propertyName, JSValue, unsigned attributes);
     119        JS_EXPORT_PRIVATE static void putDirectVirtual(JSObject*, ExecState*, const Identifier& propertyName, JSValue, unsigned attributes);
    120120        void putDirect(JSGlobalData&, const Identifier& propertyName, JSValue, unsigned attributes = 0);
    121121        void putDirect(JSGlobalData&, const Identifier& propertyName, JSValue, PutPropertySlot&);
    … …  
    124124        bool propertyIsEnumerable(ExecState*, const Identifier& propertyName) const;
    125125
    126         bool hasProperty(ExecState*, const Identifier& propertyName) const;
    127         bool hasProperty(ExecState*, unsigned propertyName) const;
     126        JS_EXPORT_PRIVATE bool hasProperty(ExecState*, const Identifier& propertyName) const;
     127        JS_EXPORT_PRIVATE bool hasProperty(ExecState*, unsigned propertyName) const;
    128128        bool hasOwnProperty(ExecState*, const Identifier& propertyName) const;
    129129
    130         static bool deleteProperty(JSCell*, ExecState*, const Identifier& propertyName);
    131         static bool deletePropertyByIndex(JSCell*, ExecState*, unsigned propertyName);
    132 
    133         static JSValue defaultValue(const JSObject*, ExecState*, PreferredPrimitiveType);
    134 
    135         static bool hasInstance(JSObject*, ExecState*, JSValue, JSValue prototypeProperty);
    136 
    137         static void getOwnPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
    138         static void getPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
     130        JS_EXPORT_PRIVATE static bool deleteProperty(JSCell*, ExecState*, const Identifier& propertyName);
     131        JS_EXPORT_PRIVATE static bool deletePropertyByIndex(JSCell*, ExecState*, unsigned propertyName);
     132
     133        JS_EXPORT_PRIVATE static JSValue defaultValue(const JSObject*, ExecState*, PreferredPrimitiveType);
     134
     135        JS_EXPORT_PRIVATE static bool hasInstance(JSObject*, ExecState*, JSValue, JSValue prototypeProperty);
     136
     137        JS_EXPORT_PRIVATE static void getOwnPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
     138        JS_EXPORT_PRIVATE static void getPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
    139139
    140140        JSValue toPrimitive(ExecState*, PreferredPrimitiveType = NoPreference) const;
    141         bool toBoolean(ExecState*) const;
     141        JS_EXPORT_PRIVATE bool toBoolean(ExecState*) const;
    142142        bool getPrimitiveNumber(ExecState*, double& number, JSValue&) const;
    143         double toNumber(ExecState*) const;
    144         UString toString(ExecState*) const;
     143        JS_EXPORT_PRIVATE double toNumber(ExecState*) const;
     144        JS_EXPORT_PRIVATE UString toString(ExecState*) const;
    145145
    146146        // NOTE: JSObject and its subclasses must be able to gracefully handle ExecState* = 0,
    147147        // because this call may come from inside the compiler.
    148         static JSObject* toThisObject(JSCell*, ExecState*);
     148        JS_EXPORT_PRIVATE static JSObject* toThisObject(JSCell*, ExecState*);
    149149        JSObject* unwrappedObject();
    150150
    … …  
    194194        void putUndefinedAtDirectOffset(size_t offset) { propertyStorage()[offset].setUndefined(); }
    195195
    196         void fillGetterPropertySlot(PropertySlot&, WriteBarrierBase<Unknown>* location);
     196        JS_EXPORT_PRIVATE void fillGetterPropertySlot(PropertySlot&, WriteBarrierBase<Unknown>* location);
    197197        void initializeGetterSetterProperty(ExecState*, const Identifier&, GetterSetter*, unsigned attributes);
    198198
    199         static void defineGetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* getterFunction, unsigned attributes = 0);
    200         static void defineSetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* setterFunction, unsigned attributes = 0);
    201         JSValue lookupGetter(ExecState*, const Identifier& propertyName);
    202         JSValue lookupSetter(ExecState*, const Identifier& propertyName);
    203         static bool defineOwnProperty(JSObject*, ExecState*, const Identifier& propertyName, PropertyDescriptor&, bool shouldThrow);
     199        JS_EXPORT_PRIVATE static void defineGetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* getterFunction, unsigned attributes = 0);
     200        JS_EXPORT_PRIVATE static void defineSetter(JSObject*, ExecState*, const Identifier& propertyName, JSObject* setterFunction, unsigned attributes = 0);
     201        JS_EXPORT_PRIVATE JSValue lookupGetter(ExecState*, const Identifier& propertyName);
     202        JS_EXPORT_PRIVATE JSValue lookupSetter(ExecState*, const Identifier& propertyName);
     203        JS_EXPORT_PRIVATE static bool defineOwnProperty(JSObject*, ExecState*, const Identifier& propertyName, PropertyDescriptor&, bool shouldThrow);
    204204
    205205        bool isGlobalObject() const;
    … …  
    211211        void seal(JSGlobalData&);
    212212        void freeze(JSGlobalData&);
    213         void preventExtensions(JSGlobalData&);
     213        JS_EXPORT_PRIVATE void preventExtensions(JSGlobalData&);
    214214        bool isSealed(JSGlobalData& globalData) { return structure()->isSealed(globalData); }
    215215        bool isFrozen(JSGlobalData& globalData) { return structure()->isFrozen(globalData); }
    … …  
    219219        void reifyStaticFunctionsForDelete(ExecState* exec);
    220220
    221         void allocatePropertyStorage(JSGlobalData&, size_t oldSize, size_t newSize);
     221        JS_EXPORT_PRIVATE void allocatePropertyStorage(JSGlobalData&, size_t oldSize, size_t newSize);
    222222        bool isUsingInlineStorage() const { return static_cast<const void*>(m_propertyStorage.get()) == static_cast<const void*>(this + 1); }
    223223
    … …  
    330330        }
    331331
    332         static void destroy(JSCell*);
     332        JS_EXPORT_PRIVATE static void destroy(JSCell*);
    333333
    334334    protected:

  • trunk/Source/JavaScriptCore/runtime/JSString.h

    r104744 r104900  
    215215
    216216        JSValue toPrimitive(ExecState*, PreferredPrimitiveType) const;
    217         bool toBoolean(ExecState*) const;
     217        JS_EXPORT_PRIVATE bool toBoolean(ExecState*) const;
    218218        bool getPrimitiveNumber(ExecState*, double& number, JSValue&) const;
    219219        JSObject* toObject(ExecState*, JSGlobalObject*) const;
    … …  
    242242
    243243    private:
    244         void resolveRope(ExecState*) const;
     244        JS_EXPORT_PRIVATE void resolveRope(ExecState*) const;
    245245        void resolveRopeSlowCase8(LChar*) const;
    246246        void resolveRopeSlowCase(UChar*) const;

  • trunk/Source/JavaScriptCore/runtime/JSValue.h

    r104886 r104900  
    9494
    9595    // This implements ToInt32, defined in ECMA-262 9.5.
    96     int32_t toInt32(double);
     96    JS_EXPORT_PRIVATE int32_t toInt32(double);
    9797
    9898    // This implements ToUInt32, defined in ECMA-262 9.6.
    … …  
    204204
    205205        // Integer conversions.
    206         double toInteger(ExecState*) const;
     206        JS_EXPORT_PRIVATE double toInteger(ExecState*) const;
    207207        double toIntegerPreserveNaN(ExecState*) const;
    208208        int32_t toInt32(ExecState*) const;
    … …  
    232232        bool isCell() const;
    233233        JSCell* asCell() const;
    234         bool isValidCallee();
     234        JS_EXPORT_PRIVATE bool isValidCallee();
    235235
    236236#ifndef NDEBUG
    … …  
    245245
    246246        inline const JSValue asValue() const { return *this; }
    247         double toNumberSlowCase(ExecState*) const;
    248         JSObject* toObjectSlowCase(ExecState*, JSGlobalObject*) const;
    249         JSObject* toThisObjectSlowCase(ExecState*) const;
    250 
    251         JSObject* synthesizePrototype(ExecState*) const;
     247        JS_EXPORT_PRIVATE double toNumberSlowCase(ExecState*) const;
     248        JS_EXPORT_PRIVATE JSObject* toObjectSlowCase(ExecState*, JSGlobalObject*) const;
     249        JS_EXPORT_PRIVATE JSObject* toThisObjectSlowCase(ExecState*) const;
     250
     251        JS_EXPORT_PRIVATE JSObject* synthesizePrototype(ExecState*) const;
    252252        JSObject* synthesizeObject(ExecState*) const;
    253253

  • trunk/Source/JavaScriptCore/runtime/JSVariableObject.h

    r104899 r104900  
    4949        SymbolTable& symbolTable() const { return *m_symbolTable; }
    5050
    51         static void destroy(JSCell*);
     51        JS_EXPORT_PRIVATE static void destroy(JSCell*);
    5252
    5353        static NO_RETURN_DUE_TO_ASSERT void putDirectVirtual(JSObject*, ExecState*, const Identifier&, JSValue, unsigned attributes);
    5454
    55         static bool deleteProperty(JSCell*, ExecState*, const Identifier&);
    56         static void getOwnPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
     55        JS_EXPORT_PRIVATE static bool deleteProperty(JSCell*, ExecState*, const Identifier&);
     56        JS_EXPORT_PRIVATE static void getOwnPropertyNames(JSObject*, ExecState*, PropertyNameArray&, EnumerationMode);
    5757       
    5858        bool isDynamicScope(bool& requiresDynamicChecks) const;
    … …  
    8989
    9090        bool symbolTableGet(const Identifier&, PropertySlot&);
    91         bool symbolTableGet(const Identifier&, PropertyDescriptor&);
     91        JS_EXPORT_PRIVATE bool symbolTableGet(const Identifier&, PropertyDescriptor&);
    9292        bool symbolTableGet(const Identifier&, PropertySlot&, bool& slotIsWriteable);
    9393        bool symbolTablePut(ExecState*, const Identifier&, JSValue, bool shouldThrow);

  • trunk/Source/JavaScriptCore/runtime/Lookup.h

    r103697 r104900  
    127127        }
    128128
    129         void deleteTable() const;
     129        JS_EXPORT_PRIVATE void deleteTable() const;
    130130
    131131        // Find an entry in the table, and return the entry.
    … …  
    219219
    220220        // Convert the hash table keys to identifiers.
    221         void createTable(JSGlobalData*) const;
     221        JS_EXPORT_PRIVATE void createTable(JSGlobalData*) const;
    222222    };
    223223
    224     bool setUpStaticFunctionSlot(ExecState*, const HashEntry*, JSObject* thisObject, const Identifier& propertyName, PropertySlot&);
     224    JS_EXPORT_PRIVATE bool setUpStaticFunctionSlot(ExecState*, const HashEntry*, JSObject* thisObject, const Identifier& propertyName, PropertySlot&);
    225225
    226226    /**

  • trunk/Source/JavaScriptCore/runtime/MemoryStatistics.h

    r95901 r104900  
    3838};
    3939
    40 GlobalMemoryStatistics globalMemoryStatistics();
     40JS_EXPORT_PRIVATE GlobalMemoryStatistics globalMemoryStatistics();
    4141
    4242}

  • trunk/Source/JavaScriptCore/runtime/ObjectPrototype.h

    r103243 r104900  
    6060    };
    6161
    62     EncodedJSValue JSC_HOST_CALL objectProtoFuncToString(ExecState*);
     62    JS_EXPORT_PRIVATE EncodedJSValue JSC_HOST_CALL objectProtoFuncToString(ExecState*);
    6363
    6464} // namespace JSC

  • trunk/Source/JavaScriptCore/runtime/Options.h

    r103286 r104900  
    7474extern unsigned maximumNumberOfSharedSegments;
    7575extern unsigned sharedStackWakeupThreshold;
    76 extern unsigned numberOfGCMarkers;
    77 extern unsigned opaqueRootMergeThreshold;
     76JS_EXPORTDATA extern unsigned numberOfGCMarkers;
     77JS_EXPORTDATA extern unsigned opaqueRootMergeThreshold;
    7878
    7979void initializeOptions();

  • trunk/Source/JavaScriptCore/runtime/PropertyDescriptor.h

    r104836 r104900  
    4242        {
    4343        }
    44         bool writable() const;
    45         bool enumerable() const;
    46         bool configurable() const;
    47         bool isDataDescriptor() const;
     44        JS_EXPORT_PRIVATE bool writable() const;
     45        JS_EXPORT_PRIVATE bool enumerable() const;
     46        JS_EXPORT_PRIVATE bool configurable() const;
     47        JS_EXPORT_PRIVATE bool isDataDescriptor() const;
    4848        bool isGenericDescriptor() const;
    49         bool isAccessorDescriptor() const;
     49        JS_EXPORT_PRIVATE bool isAccessorDescriptor() const;
    5050        unsigned attributes() const { return m_attributes; }
    5151        JSValue value() const { return m_value; }
    52         JSValue getter() const;
    53         JSValue setter() const;
     52        JS_EXPORT_PRIVATE JSValue getter() const;
     53        JS_EXPORT_PRIVATE JSValue setter() const;
    5454        JSObject* getterObject() const;
    5555        JSObject* setterObject() const;
    56         void setUndefined();
    57         void setDescriptor(JSValue value, unsigned attributes);
     56        JS_EXPORT_PRIVATE void setUndefined();
     57        JS_EXPORT_PRIVATE void setDescriptor(JSValue value, unsigned attributes);
    5858        void setAccessorDescriptor(GetterSetter* accessor, unsigned attributes);
    59         void setWritable(bool);
    60         void setEnumerable(bool);
    61         void setConfigurable(bool);
     59        JS_EXPORT_PRIVATE void setWritable(bool);
     60        JS_EXPORT_PRIVATE void setEnumerable(bool);
     61        JS_EXPORT_PRIVATE void setConfigurable(bool);
    6262        void setValue(JSValue value) { m_value = value; }
    63         void setSetter(JSValue);
    64         void setGetter(JSValue);
     63        JS_EXPORT_PRIVATE void setSetter(JSValue);
     64        JS_EXPORT_PRIVATE void setGetter(JSValue);
    6565        bool isEmpty() const { return !(m_value || m_getter || m_setter || m_seenAttributes); }
    6666        bool writablePresent() const { return m_seenAttributes & WritablePresent; }
    … …  
    7575
    7676    private:
    77         static unsigned defaultAttributes;
     77        JS_EXPORTDATA static unsigned defaultAttributes;
    7878        bool operator==(const PropertyDescriptor&){ return false; }
    7979        enum { WritablePresent = 1, EnumerablePresent = 2, ConfigurablePresent = 4};

  • trunk/Source/JavaScriptCore/runtime/PropertyNameArray.h

    r65104 r104900  
    7070
    7171        void add(const Identifier& identifier) { add(identifier.impl()); }
    72         void add(StringImpl*);
     72        JS_EXPORT_PRIVATE void add(StringImpl*);
    7373        void addKnownUnique(StringImpl* identifier) { m_data->propertyNameVector().append(Identifier(m_globalData, identifier)); }
    7474

  • trunk/Source/JavaScriptCore/runtime/PropertySlot.h

    r91095 r104900  
    219219        }
    220220    private:
    221         JSValue functionGetter(ExecState*) const;
     221        JS_EXPORT_PRIVATE JSValue functionGetter(ExecState*) const;
    222222
    223223        GetValueFunc m_getValue;

  • trunk/Source/JavaScriptCore/runtime/RegExp.h

    r103083 r104900  
    3636    class JSGlobalData;
    3737
    38     RegExpFlags regExpFlags(const UString&);
     38    JS_EXPORT_PRIVATE RegExpFlags regExpFlags(const UString&);
    3939
    4040    class RegExp : public JSCell {
    … …  
    4242        typedef JSCell Base;
    4343
    44         static RegExp* create(JSGlobalData&, const UString& pattern, RegExpFlags);
     44        JS_EXPORT_PRIVATE static RegExp* create(JSGlobalData&, const UString& pattern, RegExpFlags);
    4545        static void destroy(JSCell*);
    4646
    … …  
    5454        const char* errorMessage() const { return m_constructionError; }
    5555
    56         int match(JSGlobalData&, const UString&, int startOffset, Vector<int, 32>* ovector = 0);
     56        JS_EXPORT_PRIVATE int match(JSGlobalData&, const UString&, int startOffset, Vector<int, 32>* ovector = 0);
    5757        unsigned numSubpatterns() const { return m_numSubpatterns; }
    5858

  • trunk/Source/JavaScriptCore/runtime/RegExpObject.h

    r103243 r104900  
    7676
    7777    protected:
    78         RegExpObject(JSGlobalObject*, Structure*, RegExp*);
    79         void finishCreation(JSGlobalObject*);
     78        JS_EXPORT_PRIVATE RegExpObject(JSGlobalObject*, Structure*, RegExp*);
     79        JS_EXPORT_PRIVATE void finishCreation(JSGlobalObject*);
    8080        static void destroy(JSCell*);
    8181

  • trunk/Source/JavaScriptCore/runtime/SamplingCounter.h

    r95901 r104900  
    4747    }
    4848
    49     static void dump();
     49    JS_EXPORT_PRIVATE static void dump();
    5050
    5151    int64_t* addressOfCounter() { return &m_counter; }
    … …  
    7575    // Null object used to detect end of static chain.
    7676    static AbstractSamplingCounter s_abstractSamplingCounterChainEnd;
    77     static AbstractSamplingCounter* s_abstractSamplingCounterChain;
     77    JS_EXPORTDATA static AbstractSamplingCounter* s_abstractSamplingCounterChain;
    7878    static bool s_completed;
    7979};

  • trunk/Source/JavaScriptCore/runtime/SmallStrings.h

    r89077 r104900  
    6161        }
    6262
    63         StringImpl* singleCharacterStringRep(unsigned char character);
     63        JS_EXPORT_PRIVATE StringImpl* singleCharacterStringRep(unsigned char character);
    6464
    6565        void finalizeSmallStrings();
    … …  
    7373        static const unsigned singleCharacterStringCount = maxSingleCharacterString + 1;
    7474
    75         void createEmptyString(JSGlobalData*);
    76         void createSingleCharacterString(JSGlobalData*, unsigned char);
     75        JS_EXPORT_PRIVATE void createEmptyString(JSGlobalData*);
     76        JS_EXPORT_PRIVATE void createSingleCharacterString(JSGlobalData*, unsigned char);
    7777
    7878        JSString* m_emptyString;

  • trunk/Source/JavaScriptCore/runtime/StringObject.h

    r103243 r104900  
    6565
    6666    protected:
    67         void finishCreation(JSGlobalData&, JSString*);
     67        JS_EXPORT_PRIVATE void finishCreation(JSGlobalData&, JSString*);
    6868        static const unsigned StructureFlags = OverridesGetOwnPropertySlot | OverridesGetPropertyNames | JSWrapperObject::StructureFlags;
    69         StringObject(JSGlobalData&, Structure*);
     69        JS_EXPORT_PRIVATE StringObject(JSGlobalData&, Structure*);
    7070    };
    7171

  • trunk/Source/JavaScriptCore/runtime/Structure.h

    r104871 r104900  
    8585        static void dumpStatistics();
    8686
    87         static Structure* addPropertyTransition(JSGlobalData&, Structure*, const Identifier& propertyName, unsigned attributes, JSCell* specificValue, size_t& offset);
    88         static Structure* addPropertyTransitionToExistingStructure(Structure*, const Identifier& propertyName, unsigned attributes, JSCell* specificValue, size_t& offset);
     87        JS_EXPORT_PRIVATE static Structure* addPropertyTransition(JSGlobalData&, Structure*, const Identifier& propertyName, unsigned attributes, JSCell* specificValue, size_t& offset);
     88        JS_EXPORT_PRIVATE static Structure* addPropertyTransitionToExistingStructure(Structure*, const Identifier& propertyName, unsigned attributes, JSCell* specificValue, size_t& offset);
    8989        static Structure* removePropertyTransition(JSGlobalData&, Structure*, const Identifier& propertyName, size_t& offset);
    90         static Structure* changePrototypeTransition(JSGlobalData&, Structure*, JSValue prototype);
    91         static Structure* despecifyFunctionTransition(JSGlobalData&, Structure*, const Identifier&);
     90        JS_EXPORT_PRIVATE static Structure* changePrototypeTransition(JSGlobalData&, Structure*, JSValue prototype);
     91        JS_EXPORT_PRIVATE static Structure* despecifyFunctionTransition(JSGlobalData&, Structure*, const Identifier&);
    9292        static Structure* attributeChangeTransition(JSGlobalData&, Structure*, const Identifier& propertyName, unsigned attributes);
    9393        static Structure* toCacheableDictionaryTransition(JSGlobalData&, Structure*);
    … …  
    107107
    108108        // These should be used with caution. 
    109         size_t addPropertyWithoutTransition(JSGlobalData&, const Identifier& propertyName, unsigned attributes, JSCell* specificValue);
     109        JS_EXPORT_PRIVATE size_t addPropertyWithoutTransition(JSGlobalData&, const Identifier& propertyName, unsigned attributes, JSCell* specificValue);
    110110        size_t removePropertyWithoutTransition(JSGlobalData&, const Identifier& propertyName);
    111111        void setPrototypeWithoutTransition(JSGlobalData& globalData, JSValue prototype) { m_prototype.set(globalData, this, prototype); }
    … …  
    137137        size_t get(JSGlobalData&, const Identifier& propertyName);
    138138        size_t get(JSGlobalData&, const UString& name);
    139         size_t get(JSGlobalData&, StringImpl* propertyName, unsigned& attributes, JSCell*& specificValue);
     139        JS_EXPORT_PRIVATE size_t get(JSGlobalData&, StringImpl* propertyName, unsigned& attributes, JSCell*& specificValue);
    140140        size_t get(JSGlobalData& globalData, const Identifier& propertyName, unsigned& attributes, JSCell*& specificValue)
    141141        {
    … …  
    152152        bool isEmpty() const { return m_propertyTable ? m_propertyTable->isEmpty() : m_offset == noOffset; }
    153153
    154         void despecifyDictionaryFunction(JSGlobalData&, const Identifier& propertyName);
     154        JS_EXPORT_PRIVATE void despecifyDictionaryFunction(JSGlobalData&, const Identifier& propertyName);
    155155        void disableSpecificFunctionTracking() { m_specificFunctionThrashCount = maxSpecificFunctionThrashCount; }
    156156
    … …  
    197197
    198198    private:
    199         Structure(JSGlobalData&, JSGlobalObject*, JSValue prototype, const TypeInfo&, const ClassInfo*);
     199        JS_EXPORT_PRIVATE Structure(JSGlobalData&, JSGlobalObject*, JSValue prototype, const TypeInfo&, const ClassInfo*);
    200200        Structure(JSGlobalData&);
    201201        Structure(JSGlobalData&, const Structure*);
    … …  
    227227        PassOwnPtr<PropertyTable> copyPropertyTable(JSGlobalData&, Structure* owner);
    228228        PassOwnPtr<PropertyTable> copyPropertyTableForPinning(JSGlobalData&, Structure* owner);
    229         void materializePropertyMap(JSGlobalData&);
     229        JS_EXPORT_PRIVATE void materializePropertyMap(JSGlobalData&);
    230230        void materializePropertyMapIfNecessary(JSGlobalData& globalData)
    231231        {

  • trunk/Source/JavaScriptCore/runtime/TimeoutChecker.h

    r95901 r104900  
    5858        }
    5959
    60         void reset();
     60        JS_EXPORT_PRIVATE void reset();
    6161
    62         bool didTimeOut(ExecState*);
     62        JS_EXPORT_PRIVATE bool didTimeOut(ExecState*);
    6363
    6464    private:

  • trunk/Source/JavaScriptCore/runtime/UString.h

    r101147 r104900  
    3434
    3535    // Construct a string with UTF-16 data.
    36     UString(const UChar* characters, unsigned length);
     36    JS_EXPORT_PRIVATE UString(const UChar* characters, unsigned length);
    3737
    3838    // Construct a string with UTF-16 data, from a null-terminated source.
    39     UString(const UChar*);
     39    JS_EXPORT_PRIVATE UString(const UChar*);
    4040
    4141    // Construct a string with latin1 data.
    4242    UString(const LChar* characters, unsigned length);
    43     UString(const char* characters, unsigned length);
     43    JS_EXPORT_PRIVATE UString(const char* characters, unsigned length);
    4444
    4545    // Construct a string with latin1 data, from a null-terminated source.
    4646    UString(const LChar* characters);
    47     UString(const char* characters);
     47    JS_EXPORT_PRIVATE UString(const char* characters);
    4848
    4949    // Construct a string referencing an existing StringImpl.
    … …  
    100100    bool is8Bit() const { return m_impl->is8Bit(); }
    101101
    102     CString ascii() const;
     102    JS_EXPORT_PRIVATE CString ascii() const;
    103103    CString latin1() const;
    104     CString utf8(bool strict = false) const;
     104    JS_EXPORT_PRIVATE CString utf8(bool strict = false) const;
    105105
    106106    UChar operator[](unsigned index) const
    … …  
    113113    }
    114114
    115     static UString number(int);
    116     static UString number(unsigned);
    117     static UString number(long);
     115    JS_EXPORT_PRIVATE static UString number(int);
     116    JS_EXPORT_PRIVATE static UString number(unsigned);
     117    JS_EXPORT_PRIVATE static UString number(long);
    118118    static UString number(long long);
    119     static UString number(double);
     119    JS_EXPORT_PRIVATE static UString number(double);
    120120
    121121    // Find a single character or string, also with match function & latin1 forms.
    … …  
    133133        { return m_impl ? m_impl->reverseFind(str.impl(), start) : notFound; }
    134134
    135     UString substringSharingImpl(unsigned pos, unsigned len = UINT_MAX) const;
     135    JS_EXPORT_PRIVATE UString substringSharingImpl(unsigned pos, unsigned len = UINT_MAX) const;
    136136
    137137private:
    … …  
    190190}
    191191
    192 bool operator<(const UString& s1, const UString& s2);
    193 bool operator>(const UString& s1, const UString& s2);
    194 
    195 bool operator==(const UString& s1, const char* s2);
     192JS_EXPORT_PRIVATE bool operator<(const UString& s1, const UString& s2);
     193JS_EXPORT_PRIVATE bool operator>(const UString& s1, const UString& s2);
     194
     195JS_EXPORT_PRIVATE bool operator==(const UString& s1, const char* s2);
    196196
    197197inline bool operator!=(const UString& s1, const char* s2)

  • trunk/Source/JavaScriptCore/runtime/WriteBarrier.h

    r97642 r104900  
    4141template<> class WriteBarrierBase<JSValue>;
    4242
    43 void slowValidateCell(JSCell*);
    44 void slowValidateCell(JSGlobalObject*);
     43JS_EXPORT_PRIVATE void slowValidateCell(JSCell*);
     44JS_EXPORT_PRIVATE void slowValidateCell(JSGlobalObject*);
    4545   
    4646#if ENABLE(GC_VALIDATION)

  • trunk/Source/JavaScriptCore/wtf/ArrayBufferView.h

    r101295 r104900  
    6666    virtual unsigned byteLength() const = 0;
    6767
    68     virtual ~ArrayBufferView();
     68    WTF_EXPORT_PRIVATE virtual ~ArrayBufferView();
    6969
    7070  protected:
    71     ArrayBufferView(PassRefPtr<ArrayBuffer>, unsigned byteOffset);
     71    WTF_EXPORT_PRIVATE ArrayBufferView(PassRefPtr<ArrayBuffer>, unsigned byteOffset);
    7272
    7373    inline bool setImpl(ArrayBufferView*, unsigned byteOffset);
    … …  
    119119    }
    120120
    121     virtual void neuter();
     121    WTF_EXPORT_PRIVATE virtual void neuter();
    122122
    123123    // This is the address of the ArrayBuffer's storage, plus the byte offset.

  • trunk/Source/JavaScriptCore/wtf/ByteArray.h

    r104471 r104900  
    8484        }
    8585
    86         static PassRefPtr<ByteArray> create(size_t size);
     86        WTF_EXPORT_PRIVATE static PassRefPtr<ByteArray> create(size_t size);
    8787
    8888        static size_t offsetOfSize() { return OBJECT_OFFSETOF(ByteArray, m_size); }

  • trunk/Source/JavaScriptCore/wtf/CryptographicallyRandomNumber.h

    r95901 r104900  
    3232
    3333#if USE(OS_RANDOMNESS)
    34 uint32_t cryptographicallyRandomNumber();
    35 void cryptographicallyRandomValues(void* buffer, size_t length);
     34WTF_EXPORT_PRIVATE uint32_t cryptographicallyRandomNumber();
     35WTF_EXPORT_PRIVATE void cryptographicallyRandomValues(void* buffer, size_t length);
    3636#endif
    3737

  • trunk/Source/JavaScriptCore/wtf/CurrentTime.h

    r88199 r104900  
    4040// Precision varies depending on platform but is usually as good or better
    4141// than a millisecond.
    42 double currentTime();
     42WTF_EXPORT_PRIVATE double currentTime();
    4343
    4444// Same thing, in milliseconds.
    … …  
    6161// Provides a monotonically increasing time in seconds since an arbitrary point in the past.
    6262// On unsupported platforms, this function only guarantees the result will be non-decreasing.
    63 double monotonicallyIncreasingTime();
     63WTF_EXPORT_PRIVATE double monotonicallyIncreasingTime();
    6464
    6565} // namespace WTF

  • trunk/Source/JavaScriptCore/wtf/DateMath.h

    r100205 r104900  
    6262// Not really math related, but this is currently the only shared place to put these.
    6363double parseES5DateFromNullTerminatedCharacters(const char* dateString);
    64 double parseDateFromNullTerminatedCharacters(const char* dateString);
     64WTF_EXPORT_PRIVATE double parseDateFromNullTerminatedCharacters(const char* dateString);
    6565double parseDateFromNullTerminatedCharacters(const char* dateString, bool& haveTZ, int& offset);
    6666double timeClip(double);
    … …  
    9090
    9191// Returns the number of days from 1970-01-01 to the specified date.
    92 double dateToDaysFrom1970(int year, int month, int day);
    93 int msToYear(double ms);
     92WTF_EXPORT_PRIVATE double dateToDaysFrom1970(int year, int month, int day);
     93WTF_EXPORT_PRIVATE int msToYear(double ms);
    9494double msToDays(double ms);
    9595int msToMinutes(double ms);
    9696int msToHours(double ms);
    97 int dayInYear(double ms, int year);
    98 int monthFromDayInYear(int dayInYear, bool leapYear);
    99 int dayInMonthFromDayInYear(int dayInYear, bool leapYear);
     97WTF_EXPORT_PRIVATE int dayInYear(double ms, int year);
     98WTF_EXPORT_PRIVATE int monthFromDayInYear(int dayInYear, bool leapYear);
     99WTF_EXPORT_PRIVATE int dayInMonthFromDayInYear(int dayInYear, bool leapYear);
    100100
    101101// Returns offset milliseconds for UTC and DST.
    102 int32_t calculateUTCOffset();
    103 double calculateDSTOffset(double ms, double utcOffset);
     102WTF_EXPORT_PRIVATE int32_t calculateUTCOffset();
     103WTF_EXPORT_PRIVATE double calculateDSTOffset(double ms, double utcOffset);
    104104
    105105} // namespace WTF

  • trunk/Source/JavaScriptCore/wtf/DecimalNumber.h

    r95901 r104900  
    8282    }
    8383
    84     unsigned bufferLengthForStringDecimal() const;
    85     unsigned bufferLengthForStringExponential() const;
     84    WTF_EXPORT_PRIVATE unsigned bufferLengthForStringDecimal() const;
     85    WTF_EXPORT_PRIVATE unsigned bufferLengthForStringExponential() const;
    8686
    87     unsigned toStringDecimal(UChar* buffer, unsigned bufferLength) const;
    88     unsigned toStringExponential(UChar* buffer, unsigned bufferLength) const;
     87    WTF_EXPORT_PRIVATE unsigned toStringDecimal(UChar* buffer, unsigned bufferLength) const;
     88    WTF_EXPORT_PRIVATE unsigned toStringExponential(UChar* buffer, unsigned bufferLength) const;
    8989
    9090    bool sign() const { return m_sign; }

  • trunk/Source/JavaScriptCore/wtf/FastMalloc.cpp

    r100152 r104900  
    183183namespace Internal {
    184184#if !ENABLE(WTF_MALLOC_VALIDATION)
    185 void fastMallocMatchFailed(void*);
     185WTF_EXPORT_PRIVATE void fastMallocMatchFailed(void*);
    186186#else
    187187COMPILE_ASSERT(((sizeof(ValidationHeader) % sizeof(AllocAlignmentInteger)) == 0), ValidationHeader_must_produce_correct_alignment);
    … …  
    401401// This symbol is present in the JavaScriptCore exports file even when FastMalloc is disabled.
    402402// It will never be used in this case, so it's type and value are less interesting than its presence.
    403 extern "C" const int jscore_fastmalloc_introspection = 0;
     403extern "C" WTF_EXPORT_PRIVATE const int jscore_fastmalloc_introspection = 0;
    404404#endif
    405405

  • trunk/Source/JavaScriptCore/wtf/FastMalloc.h

    r95555 r104900  
    3030
    3131    // These functions call CRASH() if an allocation fails.
    32     void* fastMalloc(size_t);
    33     void* fastZeroedMalloc(size_t);
    34     void* fastCalloc(size_t numElements, size_t elementSize);
    35     void* fastRealloc(void*, size_t);
    36     char* fastStrDup(const char*);
    37     size_t fastMallocSize(const void*);
     32    WTF_EXPORT_PRIVATE void* fastMalloc(size_t);
     33    WTF_EXPORT_PRIVATE void* fastZeroedMalloc(size_t);
     34    WTF_EXPORT_PRIVATE void* fastCalloc(size_t numElements, size_t elementSize);
     35    WTF_EXPORT_PRIVATE void* fastRealloc(void*, size_t);
     36    WTF_EXPORT_PRIVATE char* fastStrDup(const char*);
     37    WTF_EXPORT_PRIVATE size_t fastMallocSize(const void*);
    3838
    3939    struct TryMallocReturnValue {
    … …  
    6969    }
    7070
    71     TryMallocReturnValue tryFastMalloc(size_t n);
     71    WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastMalloc(size_t n);
    7272    TryMallocReturnValue tryFastZeroedMalloc(size_t n);
    73     TryMallocReturnValue tryFastCalloc(size_t n_elements, size_t element_size);
    74     TryMallocReturnValue tryFastRealloc(void* p, size_t n);
    75 
    76     void fastFree(void*);
     73    WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastCalloc(size_t n_elements, size_t element_size);
     74    WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastRealloc(void* p, size_t n);
     75
     76    WTF_EXPORT_PRIVATE void fastFree(void*);
    7777
    7878#ifndef NDEBUG   
    … …  
    8181#endif
    8282
    83     void releaseFastMallocFreeMemory();
     83    WTF_EXPORT_PRIVATE void releaseFastMallocFreeMemory();
    8484   
    8585    struct FastMallocStatistics {
    … …  
    8888        size_t freeListBytes;
    8989    };
    90     FastMallocStatistics fastMallocStatistics();
     90    WTF_EXPORT_PRIVATE FastMallocStatistics fastMallocStatistics();
    9191
    9292    // This defines a type which holds an unsigned integer and is the same

  • trunk/Source/JavaScriptCore/wtf/MD5.h

    r95901 r104900  
    3838class MD5 {
    3939public:
    40     MD5();
     40    WTF_EXPORT_PRIVATE MD5();
    4141
    4242    void addBytes(const Vector<uint8_t>& input)
    … …  
    4444        addBytes(input.data(), input.size());
    4545    }
    46     void addBytes(const uint8_t* input, size_t length);
     46    WTF_EXPORT_PRIVATE void addBytes(const uint8_t* input, size_t length);
    4747
    4848    // checksum has a side effect of resetting the state of the object.
    49     void checksum(Vector<uint8_t, 16>&);
     49    WTF_EXPORT_PRIVATE void checksum(Vector<uint8_t, 16>&);
    5050
    5151private:

  • trunk/Source/JavaScriptCore/wtf/MainThread.h

    r102797 r104900  
    4141
    4242// Must be called from the main thread.
    43 void initializeMainThread();
     43WTF_EXPORT_PRIVATE void initializeMainThread();
    4444
    45 void callOnMainThread(MainThreadFunction*, void* context);
    46 void callOnMainThreadAndWait(MainThreadFunction*, void* context);
    47 void cancelCallOnMainThread(MainThreadFunction*, void* context);
     45WTF_EXPORT_PRIVATE void callOnMainThread(MainThreadFunction*, void* context);
     46WTF_EXPORT_PRIVATE void callOnMainThreadAndWait(MainThreadFunction*, void* context);
     47WTF_EXPORT_PRIVATE void cancelCallOnMainThread(MainThreadFunction*, void* context);
    4848
    4949template<typename> class Function;
    50 void callOnMainThread(const Function<void ()>&);
     50WTF_EXPORT_PRIVATE void callOnMainThread(const Function<void ()>&);
    5151   
    52 void setMainThreadCallbacksPaused(bool paused);
     52WTF_EXPORT_PRIVATE void setMainThreadCallbacksPaused(bool paused);
    5353
    54 bool isMainThread();
     54WTF_EXPORT_PRIVATE bool isMainThread();
    5555#if ENABLE(PARALLEL_GC)
    5656void registerGCThread();
    57 bool isMainThreadOrGCThread();
     57WTF_EXPORT_PRIVATE bool isMainThreadOrGCThread();
    5858#elif PLATFORM(MAC)
    5959bool isMainThreadOrGCThread();
    … …  
    7171// to the process's main thread, and not necessarily the thread that calls this
    7272// function. It should only be used as a legacy aid for Mac WebKit.
    73 void initializeMainThreadToProcessMainThread();
     73WTF_EXPORT_PRIVATE void initializeMainThreadToProcessMainThread();
    7474void initializeMainThreadToProcessMainThreadPlatform();
    7575#endif

  • trunk/Source/JavaScriptCore/wtf/MetaAllocator.h

    r95901 r104900  
    4848public:
    4949   
    50     MetaAllocator(size_t allocationGranule);
     50    WTF_EXPORT_PRIVATE MetaAllocator(size_t allocationGranule);
    5151   
    5252    virtual ~MetaAllocator();
    5353   
    54     PassRefPtr<MetaAllocatorHandle> allocate(size_t sizeInBytes);
     54    WTF_EXPORT_PRIVATE PassRefPtr<MetaAllocatorHandle> allocate(size_t sizeInBytes);
    5555   
    5656    // Non-atomic methods for getting allocator statistics.
    … …  
    7070    // the constructor if you wish to operate the allocator within a
    7171    // fixed pool.
    72     void addFreshFreeSpace(void* start, size_t sizeInBytes);
     72    WTF_EXPORT_PRIVATE void addFreshFreeSpace(void* start, size_t sizeInBytes);
    7373
    7474    // This is meant only for implementing tests. Never call this in release
    7575    // builds.
    76     size_t debugFreeSpaceSize();
     76    WTF_EXPORT_PRIVATE size_t debugFreeSpaceSize();
    7777   
    7878#if ENABLE(META_ALLOCATOR_PROFILE)
    … …  
    128128   
    129129    FreeSpaceNode* allocFreeSpaceNode();
    130     void freeFreeSpaceNode(FreeSpaceNode*);
     130    WTF_EXPORT_PRIVATE void freeFreeSpaceNode(FreeSpaceNode*);
    131131   
    132132    size_t m_allocationGranule;

  • trunk/Source/JavaScriptCore/wtf/MetaAllocatorHandle.h

    r99382 r104900  
    5151   
    5252public:
    53     ~MetaAllocatorHandle();
     53    WTF_EXPORT_PRIVATE ~MetaAllocatorHandle();
    5454   
    5555    static PassRefPtr<MetaAllocatorHandle> createSelfManagedHandle(void* start, size_t sizeInBytes)
    … …  
    7373    }
    7474       
    75     void shrink(size_t newSizeInBytes);
     75    WTF_EXPORT_PRIVATE void shrink(size_t newSizeInBytes);
    7676   
    7777    bool isManaged()

  • trunk/Source/JavaScriptCore/wtf/OSAllocator.h

    r97557 r104900  
    4747    // the memory must all currently be in a decommitted state.
    4848    static void* reserveUncommitted(size_t, Usage = UnknownUsage, bool writable = true, bool executable = false, bool includesGuardPages = false);
    49     static void releaseDecommitted(void*, size_t);
     49    WTF_EXPORT_PRIVATE static void releaseDecommitted(void*, size_t);
    5050
    5151    // These methods are symmetric; they commit or decommit a region of VM (uncommitted VM should
    … …  
    5858    // decommitAndRelease should be called on a region of VM allocated by a single reservation,
    5959    // the memory must all currently be in a committed state.
    60     static void* reserveAndCommit(size_t, Usage = UnknownUsage, bool writable = true, bool executable = false, bool includesGuardPages = false);
     60    WTF_EXPORT_PRIVATE static void* reserveAndCommit(size_t, Usage = UnknownUsage, bool writable = true, bool executable = false, bool includesGuardPages = false);
    6161    static void decommitAndRelease(void* base, size_t size);
    6262

  • trunk/Source/JavaScriptCore/wtf/PageBlock.h

    r95901 r104900  
    2929namespace WTF {
    3030
    31 size_t pageSize();
     31WTF_EXPORT_PRIVATE size_t pageSize();
    3232inline bool isPageAligned(void* address) { return !(reinterpret_cast<intptr_t>(address) & (pageSize() - 1)); }
    3333inline bool isPageAligned(size_t size) { return !(size & (pageSize() - 1)); }

  • trunk/Source/JavaScriptCore/wtf/RandomNumber.h

    r95901 r104900  
    3131    // Returns a pseudo-random number in the range [0, 1), attempts to be
    3232    // cryptographically secure if possible on the target platform
    33     double randomNumber();
     33    WTF_EXPORT_PRIVATE double randomNumber();
    3434
    3535}

  • trunk/Source/JavaScriptCore/wtf/RefCountedLeakCounter.h

    r95901 r104900  
    2828   
    2929    struct RefCountedLeakCounter {
    30         static void suppressMessages(const char*);
    31         static void cancelMessageSuppression(const char*);
     30        WTF_EXPORT_PRIVATE static void suppressMessages(const char*);
     31        WTF_EXPORT_PRIVATE static void cancelMessageSuppression(const char*);
    3232       
    33         explicit RefCountedLeakCounter(const char* description);
    34         ~RefCountedLeakCounter();
     33        WTF_EXPORT_PRIVATE explicit RefCountedLeakCounter(const char* description);
     34        WTF_EXPORT_PRIVATE ~RefCountedLeakCounter();
    3535
    36         void increment();
    37         void decrement();
     36        WTF_EXPORT_PRIVATE void increment();
     37        WTF_EXPORT_PRIVATE void decrement();
    3838
    3939#ifndef NDEBUG

  • trunk/Source/JavaScriptCore/wtf/SHA1.h

    r95901 r104900  
    3838class SHA1 {
    3939public:
    40     SHA1();
     40    WTF_EXPORT_PRIVATE SHA1();
    4141
    4242    void addBytes(const Vector<uint8_t>& input)
    … …  
    4444        addBytes(input.data(), input.size());
    4545    }
    46     void addBytes(const uint8_t* input, size_t length);
     46    WTF_EXPORT_PRIVATE void addBytes(const uint8_t* input, size_t length);
    4747
    4848    // computeHash has a side effect of resetting the state of the object.
    49     void computeHash(Vector<uint8_t, 20>&);
     49    WTF_EXPORT_PRIVATE void computeHash(Vector<uint8_t, 20>&);
    5050
    5151private:

  • trunk/Source/JavaScriptCore/wtf/Threading.cpp

    r95901 r104900  
    9090// compatibility. Use the 3-argument version of createThread above.
    9191
    92 ThreadIdentifier createThread(ThreadFunction entryPoint, void* data);
     92WTF_EXPORT_PRIVATE ThreadIdentifier createThread(ThreadFunction entryPoint, void* data);
    9393
    9494ThreadIdentifier createThread(ThreadFunction entryPoint, void* data)

  • trunk/Source/JavaScriptCore/wtf/Threading.h

    r92068 r104900  
    8484// Darwin is an exception to this rule: it is OK to call it from any thread, the only
    8585// requirement is that the calls are not reentrant.
    86 void initializeThreading();
     86WTF_EXPORT_PRIVATE void initializeThreading();
    8787
    8888// Returns 0 if thread creation failed.
    8989// The thread name must be a literal since on some platforms it's passed in to the thread.
    90 ThreadIdentifier createThread(ThreadFunction, void*, const char* threadName);
     90WTF_EXPORT_PRIVATE ThreadIdentifier createThread(ThreadFunction, void*, const char* threadName);
    9191
    9292// Internal platform-specific createThread implementation.
    … …  
    9797void initializeCurrentThreadInternal(const char* threadName);
    9898
    99 ThreadIdentifier currentThread();
    100 int waitForThreadCompletion(ThreadIdentifier, void**);
    101 void detachThread(ThreadIdentifier);
     99WTF_EXPORT_PRIVATE ThreadIdentifier currentThread();
     100WTF_EXPORT_PRIVATE int waitForThreadCompletion(ThreadIdentifier, void**);
     101WTF_EXPORT_PRIVATE void detachThread(ThreadIdentifier);
    102102
    103 void yield();
     103WTF_EXPORT_PRIVATE void yield();
    104104
    105 void lockAtomicallyInitializedStaticMutex();
    106 void unlockAtomicallyInitializedStaticMutex();
     105WTF_EXPORT_PRIVATE void lockAtomicallyInitializedStaticMutex();
     106WTF_EXPORT_PRIVATE void unlockAtomicallyInitializedStaticMutex();
    107107
    108108} // namespace WTF

  • trunk/Source/JavaScriptCore/wtf/ThreadingPrimitives.h

    r101477 r104900  
    8383    WTF_MAKE_NONCOPYABLE(Mutex); WTF_MAKE_FAST_ALLOCATED;
    8484public:
    85     Mutex();
    86     ~Mutex();
     85    WTF_EXPORT_PRIVATE Mutex();
     86    WTF_EXPORT_PRIVATE ~Mutex();
    8787
    88     void lock();
    89     bool tryLock();
    90     void unlock();
     88    WTF_EXPORT_PRIVATE void lock();
     89    WTF_EXPORT_PRIVATE bool tryLock();
     90    WTF_EXPORT_PRIVATE void unlock();
    9191
    9292public:
    … …  
    119119    WTF_MAKE_NONCOPYABLE(ThreadCondition);
    120120public:
    121     ThreadCondition();
    122     ~ThreadCondition();
     121    WTF_EXPORT_PRIVATE ThreadCondition();
     122    WTF_EXPORT_PRIVATE ~ThreadCondition();
    123123   
    124     void wait(Mutex& mutex);
     124    WTF_EXPORT_PRIVATE void wait(Mutex& mutex);
    125125    // Returns true if the condition was signaled before absoluteTime, false if the absoluteTime was reached or is in the past.
    126126    // The absoluteTime is in seconds, starting on January 1, 1970. The time is assumed to use the same time zone as WTF::currentTime().
    127     bool timedWait(Mutex&, double absoluteTime);
    128     void signal();
    129     void broadcast();
     127    WTF_EXPORT_PRIVATE bool timedWait(Mutex&, double absoluteTime);
     128    WTF_EXPORT_PRIVATE void signal();
     129    WTF_EXPORT_PRIVATE void broadcast();
    130130   
    131131private:

  • trunk/Source/JavaScriptCore/wtf/WTFThreadData.h

    r102849 r104900  
    7979    WTF_MAKE_NONCOPYABLE(WTFThreadData);
    8080public:
    81     WTFThreadData();
    82     ~WTFThreadData();
     81    WTF_EXPORT_PRIVATE WTFThreadData();
     82    WTF_EXPORT_PRIVATE ~WTFThreadData();
    8383
    8484    AtomicStringTable* atomicStringTable()

  • trunk/Source/JavaScriptCore/wtf/dtoa.h

    r101056 r104900  
    3232typedef char DtoaBuffer[80];
    3333
    34 void dtoa(DtoaBuffer result, double dd, bool& sign, int& exponent, unsigned& precision);
    35 void dtoaRoundSF(DtoaBuffer result, double dd, int ndigits, bool& sign, int& exponent, unsigned& precision);
    36 void dtoaRoundDP(DtoaBuffer result, double dd, int ndigits, bool& sign, int& exponent, unsigned& precision);
     34WTF_EXPORT_PRIVATE void dtoa(DtoaBuffer result, double dd, bool& sign, int& exponent, unsigned& precision);
     35WTF_EXPORT_PRIVATE void dtoaRoundSF(DtoaBuffer result, double dd, int ndigits, bool& sign, int& exponent, unsigned& precision);
     36WTF_EXPORT_PRIVATE void dtoaRoundDP(DtoaBuffer result, double dd, int ndigits, bool& sign, int& exponent, unsigned& precision);
    3737
    3838// s00: input string. Must not be 0 and must be terminated by 0.
    3939// se: *se will have the last consumed character position + 1.
    40 double strtod(const char* s00, char** se);
     40WTF_EXPORT_PRIVATE double strtod(const char* s00, char** se);
    4141
    4242// Size = 80 for sizeof(DtoaBuffer) + some sign bits, decimal point, 'e', exponent digits.
    … …  
    4444typedef char NumberToStringBuffer[NumberToStringBufferLength];
    4545typedef UChar NumberToUStringBuffer[NumberToStringBufferLength];
    46 const char* numberToString(double, NumberToStringBuffer);
     46WTF_EXPORT_PRIVATE const char* numberToString(double, NumberToStringBuffer);
    4747const char* numberToFixedPrecisionString(double, unsigned significantFigures, NumberToStringBuffer, bool truncateTrailingZeros = false);
    4848const char* numberToFixedWidthString(double, unsigned decimalPlaces, NumberToStringBuffer);

  • trunk/Source/JavaScriptCore/wtf/text/AtomicString.h

    r102849 r104900  
    3939class AtomicString {
    4040public:
    41     static void init();
     41    WTF_EXPORT_PRIVATE static void init();
    4242
    4343    AtomicString() { }
    … …  
    5555    bool isHashTableDeletedValue() const { return m_string.isHashTableDeletedValue(); }
    5656
    57     static AtomicStringImpl* find(const UChar* s, unsigned length, unsigned existingHash);
     57    WTF_EXPORT_PRIVATE static AtomicStringImpl* find(const UChar* s, unsigned length, unsigned existingHash);
    5858
    5959    operator const String&() const { return m_string; }
    … …  
    8484        { return m_string.endsWith(s, caseSensitive); }
    8585   
    86     AtomicString lower() const;
     86    WTF_EXPORT_PRIVATE AtomicString lower() const;
    8787    AtomicString upper() const { return AtomicString(impl()->upper()); }
    8888   
    … …  
    121121    String m_string;
    122122   
    123     static PassRefPtr<StringImpl> add(const LChar*);
     123    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> add(const LChar*);
    124124    ALWAYS_INLINE static PassRefPtr<StringImpl> add(const char* s) { return add(reinterpret_cast<const LChar*>(s)); };
    125     static PassRefPtr<StringImpl> add(const UChar*, unsigned length);
     125    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> add(const UChar*, unsigned length);
    126126    ALWAYS_INLINE static PassRefPtr<StringImpl> add(const char* s, unsigned length) { return add(reinterpret_cast<const char*>(s), length); };
    127     static PassRefPtr<StringImpl> add(const UChar*, unsigned length, unsigned existingHash);
    128     static PassRefPtr<StringImpl> add(const UChar*);
     127    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> add(const UChar*, unsigned length, unsigned existingHash);
     128    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> add(const UChar*);
    129129    ALWAYS_INLINE PassRefPtr<StringImpl> add(StringImpl* r)
    130130    {
    … …  
    133133        return addSlowCase(r);
    134134    }
    135     static PassRefPtr<StringImpl> addSlowCase(StringImpl*);
    136     static AtomicString fromUTF8Internal(const char*, const char*);
     135    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> addSlowCase(StringImpl*);
     136    WTF_EXPORT_PRIVATE static AtomicString fromUTF8Internal(const char*, const char*);
    137137};
    138138

  • trunk/Source/JavaScriptCore/wtf/text/CString.h

    r95901 r104900  
    5353public:
    5454    CString() { }
    55     CString(const char*);
    56     CString(const char*, size_t length);
     55    WTF_EXPORT_PRIVATE CString(const char*);
     56    WTF_EXPORT_PRIVATE CString(const char*, size_t length);
    5757    CString(CStringBuffer* buffer) : m_buffer(buffer) { }
    58     static CString newUninitialized(size_t length, char*& characterBuffer);
     58    WTF_EXPORT_PRIVATE static CString newUninitialized(size_t length, char*& characterBuffer);
    5959
    6060    const char* data() const
    … …  
    6262        return m_buffer ? m_buffer->data() : 0;
    6363    }
    64     char* mutableData();
     64    WTF_EXPORT_PRIVATE char* mutableData();
    6565    size_t length() const
    6666    {
    … …  
    7878};
    7979
    80 bool operator==(const CString& a, const CString& b);
     80WTF_EXPORT_PRIVATE bool operator==(const CString& a, const CString& b);
    8181inline bool operator!=(const CString& a, const CString& b) { return !(a == b); }
    8282

  • trunk/Source/JavaScriptCore/wtf/text/StringBuilder.h

    r102298 r104900  
    4242    }
    4343
    44     void append(const UChar*, unsigned);
    45     void append(const LChar*, unsigned);
     44    WTF_EXPORT_PRIVATE void append(const UChar*, unsigned);
     45    WTF_EXPORT_PRIVATE void append(const LChar*, unsigned);
    4646
    4747    ALWAYS_INLINE void append(const char* characters, unsigned length) { append(reinterpret_cast<const LChar*>(characters), length); }
    … …  
    128128    bool isEmpty() const { return !length(); }
    129129
    130     void reserveCapacity(unsigned newCapacity);
    131 
    132     void resize(unsigned newSize);
    133 
    134     void shrinkToFit();
     130    WTF_EXPORT_PRIVATE void reserveCapacity(unsigned newCapacity);
     131
     132    WTF_EXPORT_PRIVATE void resize(unsigned newSize);
     133
     134    WTF_EXPORT_PRIVATE void shrinkToFit();
    135135
    136136    UChar operator[](unsigned i) const
    … …  
    201201    template <typename CharType>
    202202    ALWAYS_INLINE CharType * getBufferCharacters();
    203     void reifyString();
     203    WTF_EXPORT_PRIVATE void reifyString();
    204204
    205205    unsigned m_length;

  • trunk/Source/JavaScriptCore/wtf/text/StringImpl.h

    r104315 r104900  
    191191
    192192public:
    193     ~StringImpl();
    194 
    195     static PassRefPtr<StringImpl> create(const UChar*, unsigned length);
     193    WTF_EXPORT_PRIVATE ~StringImpl();
     194
     195    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> create(const UChar*, unsigned length);
    196196    static PassRefPtr<StringImpl> create(const LChar*, unsigned length);
    197197    ALWAYS_INLINE static PassRefPtr<StringImpl> create(const char* s, unsigned length) { return create(reinterpret_cast<const LChar*>(s), length); }
    198     static PassRefPtr<StringImpl> create(const LChar*);
     198    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> create(const LChar*);
    199199    ALWAYS_INLINE static PassRefPtr<StringImpl> create(const char* s) { return create(reinterpret_cast<const LChar*>(s)); }
    200200
    … …  
    227227
    228228    static PassRefPtr<StringImpl> createUninitialized(unsigned length, LChar*& data);
    229     static PassRefPtr<StringImpl> createUninitialized(unsigned length, UChar*& data);
     229    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> createUninitialized(unsigned length, UChar*& data);
    230230    template <typename T> static ALWAYS_INLINE PassRefPtr<StringImpl> tryCreateUninitialized(unsigned length, T*& output)
    231231    {
    … …  
    276276
    277277    static PassRefPtr<StringImpl> adopt(StringBuffer<LChar>& buffer);
    278     static PassRefPtr<StringImpl> adopt(StringBuffer<UChar>& buffer);
     278    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> adopt(StringBuffer<UChar>& buffer);
    279279
    280280    unsigned length() const { return m_length; }
    … …  
    309309
    310310    bool has16BitShadow() const { return m_hashAndFlags & s_hashFlagHas16BitShadow; }
    311     void upconvertCharacters(unsigned, unsigned) const;
     311    WTF_EXPORT_PRIVATE void upconvertCharacters(unsigned, unsigned) const;
    312312    bool isIdentifier() const { return m_hashAndFlags & s_hashFlagIsIdentifier; }
    313313    void setIsIdentifier(bool isIdentifier)
    … …  
    394394    }
    395395
    396     static StringImpl* empty();
     396    WTF_EXPORT_PRIVATE static StringImpl* empty();
    397397
    398398    // FIXME: Does this really belong in StringImpl?
    … …  
    429429    PassRefPtr<StringImpl> isolatedCopy() const;
    430430
    431     PassRefPtr<StringImpl> substring(unsigned pos, unsigned len = UINT_MAX);
     431    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> substring(unsigned pos, unsigned len = UINT_MAX);
    432432
    433433    UChar operator[](unsigned i) const
    … …  
    438438        return m_data16[i];
    439439    }
    440     UChar32 characterStartingAt(unsigned);
    441 
    442     bool containsOnlyWhitespace();
     440    WTF_EXPORT_PRIVATE UChar32 characterStartingAt(unsigned);
     441
     442    WTF_EXPORT_PRIVATE bool containsOnlyWhitespace();
    443443
    444444    int toIntStrict(bool* ok = 0, int base = 10);
    … …  
    448448    intptr_t toIntPtrStrict(bool* ok = 0, int base = 10);
    449449
    450     int toInt(bool* ok = 0); // ignores trailing garbage
     450    WTF_EXPORT_PRIVATE int toInt(bool* ok = 0); // ignores trailing garbage
    451451    unsigned toUInt(bool* ok = 0); // ignores trailing garbage
    452452    int64_t toInt64(bool* ok = 0); // ignores trailing garbage
    … …  
    457457    float toFloat(bool* ok = 0, bool* didReadNumber = 0);
    458458
    459     PassRefPtr<StringImpl> lower();
    460     PassRefPtr<StringImpl> upper();
    461 
    462     PassRefPtr<StringImpl> fill(UChar);
     459    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> lower();
     460    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> upper();
     461
     462    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> fill(UChar);
    463463    // FIXME: Do we need fill(char) or can we just do the right thing if UChar is ASCII?
    464464    PassRefPtr<StringImpl> foldCase();
    … …  
    466466    PassRefPtr<StringImpl> stripWhiteSpace();
    467467    PassRefPtr<StringImpl> stripWhiteSpace(IsWhiteSpaceFunctionPtr);
    468     PassRefPtr<StringImpl> simplifyWhiteSpace();
     468    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> simplifyWhiteSpace();
    469469    PassRefPtr<StringImpl> simplifyWhiteSpace(IsWhiteSpaceFunctionPtr);
    470470
    … …  
    473473    ALWAYS_INLINE PassRefPtr<StringImpl> removeCharacters(const CharType* characters, CharacterMatchFunctionPtr);
    474474
    475     size_t find(UChar, unsigned index = 0);
    476     size_t find(CharacterMatchFunctionPtr, unsigned index = 0);
     475    WTF_EXPORT_PRIVATE size_t find(UChar, unsigned index = 0);
     476    WTF_EXPORT_PRIVATE size_t find(CharacterMatchFunctionPtr, unsigned index = 0);
    477477    size_t find(const LChar*, unsigned index = 0);
    478478    ALWAYS_INLINE size_t find(const char* s, unsigned index = 0) { return find(reinterpret_cast<const LChar*>(s), index); };
    479     size_t find(StringImpl*, unsigned index = 0);
     479    WTF_EXPORT_PRIVATE size_t find(StringImpl*, unsigned index = 0);
    480480    size_t findIgnoringCase(const LChar*, unsigned index = 0);
    481481    ALWAYS_INLINE size_t findIgnoringCase(const char* s, unsigned index = 0) { return findIgnoringCase(reinterpret_cast<const LChar*>(s), index); };
    482     size_t findIgnoringCase(StringImpl*, unsigned index = 0);
    483 
    484     size_t reverseFind(UChar, unsigned index = UINT_MAX);
    485     size_t reverseFind(StringImpl*, unsigned index = UINT_MAX);
    486     size_t reverseFindIgnoringCase(StringImpl*, unsigned index = UINT_MAX);
     482    WTF_EXPORT_PRIVATE size_t findIgnoringCase(StringImpl*, unsigned index = 0);
     483
     484    WTF_EXPORT_PRIVATE size_t reverseFind(UChar, unsigned index = UINT_MAX);
     485    WTF_EXPORT_PRIVATE size_t reverseFind(StringImpl*, unsigned index = UINT_MAX);
     486    WTF_EXPORT_PRIVATE size_t reverseFindIgnoringCase(StringImpl*, unsigned index = UINT_MAX);
    487487
    488488    bool startsWith(StringImpl* str, bool caseSensitive = true) { return (caseSensitive ? reverseFind(str, 0) : reverseFindIgnoringCase(str, 0)) == 0; }
    489     bool endsWith(StringImpl*, bool caseSensitive = true);
    490 
    491     PassRefPtr<StringImpl> replace(UChar, UChar);
    492     PassRefPtr<StringImpl> replace(UChar, StringImpl*);
    493     PassRefPtr<StringImpl> replace(StringImpl*, StringImpl*);
    494     PassRefPtr<StringImpl> replace(unsigned index, unsigned len, StringImpl*);
    495 
    496     WTF::Unicode::Direction defaultWritingDirection(bool* hasStrongDirectionality = 0);
     489    WTF_EXPORT_PRIVATE bool endsWith(StringImpl*, bool caseSensitive = true);
     490
     491    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> replace(UChar, UChar);
     492    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> replace(UChar, StringImpl*);
     493    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> replace(StringImpl*, StringImpl*);
     494    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> replace(unsigned index, unsigned len, StringImpl*);
     495
     496    WTF_EXPORT_PRIVATE WTF::Unicode::Direction defaultWritingDirection(bool* hasStrongDirectionality = 0);
    497497
    498498#if USE(CF)
    … …  
    511511    template <class UCharPredicate> PassRefPtr<StringImpl> stripMatchedCharacters(UCharPredicate);
    512512    template <typename CharType, class UCharPredicate> PassRefPtr<StringImpl> simplifyMatchedCharactersToSpace(UCharPredicate);
    513     NEVER_INLINE const UChar* getData16SlowCase() const;
    514     NEVER_INLINE unsigned hashSlowCase() const;
     513    WTF_EXPORT_PRIVATE NEVER_INLINE const UChar* getData16SlowCase() const;
     514    WTF_EXPORT_PRIVATE NEVER_INLINE unsigned hashSlowCase() const;
    515515
    516516    // The bottom bit in the ref count indicates a static (immortal) string.
    … …  
    551551ALWAYS_INLINE const UChar* StringImpl::getCharacters<UChar>() const { return characters16(); }
    552552
    553 bool equal(const StringImpl*, const StringImpl*);
    554 bool equal(const StringImpl*, const LChar*);
     553WTF_EXPORT_PRIVATE bool equal(const StringImpl*, const StringImpl*);
     554WTF_EXPORT_PRIVATE bool equal(const StringImpl*, const LChar*);
    555555inline bool equal(const StringImpl* a, const char* b) { return equal(a, reinterpret_cast<const LChar*>(b)); }
    556 bool equal(const StringImpl*, const LChar*, unsigned);
     556WTF_EXPORT_PRIVATE bool equal(const StringImpl*, const LChar*, unsigned);
    557557inline bool equal(const StringImpl* a, const char* b, unsigned length) { return equal(a, reinterpret_cast<const LChar*>(b), length); }
    558558inline bool equal(const LChar* a, StringImpl* b) { return equal(b, a); }
    559559inline bool equal(const char* a, StringImpl* b) { return equal(b, reinterpret_cast<const LChar*>(a)); }
    560 bool equal(const StringImpl*, const UChar*, unsigned);
     560WTF_EXPORT_PRIVATE bool equal(const StringImpl*, const UChar*, unsigned);
    561561
    562562// Do comparisons 8 or 4 bytes-at-a-time on architectures where it's safe.
    … …  
    716716}
    717717
    718 bool equalIgnoringCase(StringImpl*, StringImpl*);
    719 bool equalIgnoringCase(StringImpl*, const LChar*);
     718WTF_EXPORT_PRIVATE bool equalIgnoringCase(StringImpl*, StringImpl*);
     719WTF_EXPORT_PRIVATE bool equalIgnoringCase(StringImpl*, const LChar*);
    720720inline bool equalIgnoringCase(const LChar* a, StringImpl* b) { return equalIgnoringCase(b, a); }
    721 bool equalIgnoringCase(const UChar*, const LChar*, unsigned);
     721WTF_EXPORT_PRIVATE bool equalIgnoringCase(const UChar*, const LChar*, unsigned);
    722722inline bool equalIgnoringCase(const UChar* a, const char* b, unsigned length) { return equalIgnoringCase(a, reinterpret_cast<const LChar*>(b), length); }
    723723inline bool equalIgnoringCase(const LChar* a, const UChar* b, unsigned length) { return equalIgnoringCase(b, a, length); }
    724724inline bool equalIgnoringCase(const char* a, const UChar* b, unsigned length) { return equalIgnoringCase(b, reinterpret_cast<const LChar*>(a), length); }
    725725
    726 bool equalIgnoringNullity(StringImpl*, StringImpl*);
     726WTF_EXPORT_PRIVATE bool equalIgnoringNullity(StringImpl*, StringImpl*);
    727727
    728728template<size_t inlineCapacity>
    … …  
    736736}
    737737
    738 int codePointCompare(const StringImpl*, const StringImpl*);
     738WTF_EXPORT_PRIVATE int codePointCompare(const StringImpl*, const StringImpl*);
    739739
    740740static inline bool isSpaceOrNewline(UChar c)

  • trunk/Source/JavaScriptCore/wtf/text/WTFString.h

    r104270 r104900  
    7575
    7676int charactersToInt(const LChar*, size_t, bool* ok = 0); // ignores trailing garbage
    77 int charactersToInt(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
     77WTF_EXPORT_PRIVATE int charactersToInt(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
    7878unsigned charactersToUInt(const LChar*, size_t, bool* ok = 0); // ignores trailing garbage
    7979unsigned charactersToUInt(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
    … …  
    8888WTF_EXPORT_PRIVATE double charactersToDouble(const UChar*, size_t, bool* ok = 0, bool* didReadNumber = 0);
    8989float charactersToFloat(const LChar*, size_t, bool* ok = 0, bool* didReadNumber = 0);
    90 float charactersToFloat(const UChar*, size_t, bool* ok = 0, bool* didReadNumber = 0);
     90WTF_EXPORT_PRIVATE float charactersToFloat(const UChar*, size_t, bool* ok = 0, bool* didReadNumber = 0);
    9191
    9292enum FloatConversionFlags {

  • trunk/Source/JavaScriptCore/wtf/unicode/Collator.h

    r76248 r104900  
    4646        enum Result { Equal = 0, Greater = 1, Less = -1 };
    4747
    48         Collator(const char* locale); // Parsing is lenient; e.g. language identifiers (such as "en-US") are accepted, too.
    49         ~Collator();
    50         void setOrderLowerFirst(bool);
     48        WTF_EXPORT_PRIVATE Collator(const char* locale); // Parsing is lenient; e.g. language identifiers (such as "en-US") are accepted, too.
     49        WTF_EXPORT_PRIVATE ~Collator();
     50        WTF_EXPORT_PRIVATE void setOrderLowerFirst(bool);
    5151
    5252        static PassOwnPtr<Collator> userDefault();
    5353
    54         Result collate(const ::UChar*, size_t, const ::UChar*, size_t) const;
     54        WTF_EXPORT_PRIVATE Result collate(const ::UChar*, size_t, const ::UChar*, size_t) const;
    5555
    5656    private:

  • trunk/Source/JavaScriptCore/wtf/unicode/UTF8.h

    r100405 r104900  
    6363    // they constitute an error.
    6464
    65     ConversionResult convertUTF8ToUTF16(
     65    WTF_EXPORT_PRIVATE ConversionResult convertUTF8ToUTF16(
    6666                    const char** sourceStart, const char* sourceEnd,
    6767                    UChar** targetStart, UChar* targetEnd, bool strict = true);
    … …  
    7171                    char** targetStart, char* targetEnd);
    7272
    73     ConversionResult convertUTF16ToUTF8(
     73    WTF_EXPORT_PRIVATE ConversionResult convertUTF16ToUTF8(
    7474                    const UChar** sourceStart, const UChar* sourceEnd,
    7575                    char** targetStart, char* targetEnd, bool strict = true);

  • trunk/Source/JavaScriptCore/yarr/Yarr.h

    r95901 r104900  
    6363};
    6464
    65 PassOwnPtr<BytecodePattern> byteCompile(YarrPattern&, BumpPointerAllocator*);
    66 int interpret(BytecodePattern*, const UString& input, unsigned start, unsigned length, int* output);
     65JS_EXPORT_PRIVATE PassOwnPtr<BytecodePattern> byteCompile(YarrPattern&, BumpPointerAllocator*);
     66JS_EXPORT_PRIVATE int interpret(BytecodePattern*, const UString& input, unsigned start, unsigned length, int* output);
    6767
    6868} } // namespace JSC::Yarr

  • trunk/Source/JavaScriptCore/yarr/YarrPattern.h

    r98316 r104900  
    317317
    318318struct YarrPattern {
    319     YarrPattern(const UString& pattern, bool ignoreCase, bool multiline, const char** error);
     319    JS_EXPORT_PRIVATE YarrPattern(const UString& pattern, bool ignoreCase, bool multiline, const char** error);
    320320
    321321    ~YarrPattern()
Note: See TracChangeset for help on using the changeset viewer.