Attachment 87051 Details for Bug 27551 – Step 2, part 1, third try: More Win build fixes.

[patch] Step 2, part 1, third try: More Win build fixes.

jscore_exports_step2_try3.patch (text/plain), 112.23 KB, created by Kevin Ollivier on 2011-03-26 18:19:08 PDT

(hide)

Description:

Filename:

MIME Type:

Creator: Kevin Ollivier

Created: 2011-03-26 18:19:08 PDT

Size: 112.23 KB

patch

obsolete

>Index: Tools/wx/build/settings.py
>===================================================================
>--- Tools/wx/build/settings.py	(revision 82010)
>+++ Tools/wx/build/settings.py	(working copy)
>@@ -283,7 +283,7 @@
>     if build_port == "wx":
>         update_wx_deps(conf, wk_root, msvc_version)
> 
>-        conf.env.append_value('CXXDEFINES', ['BUILDING_WX__=1', 'JS_NO_EXPORT'])
>+        conf.env.append_value('CXXDEFINES', ['BUILDING_WX__=1'])
> 
>         if building_on_win32:
>             conf.env.append_value('LIBPATH', os.path.join(msvclibs_dir, 'lib'))
>@@ -295,6 +295,8 @@
>             conf.env['CPPPATH_WX'] = wxincludes
>             conf.env['LIB_WX'] = wxlibs
>             conf.env['LIBPATH_WX'] = wxlibpaths
>+        else:
>+            conf.env.append_value('CXXFLAGS', ['-fvisibility=hidden'])
> 
>     if sys.platform.startswith('darwin'):
>         conf.env['LIB_ICU'] = ['icucore']
>Index: Tools/WebKitTestRunner/config.h
>===================================================================
>--- Tools/WebKitTestRunner/config.h	(revision 82010)
>+++ Tools/WebKitTestRunner/config.h	(working copy)
>@@ -49,8 +49,8 @@
> #define WEBKIT_EXPORTDATA
> #endif
> 
>-#define WTF_EXPORT_PRIVATE JS_EXPORTDATA
>-#define JS_EXPORT_PRIVATE JS_EXPORTDATA
>+#define WTF_EXPORT_PRIVATE
>+#define JS_EXPORT_PRIVATE
> 
> #endif /* USE(EXPORT_MACROS) */
> 
>Index: Tools/WebKitAPITest/config.h
>===================================================================
>--- Tools/WebKitAPITest/config.h	(revision 82010)
>+++ Tools/WebKitAPITest/config.h	(working copy)
>@@ -49,8 +49,8 @@
> #define WEBKIT_EXPORTDATA
> #endif
> 
>-#define WTF_EXPORT_PRIVATE JS_EXPORTDATA
>-#define JS_EXPORT_PRIVATE JS_EXPORTDATA
>+#define WTF_EXPORT_PRIVATE
>+#define JS_EXPORT_PRIVATE
> 
> #endif /* USE(EXPORT_MACROS) */
> 
>Index: Tools/DumpRenderTree/config.h
>===================================================================
>--- Tools/DumpRenderTree/config.h	(revision 82010)
>+++ Tools/DumpRenderTree/config.h	(working copy)
>@@ -48,8 +48,8 @@
> #define WEBKIT_EXPORTDATA
> #endif
> 
>-#define WTF_EXPORT_PRIVATE JS_EXPORTDATA
>-#define JS_EXPORT_PRIVATE JS_EXPORTDATA
>+#define WTF_EXPORT_PRIVATE
>+#define JS_EXPORT_PRIVATE
> 
> #endif /* USE(EXPORT_MACROS) */
> 
>Index: Tools/ChangeLog
>===================================================================
>--- Tools/ChangeLog	(revision 82044)
>+++ Tools/ChangeLog	(working copy)
>@@ -1,3 +1,16 @@
>+2011-03-26  Kevin Ollivier  <kevino@theolliviers.com>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Add export macros to all exported JSCore methods, and enable them for the wx port.
>+
>+        https://bugs.webkit.org/show_bug.cgi?id=27551
>+
>+        * DumpRenderTree/config.h:
>+        * WebKitAPITest/config.h:
>+        * WebKitTestRunner/config.h:
>+        * wx/build/settings.py:
>+
> 2011-03-23  Martin Robinson  <mrobinson@igalia.com>
> 
>         Reviewed by Xan Lopez.
>Index: Source/JavaScriptCore/runtime/RegExp.h
>===================================================================
>--- Source/JavaScriptCore/runtime/RegExp.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/RegExp.h	(working copy)
>@@ -33,12 +33,12 @@
>     struct RegExpRepresentation;
>     class JSGlobalData;
> 
>-    RegExpFlags regExpFlags(const UString&);
>+    JS_EXPORT_PRIVATE RegExpFlags regExpFlags(const UString&);
> 
>     class RegExp : public RefCounted<RegExp> {
>     public:
>-        static PassRefPtr<RegExp> create(JSGlobalData* globalData, const UString& pattern, RegExpFlags);
>-        ~RegExp();
>+        JS_EXPORT_PRIVATE static PassRefPtr<RegExp> create(JSGlobalData*, const UString& pattern, RegExpFlags);
>+        JS_EXPORT_PRIVATE ~RegExp();
> 
>         bool global() const { return m_flags & FlagGlobal; }
>         bool ignoreCase() const { return m_flags & FlagIgnoreCase; }
>Index: Source/JavaScriptCore/runtime/Structure.h
>===================================================================
>--- Source/JavaScriptCore/runtime/Structure.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/Structure.h	(working copy)
>@@ -73,11 +73,11 @@
> 
>         static void dumpStatistics();
> 
>-        static PassRefPtr<Structure> addPropertyTransition(Structure*, const Identifier& propertyName, unsigned attributes, JSCell* specificValue, size_t& offset);
>-        static PassRefPtr<Structure> addPropertyTransitionToExistingStructure(Structure*, const Identifier& propertyName, unsigned attributes, JSCell* specificValue, size_t& offset);
>+        JS_EXPORT_PRIVATE static PassRefPtr<Structure> addPropertyTransition(Structure*, const Identifier& propertyName, unsigned attributes, JSCell* specificValue, size_t& offset);
>+        JS_EXPORT_PRIVATE static PassRefPtr<Structure> addPropertyTransitionToExistingStructure(Structure*, const Identifier& propertyName, unsigned attributes, JSCell* specificValue, size_t& offset);
>         static PassRefPtr<Structure> removePropertyTransition(Structure*, const Identifier& propertyName, size_t& offset);
>-        static PassRefPtr<Structure> changePrototypeTransition(Structure*, JSValue prototype);
>-        static PassRefPtr<Structure> despecifyFunctionTransition(Structure*, const Identifier&);
>+        JS_EXPORT_PRIVATE static PassRefPtr<Structure> changePrototypeTransition(Structure*, JSValue prototype);
>+        JS_EXPORT_PRIVATE static PassRefPtr<Structure> despecifyFunctionTransition(Structure*, const Identifier&);
>         static PassRefPtr<Structure> getterSetterTransition(Structure*);
>         static PassRefPtr<Structure> toCacheableDictionaryTransition(Structure*);
>         static PassRefPtr<Structure> toUncacheableDictionaryTransition(Structure*);
>@@ -91,10 +91,10 @@
> 
>         PassRefPtr<Structure> flattenDictionaryStructure(JSGlobalData&, JSObject*);
> 
>-        ~Structure();
>+        JS_EXPORT_PRIVATE ~Structure();
> 
>         // These should be used with caution.  
>-        size_t addPropertyWithoutTransition(const Identifier& propertyName, unsigned attributes, JSCell* specificValue);
>+        JS_EXPORT_PRIVATE size_t addPropertyWithoutTransition(const Identifier& propertyName, unsigned attributes, JSCell* specificValue);
>         size_t removePropertyWithoutTransition(const Identifier& propertyName);
>         void setPrototypeWithoutTransition(JSValue prototype) { m_prototype = prototype; }
>         
>@@ -116,7 +116,7 @@
>         bool isUsingInlineStorage() const;
> 
>         size_t get(const Identifier& propertyName);
>-        size_t get(StringImpl* propertyName, unsigned& attributes, JSCell*& specificValue);
>+        JS_EXPORT_PRIVATE size_t get(StringImpl* propertyName, unsigned& attributes, JSCell*& specificValue);
>         size_t get(const Identifier& propertyName, unsigned& attributes, JSCell*& specificValue)
>         {
>             ASSERT(!propertyName.isNull());
>@@ -133,7 +133,7 @@
>         
>         bool isEmpty() const { return m_propertyTable ? m_propertyTable->isEmpty() : m_offset == noOffset; }
> 
>-        void despecifyDictionaryFunction(const Identifier& propertyName);
>+        JS_EXPORT_PRIVATE void despecifyDictionaryFunction(const Identifier& propertyName);
>         void disableSpecificFunctionTracking() { m_specificFunctionThrashCount = maxSpecificFunctionThrashCount; }
> 
>         void setEnumerationCache(JSGlobalData&, JSPropertyNameIterator* enumerationCache); // Defined in JSPropertyNameIterator.h.
>@@ -161,7 +161,7 @@
>         }
> 
>     private:
>-        Structure(JSValue prototype, const TypeInfo&, unsigned anonymousSlotCount, const ClassInfo*);
>+        JS_EXPORT_PRIVATE Structure(JSValue prototype, const TypeInfo&, unsigned anonymousSlotCount, const ClassInfo*);
>         Structure(const Structure*);
> 
>         static PassRefPtr<Structure> create(const Structure* structure)
>@@ -186,7 +186,7 @@
>         void despecifyAllFunctions();
> 
>         PropertyTable* copyPropertyTable();
>-        void materializePropertyMap();
>+        JS_EXPORT_PRIVATE void materializePropertyMap();
>         void materializePropertyMapIfNecessary()
>         {
>             if (!m_propertyTable && m_previous)
>Index: Source/JavaScriptCore/runtime/JSObject.h
>===================================================================
>--- Source/JavaScriptCore/runtime/JSObject.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/JSObject.h	(working copy)
>@@ -73,11 +73,11 @@
>     typedef WriteBarrierBase<Unknown>* PropertyStorage;
>     typedef const WriteBarrierBase<Unknown>* ConstPropertyStorage;
> 
>-    class JSObject : public JSCell {
>+    class JS_EXPORTDATA JSObject : public JSCell {
>         friend class BatchedTransitionOptimizer;
>         friend class JIT;
>         friend class JSCell;
>-        friend void setUpStaticFunctionSlot(ExecState* exec, const HashEntry* entry, JSObject* thisObj, const Identifier& propertyName, PropertySlot& slot);
>+        friend JS_EXPORT_PRIVATE void setUpStaticFunctionSlot(ExecState*, const HashEntry*, JSObject* thisObj, const Identifier& propertyName, PropertySlot&);
> 
>     public:
>         virtual void markChildren(MarkStack&);
>@@ -247,7 +247,7 @@
> 
>         static size_t offsetOfInlineStorage();
>         
>-        static JS_EXPORTDATA const ClassInfo s_info;
>+        static const ClassInfo s_info;
> 
>     protected:
>         static PassRefPtr<Structure> createStructure(JSGlobalData& globalData, JSValue prototype)
>Index: Source/JavaScriptCore/runtime/RegExpObject.h
>===================================================================
>--- Source/JavaScriptCore/runtime/RegExpObject.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/RegExpObject.h	(working copy)
>@@ -30,7 +30,7 @@
>     public:
>         typedef JSObjectWithGlobalObject Base;
> 
>-        RegExpObject(JSGlobalObject* globalObject, NonNullPassRefPtr<Structure>, NonNullPassRefPtr<RegExp>);
>+        JS_EXPORT_PRIVATE RegExpObject(JSGlobalObject*, NonNullPassRefPtr<Structure>, NonNullPassRefPtr<RegExp>);
>         virtual ~RegExpObject();
> 
>         void setRegExp(PassRefPtr<RegExp> r) { d->regExp = r; }
>Index: Source/JavaScriptCore/runtime/ExceptionHelpers.h
>===================================================================
>--- Source/JavaScriptCore/runtime/ExceptionHelpers.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/ExceptionHelpers.h	(working copy)
>@@ -43,9 +43,9 @@
>     class Node;
>     struct Instruction;
>     
>-    JSObject* createInterruptedExecutionException(JSGlobalData*);
>+    JS_EXPORT_PRIVATE JSObject* createInterruptedExecutionException(JSGlobalData*);
>     JSObject* createTerminatedExecutionException(JSGlobalData*);
>-    JSObject* createStackOverflowError(ExecState*);
>+    JS_EXPORT_PRIVATE JSObject* createStackOverflowError(ExecState*);
>     JSObject* createStackOverflowError(JSGlobalObject*);
>     JSObject* createOutOfMemoryError(JSGlobalObject*);
>     JSObject* createUndefinedVariableError(ExecState*, const Identifier&);
>Index: Source/JavaScriptCore/runtime/JSFunction.h
>===================================================================
>--- Source/JavaScriptCore/runtime/JSFunction.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/JSFunction.h	(working copy)
>@@ -45,12 +45,12 @@
>         typedef JSObjectWithGlobalObject Base;
> 
>     public:
>-        JSFunction(ExecState*, JSGlobalObject*, NonNullPassRefPtr<Structure>, int length, const Identifier&, NativeFunction);
>+        JS_EXPORT_PRIVATE JSFunction(ExecState*, JSGlobalObject*, NonNullPassRefPtr<Structure>, int length, const Identifier&, NativeFunction);
>         JSFunction(ExecState*, JSGlobalObject*, NonNullPassRefPtr<Structure>, int length, const Identifier&, NativeExecutable*);
>         JSFunction(ExecState*, FunctionExecutable*, ScopeChainNode*);
>         virtual ~JSFunction();
> 
>-        const UString& name(ExecState*);
>+        JS_EXPORT_PRIVATE const UString& name(ExecState*);
>         const UString displayName(ExecState*);
>         const UString calculatedDisplayName(ExecState*);
> 
>@@ -89,7 +89,7 @@
>     private:
>         JSFunction(NonNullPassRefPtr<Structure>, VPtrHackExecutable*);
> 
>-        bool isHostFunctionNonInline() const;
>+        JS_EXPORT_PRIVATE bool isHostFunctionNonInline() const;
> 
>         virtual bool getOwnPropertySlot(ExecState*, const Identifier&, PropertySlot&);
>         virtual bool getOwnPropertyDescriptor(ExecState*, const Identifier&, PropertyDescriptor&);
>Index: Source/JavaScriptCore/runtime/ObjectPrototype.h
>===================================================================
>--- Source/JavaScriptCore/runtime/ObjectPrototype.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/ObjectPrototype.h	(working copy)
>@@ -36,7 +36,7 @@
>         bool m_hasNoPropertiesWithUInt32Names;
>     };
> 
>-    EncodedJSValue JSC_HOST_CALL objectProtoFuncToString(ExecState*);
>+    JS_EXPORT_PRIVATE EncodedJSValue JSC_HOST_CALL objectProtoFuncToString(ExecState*);
> 
> } // namespace JSC
> 
>Index: Source/JavaScriptCore/runtime/ArgList.h
>===================================================================
>--- Source/JavaScriptCore/runtime/ArgList.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/ArgList.h	(working copy)
>@@ -144,7 +144,7 @@
>         static void markLists(HeapRootMarker&, ListSet&);
> 
>     private:
>-        void slowAppend(JSValue);
>+        JS_EXPORT_PRIVATE void slowAppend(JSValue);
>         
>         Register* m_buffer;
>         size_t m_size;
>@@ -234,7 +234,7 @@
>         const_iterator begin() const { return m_args; }
>         const_iterator end() const { return m_args + m_argCount; }
> 
>-        void getSlice(int startIndex, ArgList& result) const;
>+        JS_EXPORT_PRIVATE void getSlice(int startIndex, ArgList& result) const;
>     private:
>         JSValue* m_args;
>         size_t m_argCount;
>Index: Source/JavaScriptCore/runtime/JSArray.h
>===================================================================
>--- Source/JavaScriptCore/runtime/JSArray.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/JSArray.h	(working copy)
>@@ -57,7 +57,8 @@
> 
>     enum ArrayCreationMode { CreateCompact, CreateInitialized };
> 
>-    class JSArray : public JSNonFinalObject {
>+    class JS_EXPORTDATA JSArray : public JSNonFinalObject {
>+        friend class JIT;
>         friend class Walker;
> 
>     public:
>@@ -74,7 +75,7 @@
>         virtual bool getOwnPropertyDescriptor(ExecState*, const Identifier&, PropertyDescriptor&);
>         virtual void put(ExecState*, unsigned propertyName, JSValue); // FIXME: Make protected and add setItem.
> 
>-        static JS_EXPORTDATA const ClassInfo s_info;
>+        static const ClassInfo s_info;
>         
>         unsigned length() const { return m_storage->m_length; }
>         void setLength(unsigned); // OK to use on new arrays, but not if it might be a RegExpMatchArray.
>Index: Source/JavaScriptCore/runtime/InternalFunction.h
>===================================================================
>--- Source/JavaScriptCore/runtime/InternalFunction.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/InternalFunction.h	(working copy)
>@@ -31,9 +31,9 @@
> 
>     class FunctionPrototype;
> 
>-    class InternalFunction : public JSObjectWithGlobalObject {
>+    class JS_EXPORTDATA InternalFunction : public JSObjectWithGlobalObject {
>     public:
>-        static JS_EXPORTDATA const ClassInfo s_info;
>+        static const ClassInfo s_info;
> 
>         const UString& name(ExecState*);
>         const UString displayName(ExecState*);
>Index: Source/JavaScriptCore/runtime/Identifier.h
>===================================================================
>--- Source/JavaScriptCore/runtime/Identifier.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/Identifier.h	(working copy)
>@@ -53,15 +53,15 @@
>         
>         CString ascii() const { return m_string.ascii(); }
>         
>-        static Identifier from(ExecState* exec, unsigned y);
>-        static Identifier from(ExecState* exec, int y);
>-        static Identifier from(ExecState* exec, double y);
>+        JS_EXPORT_PRIVATE static Identifier from(ExecState*, unsigned y);
>+        JS_EXPORT_PRIVATE static Identifier from(ExecState*, int y);
>+        JS_EXPORT_PRIVATE static Identifier from(ExecState*, double y);
>         static Identifier from(JSGlobalData*, unsigned y);
>         static Identifier from(JSGlobalData*, int y);
>         static Identifier from(JSGlobalData*, double y);
> 
>-        static uint32_t toUInt32(const UString&, bool& ok);
>-        uint32_t toUInt32(bool& ok) const { return toUInt32(m_string, ok); }
>+        JS_EXPORT_PRIVATE static uint32_t toUInt32(const UString&, bool& ok);
>+        JS_EXPORT_PRIVATE uint32_t toUInt32(bool& ok) const { return toUInt32(m_string, ok); }
>         unsigned toArrayIndex(bool& ok) const;
> 
>         bool isNull() const { return m_string.isNull(); }
>@@ -73,12 +73,12 @@
>         friend bool operator==(const Identifier&, const char*);
>         friend bool operator!=(const Identifier&, const char*);
>     
>-        static bool equal(const StringImpl*, const char*);
>-        static bool equal(const StringImpl*, const UChar*, unsigned length);
>-        static bool equal(const StringImpl* a, const StringImpl* b) { return ::equal(a, b); }
>+        JS_EXPORT_PRIVATE static bool equal(const StringImpl*, const char*);
>+        JS_EXPORT_PRIVATE static bool equal(const StringImpl*, const UChar*, unsigned length);
>+        JS_EXPORT_PRIVATE static bool equal(const StringImpl* a, const StringImpl* b) { return ::equal(a, b); }
> 
>-        static PassRefPtr<StringImpl> add(ExecState*, const char*); // Only to be used with string literals.
>-        static PassRefPtr<StringImpl> add(JSGlobalData*, const char*); // Only to be used with string literals.
>+        JS_EXPORT_PRIVATE static PassRefPtr<StringImpl> add(ExecState*, const char*); // Only to be used with string literals.
>+        JS_EXPORT_PRIVATE static PassRefPtr<StringImpl> add(JSGlobalData*, const char*); // Only to be used with string literals.
> 
>     private:
>         UString m_string;
>@@ -108,10 +108,10 @@
>             return addSlowCase(globalData, r);
>         }
> 
>-        static PassRefPtr<StringImpl> addSlowCase(ExecState*, StringImpl* r);
>-        static PassRefPtr<StringImpl> addSlowCase(JSGlobalData*, StringImpl* r);
>+        JS_EXPORT_PRIVATE static PassRefPtr<StringImpl> addSlowCase(ExecState*, StringImpl*);
>+        static PassRefPtr<StringImpl> addSlowCase(JSGlobalData*, StringImpl*);
> 
>-        static void checkCurrentIdentifierTable(ExecState*);
>+        JS_EXPORT_PRIVATE static void checkCurrentIdentifierTable(ExecState*);
>         static void checkCurrentIdentifierTable(JSGlobalData*);
>     };
>     
>Index: Source/JavaScriptCore/runtime/StringObject.h
>===================================================================
>--- Source/JavaScriptCore/runtime/StringObject.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/StringObject.h	(working copy)
>@@ -26,7 +26,7 @@
> 
> namespace JSC {
> 
>-    class StringObject : public JSWrapperObject {
>+    class JS_EXPORTDATA StringObject : public JSWrapperObject {
>     public:
>         StringObject(ExecState*, NonNullPassRefPtr<Structure>);
>         StringObject(ExecState*, NonNullPassRefPtr<Structure>, const UString&);
>@@ -41,7 +41,7 @@
>         virtual bool deleteProperty(ExecState*, const Identifier& propertyName);
>         virtual void getOwnPropertyNames(ExecState*, PropertyNameArray&, EnumerationMode mode = ExcludeDontEnumProperties);
> 
>-        static const JS_EXPORTDATA ClassInfo s_info;
>+        static const ClassInfo s_info;
> 
>         JSString* internalValue() const { return asString(JSWrapperObject::internalValue());}
> 
>Index: Source/JavaScriptCore/runtime/JSByteArray.h
>===================================================================
>--- Source/JavaScriptCore/runtime/JSByteArray.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/JSByteArray.h	(working copy)
>@@ -75,8 +75,8 @@
>                 setIndex(i, byteValue);
>         }
> 
>-        JSByteArray(ExecState*, NonNullPassRefPtr<Structure>, WTF::ByteArray* storage);
>-        static PassRefPtr<Structure> createStructure(JSGlobalData&, JSValue prototype, const JSC::ClassInfo* = &s_defaultInfo);
>+        JS_EXPORT_PRIVATE JSByteArray(ExecState*, NonNullPassRefPtr<Structure>, WTF::ByteArray* storage);
>+        JS_EXPORT_PRIVATE static PassRefPtr<Structure> createStructure(JSGlobalData&, JSValue prototype, const JSC::ClassInfo* = &s_defaultInfo);
> 
>         virtual bool getOwnPropertySlot(JSC::ExecState*, const JSC::Identifier& propertyName, JSC::PropertySlot&);
>         virtual bool getOwnPropertySlot(JSC::ExecState*, unsigned propertyName, JSC::PropertySlot&);
>Index: Source/JavaScriptCore/runtime/Completion.h
>===================================================================
>--- Source/JavaScriptCore/runtime/Completion.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/Completion.h	(working copy)
>@@ -55,8 +55,8 @@
>         JSValue m_value;
>     };
> 
>-    Completion checkSyntax(ExecState*, const SourceCode&);
>-    Completion evaluate(ExecState*, ScopeChainNode*, const SourceCode&, JSValue thisValue = JSValue());
>+    JS_EXPORT_PRIVATE Completion checkSyntax(ExecState*, const SourceCode&);
>+    JS_EXPORT_PRIVATE Completion evaluate(ExecState*, ScopeChainNode*, const SourceCode&, JSValue thisValue = JSValue());
> 
> } // namespace JSC
> 
>Index: Source/JavaScriptCore/runtime/JSVariableObject.h
>===================================================================
>--- Source/JavaScriptCore/runtime/JSVariableObject.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/JSVariableObject.h	(working copy)
>@@ -40,7 +40,7 @@
> 
>     class Register;
> 
>-    class JSVariableObject : public JSNonFinalObject {
>+    class JS_EXPORT_PRIVATE JSVariableObject : public JSNonFinalObject {
>         friend class JIT;
> 
>     public:
>Index: Source/JavaScriptCore/runtime/Lookup.h
>===================================================================
>--- Source/JavaScriptCore/runtime/Lookup.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/Lookup.h	(working copy)
>@@ -140,7 +140,7 @@
>                 createTable(&exec->globalData());
>         }
> 
>-        void deleteTable() const;
>+        JS_EXPORT_PRIVATE void deleteTable() const;
> 
>         // Find an entry in the table, and return the entry.
>         ALWAYS_INLINE const HashEntry* entry(JSGlobalData* globalData, const Identifier& identifier) const
>@@ -175,10 +175,10 @@
>         }
> 
>         // Convert the hash table keys to identifiers.
>-        void createTable(JSGlobalData*) const;
>+        JS_EXPORT_PRIVATE void createTable(JSGlobalData*) const;
>     };
> 
>-    void setUpStaticFunctionSlot(ExecState*, const HashEntry*, JSObject* thisObject, const Identifier& propertyName, PropertySlot&);
>+    JS_EXPORT_PRIVATE void setUpStaticFunctionSlot(ExecState*, const HashEntry*, JSObject* thisObject, const Identifier& propertyName, PropertySlot&);
> 
>     /**
>      * This method does it all (looking in the hashtable, checking for function
>Index: Source/JavaScriptCore/runtime/JSCell.h
>===================================================================
>--- Source/JavaScriptCore/runtime/JSCell.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/JSCell.h	(working copy)
>@@ -68,8 +68,8 @@
>         friend class ScopeChainNode;
> 
>     private:
>-        explicit JSCell(Structure*);
>-        virtual ~JSCell();
>+        JS_EXPORT_PRIVATE explicit JSCell(Structure*);
>+        JS_EXPORT_PRIVATE virtual ~JSCell();
> 
>     public:
>         static PassRefPtr<Structure> createDummyStructure(JSGlobalData& globalData)
>@@ -78,9 +78,9 @@
>         }
> 
>         // Querying the type.
>-        bool isString() const;
>-        bool isObject() const;
>-        virtual bool isGetterSetter() const;
>+        JS_EXPORT_PRIVATE bool isString() const;
>+        JS_EXPORT_PRIVATE bool isObject() const;
>+        JS_EXPORT_PRIVATE virtual bool isGetterSetter() const;
>         bool inherits(const ClassInfo*) const;
>         virtual bool isAPIValueWrapper() const { return false; }
>         virtual bool isPropertyNameIterator() const { return false; }
>@@ -88,25 +88,25 @@
>         Structure* structure() const;
> 
>         // Extracting the value.
>-        bool getString(ExecState* exec, UString&) const;
>-        UString getString(ExecState* exec) const; // null string if not a string
>-        JSObject* getObject(); // NULL if not an object
>-        const JSObject* getObject() const; // NULL if not an object
>+        JS_EXPORT_PRIVATE bool getString(ExecState*, UString&) const;
>+        JS_EXPORT_PRIVATE UString getString(ExecState*) const; // null string if not a string
>+        JS_EXPORT_PRIVATE JSObject* getObject(); // 0 if not an object
>+        JS_EXPORT_PRIVATE const JSObject* getObject() const; // 0 if not an object
>         
>-        virtual CallType getCallData(CallData&);
>-        virtual ConstructType getConstructData(ConstructData&);
>+        JS_EXPORT_PRIVATE virtual CallType getCallData(CallData&);
>+        JS_EXPORT_PRIVATE virtual ConstructType getConstructData(ConstructData&);
> 
>         // Extracting integer values.
>         // FIXME: remove these methods, can check isNumberCell in JSValue && then call asNumberCell::*.
>-        virtual bool getUInt32(uint32_t&) const;
>+        JS_EXPORT_PRIVATE virtual bool getUInt32(uint32_t&) const;
> 
>         // Basic conversions.
>-        virtual JSValue toPrimitive(ExecState*, PreferredPrimitiveType) const;
>-        virtual bool getPrimitiveNumber(ExecState*, double& number, JSValue&);
>-        virtual bool toBoolean(ExecState*) const;
>-        virtual double toNumber(ExecState*) const;
>-        virtual UString toString(ExecState*) const;
>-        virtual JSObject* toObject(ExecState*) const;
>+        JS_EXPORT_PRIVATE virtual JSValue toPrimitive(ExecState*, PreferredPrimitiveType) const;
>+        JS_EXPORT_PRIVATE virtual bool getPrimitiveNumber(ExecState*, double& number, JSValue&);
>+        JS_EXPORT_PRIVATE virtual bool toBoolean(ExecState*) const;
>+        JS_EXPORT_PRIVATE virtual double toNumber(ExecState*) const;
>+        JS_EXPORT_PRIVATE virtual UString toString(ExecState*) const;
>+        JS_EXPORT_PRIVATE virtual JSObject* toObject(ExecState*) const;
> 
>         // Garbage collection.
>         void* operator new(size_t, ExecState*);
>@@ -119,16 +119,16 @@
> #endif
> 
>         // Object operations, with the toObject operation included.
>-        const ClassInfo* classInfo() const { return m_structure->classInfo(); }
>-        virtual void put(ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
>-        virtual void put(ExecState*, unsigned propertyName, JSValue);
>-        virtual bool deleteProperty(ExecState*, const Identifier& propertyName);
>-        virtual bool deleteProperty(ExecState*, unsigned propertyName);
>+        JS_EXPORT_PRIVATE const ClassInfo* classInfo() const { return m_structure->classInfo(); }
>+        JS_EXPORT_PRIVATE virtual void put(ExecState*, const Identifier& propertyName, JSValue, PutPropertySlot&);
>+        JS_EXPORT_PRIVATE virtual void put(ExecState*, unsigned propertyName, JSValue);
>+        JS_EXPORT_PRIVATE virtual bool deleteProperty(ExecState*, const Identifier& propertyName);
>+        JS_EXPORT_PRIVATE virtual bool deleteProperty(ExecState*, unsigned propertyName);
> 
>-        virtual JSObject* toThisObject(ExecState*) const;
>-        virtual JSValue getJSNumber();
>-        void* vptr() { return *reinterpret_cast<void**>(this); }
>-        void setVPtr(void* vptr) { *reinterpret_cast<void**>(this) = vptr; }
>+        JS_EXPORT_PRIVATE virtual JSObject* toThisObject(ExecState*) const;
>+        JS_EXPORT_PRIVATE virtual JSValue getJSNumber();
>+        JS_EXPORT_PRIVATE void* vptr() { return *reinterpret_cast<void**>(this); }
>+        JS_EXPORT_PRIVATE void setVPtr(void* vptr) { *reinterpret_cast<void**>(this) = vptr; }
> 
>         // FIXME: Rename getOwnPropertySlot to virtualGetOwnPropertySlot, and
>         // fastGetOwnPropertySlot to getOwnPropertySlot. Callers should always
>@@ -151,8 +151,8 @@
> 
>     private:
>         // Base implementation; for non-object classes implements getPropertySlot.
>-        virtual bool getOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
>-        virtual bool getOwnPropertySlot(ExecState*, unsigned propertyName, PropertySlot&);
>+        JS_EXPORT_PRIVATE virtual bool getOwnPropertySlot(ExecState*, const Identifier& propertyName, PropertySlot&);
>+        JS_EXPORT_PRIVATE virtual bool getOwnPropertySlot(ExecState*, unsigned propertyName, PropertySlot&);
>         
>         Structure* m_structure;
>     };
>@@ -171,7 +171,7 @@
>         return m_structure->typeInfo().type() == ObjectType;
>     }
> 
>-    inline bool JSCell::isString() const
>+    JS_EXPORT_PRIVATE inline bool JSCell::isString() const
>     {
>         return m_structure->typeInfo().type() == StringType;
>     }
>Index: Source/JavaScriptCore/runtime/JSLock.h
>===================================================================
>--- Source/JavaScriptCore/runtime/JSLock.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/JSLock.h	(working copy)
>@@ -56,7 +56,7 @@
>     class JSLock {
>         WTF_MAKE_NONCOPYABLE(JSLock);
>     public:
>-        JSLock(ExecState*);
>+        JS_EXPORT_PRIVATE JSLock(ExecState*);
>         JSLock(JSGlobalData*);
> 
>         JSLock(JSLockBehavior lockBehavior)
>@@ -80,13 +80,13 @@
>             unlock(m_lockBehavior); 
>         }
>         
>-        static void lock(JSLockBehavior);
>-        static void unlock(JSLockBehavior);
>+        JS_EXPORT_PRIVATE static void lock(JSLockBehavior);
>+        JS_EXPORT_PRIVATE static void unlock(JSLockBehavior);
>         static void lock(ExecState*);
>         static void unlock(ExecState*);
> 
>-        static intptr_t lockCount();
>-        static bool currentThreadIsHoldingLock();
>+        JS_EXPORT_PRIVATE static intptr_t lockCount();
>+        JS_EXPORT_PRIVATE static bool currentThreadIsHoldingLock();
> 
>         JSLockBehavior m_lockBehavior;
> 
>@@ -94,8 +94,8 @@
>             WTF_MAKE_NONCOPYABLE(DropAllLocks);
>         public:
>             DropAllLocks(ExecState* exec);
>-            DropAllLocks(JSLockBehavior);
>-            ~DropAllLocks();
>+            JS_EXPORT_PRIVATE DropAllLocks(JSLockBehavior);
>+            JS_EXPORT_PRIVATE ~DropAllLocks();
>             
>         private:
>             intptr_t m_lockCount;
>Index: Source/JavaScriptCore/runtime/PropertySlot.h
>===================================================================
>--- Source/JavaScriptCore/runtime/PropertySlot.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/PropertySlot.h	(working copy)
>@@ -220,7 +220,7 @@
>             return m_getValue;
>         }
>     private:
>-        JSValue functionGetter(ExecState*) const;
>+        JS_EXPORT_PRIVATE JSValue functionGetter(ExecState*) const;
> 
>         GetValueFunc m_getValue;
>         GetIndexValueFunc m_getIndexValue;
>Index: Source/JavaScriptCore/runtime/FunctionConstructor.h
>===================================================================
>--- Source/JavaScriptCore/runtime/FunctionConstructor.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/FunctionConstructor.h	(working copy)
>@@ -36,7 +36,7 @@
>         virtual CallType getCallData(CallData&);
>     };
> 
>-    JSObject* constructFunction(ExecState*, const ArgList&, const Identifier& functionName, const UString& sourceURL, int lineNumber);
>+    JS_EXPORT_PRIVATE JSObject* constructFunction(ExecState*, const ArgList&, const Identifier& functionName, const UString& sourceURL, int lineNumber);
>     JSObject* constructFunction(ExecState*, const ArgList&);
> 
> } // namespace JSC
>Index: Source/JavaScriptCore/runtime/SmallStrings.h
>===================================================================
>--- Source/JavaScriptCore/runtime/SmallStrings.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/SmallStrings.h	(working copy)
>@@ -73,8 +73,8 @@
>     private:
>         static const unsigned singleCharacterStringCount = maxSingleCharacterString + 1;
> 
>-        void createEmptyString(JSGlobalData*);
>-        void createSingleCharacterString(JSGlobalData*, unsigned char);
>+        JS_EXPORT_PRIVATE void createEmptyString(JSGlobalData*);
>+        JS_EXPORT_PRIVATE void createSingleCharacterString(JSGlobalData*, unsigned char);
> 
>         JSString* m_emptyString;
>         JSString* m_singleCharacterStrings[singleCharacterStringCount];
>Index: Source/JavaScriptCore/runtime/PropertyNameArray.h
>===================================================================
>--- Source/JavaScriptCore/runtime/PropertyNameArray.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/PropertyNameArray.h	(working copy)
>@@ -68,8 +68,8 @@
> 
>         JSGlobalData* globalData() { return m_globalData; }
> 
>-        void add(const Identifier& identifier) { add(identifier.impl()); }
>-        void add(StringImpl*);
>+        JS_EXPORT_PRIVATE void add(const Identifier& identifier) { add(identifier.impl()); }
>+        JS_EXPORT_PRIVATE void add(StringImpl*);
>         void addKnownUnique(StringImpl* identifier) { m_data->propertyNameVector().append(Identifier(m_globalData, identifier)); }
> 
>         Identifier& operator[](unsigned i) { return m_data->propertyNameVector()[i]; }
>Index: Source/JavaScriptCore/runtime/Error.h
>===================================================================
>--- Source/JavaScriptCore/runtime/Error.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/Error.h	(working copy)
>@@ -45,12 +45,12 @@
>     JSObject* createTypeError(JSGlobalObject*, const UString&);
>     JSObject* createURIError(JSGlobalObject*, const UString&);
>     // ExecState wrappers.
>-    JSObject* createError(ExecState*, const UString&);
>+    JS_EXPORT_PRIVATE JSObject* createError(ExecState*, const UString&);
>     JSObject* createEvalError(ExecState*, const UString&);
>-    JSObject* createRangeError(ExecState*, const UString&);
>-    JSObject* createReferenceError(ExecState*, const UString&);
>-    JSObject* createSyntaxError(ExecState*, const UString&);
>-    JSObject* createTypeError(ExecState*, const UString&);
>+    JS_EXPORT_PRIVATE JSObject* createRangeError(ExecState*, const UString&);
>+    JS_EXPORT_PRIVATE JSObject* createReferenceError(ExecState*, const UString&);
>+    JS_EXPORT_PRIVATE JSObject* createSyntaxError(ExecState*, const UString&);
>+    JS_EXPORT_PRIVATE JSObject* createTypeError(ExecState*, const UString&);
>     JSObject* createURIError(ExecState*, const UString&);
> 
>     // Methods to add 
>@@ -60,12 +60,12 @@
>     JSObject* addErrorInfo(ExecState*, JSObject* error, int line, const SourceCode&);
> 
>     // Methods to throw Errors.
>-    JSValue throwError(ExecState*, JSValue);
>-    JSObject* throwError(ExecState*, JSObject*);
>+    JS_EXPORT_PRIVATE JSValue throwError(ExecState*, JSValue);
>+    JS_EXPORT_PRIVATE JSObject* throwError(ExecState*, JSObject*);
> 
>     // Convenience wrappers, create an throw an exception with a default message.
>-    JSObject* throwTypeError(ExecState*);
>-    JSObject* throwSyntaxError(ExecState*);
>+    JS_EXPORT_PRIVATE JSObject* throwTypeError(ExecState*);
>+    JS_EXPORT_PRIVATE JSObject* throwSyntaxError(ExecState*);
> 
>     // Convenience wrappers, wrap result as an EncodedJSValue.
>     inline EncodedJSValue throwVMError(ExecState* exec, JSValue error) { return JSValue::encode(throwError(exec, error)); }
>Index: Source/JavaScriptCore/runtime/UString.h
>===================================================================
>--- Source/JavaScriptCore/runtime/UString.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/UString.h	(working copy)
>@@ -30,24 +30,24 @@
> class UString {
> public:
>     // Construct a null string, distinguishable from an empty string.
>-    UString() { }
>+    JS_EXPORT_PRIVATE UString() { }
> 
>     // Construct a string with UTF-16 data.
>-    UString(const UChar* characters, unsigned length);
>+    JS_EXPORT_PRIVATE UString(const UChar* characters, unsigned length);
> 
>     // Construct a string with UTF-16 data, from a null-terminated source.
>-    UString(const UChar*);
>+    JS_EXPORT_PRIVATE UString(const UChar*);
> 
>     // Construct a string with latin1 data.
>-    UString(const char* characters, unsigned length);
>+    JS_EXPORT_PRIVATE UString(const char* characters, unsigned length);
> 
>     // Construct a string with latin1 data, from a null-terminated source.
>-    UString(const char* characters);
>+    JS_EXPORT_PRIVATE UString(const char* characters);
> 
>     // Construct a string referencing an existing StringImpl.
>-    UString(StringImpl* impl) : m_impl(impl) { }
>-    UString(PassRefPtr<StringImpl> impl) : m_impl(impl) { }
>-    UString(RefPtr<StringImpl> impl) : m_impl(impl) { }
>+    JS_EXPORT_PRIVATE UString(StringImpl* impl) : m_impl(impl) { }
>+    JS_EXPORT_PRIVATE UString(PassRefPtr<StringImpl> impl) : m_impl(impl) { }
>+    JS_EXPORT_PRIVATE UString(RefPtr<StringImpl> impl) : m_impl(impl) { }
> 
>     // Inline the destructor.
>     ALWAYS_INLINE ~UString() { }
>@@ -76,9 +76,9 @@
>         return m_impl->characters();
>     }
> 
>-    CString ascii() const;
>-    CString latin1() const;
>-    CString utf8(bool strict = false) const;
>+    JS_EXPORT_PRIVATE CString ascii() const;
>+    JS_EXPORT_PRIVATE CString latin1() const;
>+    JS_EXPORT_PRIVATE CString utf8(bool strict = false) const;
> 
>     UChar operator[](unsigned index) const
>     {
>@@ -87,11 +87,11 @@
>         return m_impl->characters()[index];
>     }
> 
>-    static UString number(int);
>-    static UString number(unsigned);
>-    static UString number(long);
>-    static UString number(long long);
>-    static UString number(double);
>+    JS_EXPORT_PRIVATE static UString number(int);
>+    JS_EXPORT_PRIVATE static UString number(unsigned);
>+    JS_EXPORT_PRIVATE static UString number(long);
>+    JS_EXPORT_PRIVATE static UString number(long long);
>+    JS_EXPORT_PRIVATE static UString number(double);
> 
>     // Find a single character or string, also with match function & latin1 forms.
>     size_t find(UChar c, unsigned start = 0) const
>@@ -107,7 +107,7 @@
>     size_t reverseFind(const UString& str, unsigned start = UINT_MAX) const
>         { return m_impl ? m_impl->reverseFind(str.impl(), start) : notFound; }
> 
>-    UString substringSharingImpl(unsigned pos, unsigned len = UINT_MAX) const;
>+    JS_EXPORT_PRIVATE UString substringSharingImpl(unsigned pos, unsigned len = UINT_MAX) const;
> 
> private:
>     RefPtr<StringImpl> m_impl;
>Index: Source/JavaScriptCore/runtime/DateInstance.h
>===================================================================
>--- Source/JavaScriptCore/runtime/DateInstance.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/DateInstance.h	(working copy)
>@@ -31,8 +31,8 @@
> 
>     class DateInstance : public JSWrapperObject {
>     public:
>-        DateInstance(ExecState*, double);
>-        DateInstance(ExecState*, NonNullPassRefPtr<Structure>, double);
>+        JS_EXPORT_PRIVATE DateInstance(ExecState*, double);
>+        JS_EXPORT_PRIVATE DateInstance(ExecState*, NonNullPassRefPtr<Structure>, double);
>         explicit DateInstance(ExecState*, NonNullPassRefPtr<Structure>);
> 
>         double internalNumber() const { return internalValue().uncheckedGetNumber(); }
>Index: Source/JavaScriptCore/runtime/RopeImpl.h
>===================================================================
>--- Source/JavaScriptCore/runtime/RopeImpl.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/RopeImpl.h	(working copy)
>@@ -83,7 +83,7 @@
>     {
>     }
> 
>-    void destructNonRecursive();
>+    JS_EXPORT_PRIVATE void destructNonRecursive();
>     void derefFibersNonRecursive(Vector<RopeImpl*, 32>& workQueue);
> 
>     bool hasOneRef() { return (m_refCountAndFlags & s_refCountMask) == s_refCountIncrement; }
>Index: Source/JavaScriptCore/runtime/JSGlobalData.h
>===================================================================
>--- Source/JavaScriptCore/runtime/JSGlobalData.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/JSGlobalData.h	(working copy)
>@@ -113,7 +113,7 @@
>         // the original API.
>         enum GlobalDataType { Default, APIContextGroup, APIShared };
> 
>-        struct ClientData {
>+        struct JS_EXPORT_PRIVATE ClientData {
>             virtual ~ClientData() = 0;
>         };
> 
>@@ -122,10 +122,10 @@
>         static bool sharedInstanceExists();
>         static JSGlobalData& sharedInstance();
> 
>-        static PassRefPtr<JSGlobalData> create(ThreadStackType);
>-        static PassRefPtr<JSGlobalData> createLeaked(ThreadStackType);
>+        JS_EXPORT_PRIVATE static PassRefPtr<JSGlobalData> create(ThreadStackType);
>+        JS_EXPORT_PRIVATE static PassRefPtr<JSGlobalData> createLeaked(ThreadStackType);
>         static PassRefPtr<JSGlobalData> createContextGroup(ThreadStackType);
>-        ~JSGlobalData();
>+        JS_EXPORT_PRIVATE ~JSGlobalData();
> 
> #if ENABLE(JSC_MULTIPLE_THREADS)
>         // Will start tracking threads that use the heap, which is resource-heavy.
>@@ -248,9 +248,9 @@
> 
>         void resetDateCache();
> 
>-        void startSampling();
>-        void stopSampling();
>-        void dumpSampleData(ExecState* exec);
>+        JS_EXPORT_PRIVATE void startSampling();
>+        JS_EXPORT_PRIVATE void stopSampling();
>+        JS_EXPORT_PRIVATE void dumpSampleData(ExecState*);
>         void recompileAllJSFunctions();
>         RegExpCache* regExpCache() { return m_regExpCache; }
> #if ENABLE(REGEXP_TRACING)
>Index: Source/JavaScriptCore/runtime/TimeoutChecker.h
>===================================================================
>--- Source/JavaScriptCore/runtime/TimeoutChecker.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/TimeoutChecker.h	(working copy)
>@@ -57,9 +57,9 @@
>             --m_startCount;
>         }
> 
>-        void reset();
>+        JS_EXPORT_PRIVATE void reset();
> 
>-        bool didTimeOut(ExecState*);
>+        JS_EXPORT_PRIVATE bool didTimeOut(ExecState*);
> 
>     private:
>         unsigned m_timeoutInterval;
>Index: Source/JavaScriptCore/runtime/Heap.h
>===================================================================
>--- Source/JavaScriptCore/runtime/Heap.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/Heap.h	(working copy)
>@@ -63,28 +63,28 @@
>         
>         Heap(JSGlobalData*);
>         ~Heap();
>-        void destroy(); // JSGlobalData must call destroy() before ~Heap().
>+        JS_EXPORT_PRIVATE void destroy(); // JSGlobalData must call destroy() before ~Heap().
> 
>         JSGlobalData* globalData() const { return m_globalData; }
>         MarkedSpace& markedSpace() { return m_markedSpace; }
>         MachineThreads& machineThreads() { return m_machineThreads; }
> 
>-        GCActivityCallback* activityCallback();
>+        JS_EXPORT_PRIVATE GCActivityCallback* activityCallback();
>         void setActivityCallback(PassOwnPtr<GCActivityCallback>);
> 
>-        bool isBusy(); // true if an allocation or collection is in progress
>-        void* allocate(size_t);
>-        void collectAllGarbage();
>+        JS_EXPORT_PRIVATE bool isBusy(); // true if an allocation or collection is in progress
>+        JS_EXPORT_PRIVATE void* allocate(size_t);
>+        JS_EXPORT_PRIVATE void collectAllGarbage();
> 
>-        void reportExtraMemoryCost(size_t cost);
>+        JS_EXPORT_PRIVATE void reportExtraMemoryCost(size_t cost);
> 
>-        void protect(JSValue);
>-        bool unprotect(JSValue); // True when the protect count drops to 0.
>+        JS_EXPORT_PRIVATE void protect(JSValue);
>+        JS_EXPORT_PRIVATE bool unprotect(JSValue); // True when the protect count drops to 0.
> 
>         bool contains(void*);
> 
>-        size_t size() const;
>-        size_t capacity() const;
>+        JS_EXPORT_PRIVATE size_t size() const;
>+        JS_EXPORT_PRIVATE size_t capacity() const;
>         size_t objectCount() const;
>         size_t globalObjectCount();
>         size_t protectedObjectCount();
>@@ -110,8 +110,8 @@
>         static const size_t minExtraCost = 256;
>         static const size_t maxExtraCost = 1024 * 1024;
> 
>-        void* allocateSlowCase(size_t);
>-        void reportExtraMemoryCostSlowCase(size_t);
>+        JS_EXPORT_PRIVATE void* allocateSlowCase(size_t);
>+        JS_EXPORT_PRIVATE void reportExtraMemoryCostSlowCase(size_t);
> 
>         void markRoots();
>         void markProtectedObjects(HeapRootMarker&);
>Index: Source/JavaScriptCore/runtime/JSGlobalObject.h
>===================================================================
>--- Source/JavaScriptCore/runtime/JSGlobalObject.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/JSGlobalObject.h	(working copy)
>@@ -52,7 +52,7 @@
> 
>     typedef Vector<ExecState*, 16> ExecStateStack;
>     
>-    class JSGlobalObject : public JSVariableObject {
>+    class JS_EXPORT_PRIVATE JSGlobalObject : public JSVariableObject {
>     protected:
>         typedef HashSet<RefPtr<OpaqueJSWeakObjectMap> > WeakMapSet;
> 
>@@ -434,7 +434,7 @@
>     class DynamicGlobalObjectScope {
>         WTF_MAKE_NONCOPYABLE(DynamicGlobalObjectScope);
>     public:
>-        DynamicGlobalObjectScope(JSGlobalData&, JSGlobalObject*);
>+        JS_EXPORT_PRIVATE DynamicGlobalObjectScope(JSGlobalData&, JSGlobalObject*);
> 
>         ~DynamicGlobalObjectScope()
>         {
>Index: Source/JavaScriptCore/runtime/JSObjectWithGlobalObject.h
>===================================================================
>--- Source/JavaScriptCore/runtime/JSObjectWithGlobalObject.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/JSObjectWithGlobalObject.h	(working copy)
>@@ -39,10 +39,10 @@
>         return Structure::create(globalData, proto, TypeInfo(ObjectType, StructureFlags), AnonymousSlotCount, &s_info);
>     }
> 
>-    JSGlobalObject* globalObject() const;
>+    JS_EXPORT_PRIVATE JSGlobalObject* globalObject() const;
> 
> protected:
>-    JSObjectWithGlobalObject(JSGlobalObject*, NonNullPassRefPtr<Structure>);
>+    JS_EXPORT_PRIVATE JSObjectWithGlobalObject(JSGlobalObject*, NonNullPassRefPtr<Structure>);
> 
>     JSObjectWithGlobalObject(NonNullPassRefPtr<Structure> structure)
>         : JSNonFinalObject(structure)
>Index: Source/JavaScriptCore/runtime/JSValue.h
>===================================================================
>--- Source/JavaScriptCore/runtime/JSValue.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/JSValue.h	(working copy)
>@@ -80,10 +80,10 @@
> #endif
>     };
> 
>-    double nonInlineNaN();
>+    JS_EXPORT_PRIVATE double nonInlineNaN();
> 
>     // This implements ToInt32, defined in ECMA-262 9.5.
>-    int32_t toInt32(double);
>+    JS_EXPORT_PRIVATE int32_t toInt32(double);
> 
>     // This implements ToUInt32, defined in ECMA-262 9.6.
>     inline uint32_t toUInt32(double number)
>@@ -191,7 +191,7 @@
>         JSObject* toObject(ExecState*) const;
> 
>         // Integer conversions.
>-        double toInteger(ExecState*) const;
>+        JS_EXPORT_PRIVATE double toInteger(ExecState*) const;
>         double toIntegerPreserveNaN(ExecState*) const;
>         int32_t toInt32(ExecState*) const;
>         uint32_t toUInt32(ExecState*) const;
>@@ -230,7 +230,7 @@
> 
>         bool isCell() const;
>         JSCell* asCell() const;
>-        bool isValidCallee();
>+        JS_EXPORT_PRIVATE bool isValidCallee();
> 
> #ifndef NDEBUG
>         char* description();
>@@ -244,10 +244,10 @@
>         JSValue(HashTableDeletedValueTag);
> 
>         inline const JSValue asValue() const { return *this; }
>-        JSObject* toObjectSlowCase(ExecState*) const;
>-        JSObject* toThisObjectSlowCase(ExecState*) const;
>+        JS_EXPORT_PRIVATE JSObject* toObjectSlowCase(ExecState*) const;
>+        JS_EXPORT_PRIVATE JSObject* toThisObjectSlowCase(ExecState*) const;
> 
>-        JSObject* synthesizePrototype(ExecState*) const;
>+        JS_EXPORT_PRIVATE JSObject* synthesizePrototype(ExecState*) const;
>         JSObject* synthesizeObject(ExecState*) const;
> 
> #if USE(JSVALUE32_64)
>Index: Source/JavaScriptCore/runtime/PropertyDescriptor.h
>===================================================================
>--- Source/JavaScriptCore/runtime/PropertyDescriptor.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/PropertyDescriptor.h	(working copy)
>@@ -46,8 +46,8 @@
>         JSValue value() const { return m_value; }
>         JSValue getter() const;
>         JSValue setter() const;
>-        void setUndefined();
>-        void setDescriptor(JSValue value, unsigned attributes);
>+        JS_EXPORT_PRIVATE void setUndefined();
>+        JS_EXPORT_PRIVATE void setDescriptor(JSValue, unsigned attributes);
>         void setAccessorDescriptor(JSValue getter, JSValue setter, unsigned attributes);
>         void setWritable(bool);
>         void setEnumerable(bool);
>Index: Source/JavaScriptCore/runtime/JSWrapperObject.h
>===================================================================
>--- Source/JavaScriptCore/runtime/JSWrapperObject.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/JSWrapperObject.h	(working copy)
>@@ -28,7 +28,7 @@
> 
>     // This class is used as a base for classes such as String,
>     // Number, Boolean and Date which are wrappers for primitive types.
>-    class JSWrapperObject : public JSNonFinalObject {
>+    class JS_EXPORT_PRIVATE JSWrapperObject : public JSNonFinalObject {
>     protected:
>         explicit JSWrapperObject(NonNullPassRefPtr<Structure>);
> 
>Index: Source/JavaScriptCore/runtime/CallData.h
>===================================================================
>--- Source/JavaScriptCore/runtime/CallData.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/CallData.h	(working copy)
>@@ -57,7 +57,7 @@
>         } js;
>     };
> 
>-    JSValue call(ExecState*, JSValue functionObject, CallType, const CallData&, JSValue thisValue, const ArgList&);
>+    JS_EXPORT_PRIVATE JSValue call(ExecState*, JSValue functionObject, CallType, const CallData&, JSValue thisValue, const ArgList&);
> 
> } // namespace JSC
> 
>Index: Source/JavaScriptCore/runtime/ScopeChain.h
>===================================================================
>--- Source/JavaScriptCore/runtime/ScopeChain.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/ScopeChain.h	(working copy)
>@@ -32,7 +32,7 @@
>     class MarkStack;
>     class ScopeChainIterator;
>     
>-    class ScopeChainNode : public JSCell {
>+    class JS_EXPORT_PRIVATE ScopeChainNode : public JSCell {
>     public:
>         ScopeChainNode(ScopeChainNode* next, JSObject* object, JSGlobalData* globalData, JSGlobalObject* globalObject, JSObject* globalThis)
>             : JSCell(globalData->scopeChainNodeStructure.get())
>Index: Source/JavaScriptCore/runtime/ConstructData.h
>===================================================================
>--- Source/JavaScriptCore/runtime/ConstructData.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/ConstructData.h	(working copy)
>@@ -57,7 +57,7 @@
>         } js;
>     };
> 
>-    JSObject* construct(ExecState*, JSValue constructor, ConstructType, const ConstructData&, const ArgList&);
>+    JS_EXPORT_PRIVATE JSObject* construct(ExecState*, JSValue constructor, ConstructType, const ConstructData&, const ArgList&);
> 
> } // namespace JSC
> 
>Index: Source/JavaScriptCore/runtime/MarkedSpace.h
>===================================================================
>--- Source/JavaScriptCore/runtime/MarkedSpace.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/MarkedSpace.h	(working copy)
>@@ -105,7 +105,7 @@
>         void freeBlocks(DoublyLinkedList<MarkedBlock>&);
> 
>         SizeClass& sizeClassFor(size_t);
>-        void* allocateFromSizeClass(SizeClass&);
>+        JS_EXPORT_PRIVATE void* allocateFromSizeClass(SizeClass&);
> 
>         void clearMarks(MarkedBlock*);
> 
>Index: Source/JavaScriptCore/runtime/InitializeThreading.h
>===================================================================
>--- Source/JavaScriptCore/runtime/InitializeThreading.h	(revision 82010)
>+++ Source/JavaScriptCore/runtime/InitializeThreading.h	(working copy)
>@@ -33,7 +33,7 @@
> 
>     // This function must be called from the main thread. It is safe to call it repeatedly.
>     // Darwin is an exception to this rule: it is OK to call this function from any thread, even reentrantly.
>-    void initializeThreading();
>+    JS_EXPORT_PRIVATE void initializeThreading();
> 
> }
> 
>Index: Source/JavaScriptCore/config.h
>===================================================================
>--- Source/JavaScriptCore/config.h	(revision 82010)
>+++ Source/JavaScriptCore/config.h	(working copy)
>@@ -59,8 +59,8 @@
> #define JS_EXPORTCLASS
> #endif
> 
>-#define WTF_EXPORT_PRIVATE JS_EXPORTDATA
>-#define JS_EXPORT_PRIVATE JS_EXPORTDATA
>+#define WTF_EXPORT_PRIVATE
>+#define JS_EXPORT_PRIVATE
> 
> #endif /* USE(EXPORT_MACROS) */
> 
>Index: Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h
>===================================================================
>--- Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h	(revision 82010)
>+++ Source/JavaScriptCore/bytecompiler/BytecodeGenerator.h	(working copy)
>@@ -89,7 +89,7 @@
>         typedef DeclarationStacks::VarStack VarStack;
>         typedef DeclarationStacks::FunctionStack FunctionStack;
> 
>-        static void setDumpsGeneratedCode(bool dumpsGeneratedCode);
>+        JS_EXPORT_PRIVATE static void setDumpsGeneratedCode(bool);
>         static bool dumpsGeneratedCode();
> 
>         BytecodeGenerator(ProgramNode*, ScopeChainNode*, SymbolTable*, ProgramCodeBlock*);
>Index: Source/JavaScriptCore/wtf/RefCountedLeakCounter.h
>===================================================================
>--- Source/JavaScriptCore/wtf/RefCountedLeakCounter.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/RefCountedLeakCounter.h	(working copy)
>@@ -26,7 +26,7 @@
> 
> namespace WTF {
>     
>-    struct RefCountedLeakCounter {
>+    struct WTF_EXPORT_PRIVATE RefCountedLeakCounter {
>         static void suppressMessages(const char*);
>         static void cancelMessageSuppression(const char*);
>         
>Index: Source/JavaScriptCore/wtf/NullPtr.h
>===================================================================
>--- Source/JavaScriptCore/wtf/NullPtr.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/NullPtr.h	(working copy)
>@@ -42,10 +42,10 @@
> #else
> 
> namespace std {
>-    class nullptr_t { };
>+class WTF_EXPORT_PRIVATE nullptr_t { };
> }
> 
>-extern std::nullptr_t nullptr;
>+extern WTF_EXPORT_PRIVATE std::nullptr_t nullptr;
> 
> #endif
> 
>Index: Source/JavaScriptCore/wtf/Threading.h
>===================================================================
>--- Source/JavaScriptCore/wtf/Threading.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/Threading.h	(working copy)
>@@ -84,27 +84,27 @@
> // This function must be called from the main thread. It is safe to call it repeatedly.
> // Darwin is an exception to this rule: it is OK to call it from any thread, the only 
> // requirement is that the calls are not reentrant.
>-void initializeThreading();
>+WTF_EXPORT_PRIVATE void initializeThreading();
> 
> // Returns 0 if thread creation failed.
> // The thread name must be a literal since on some platforms it's passed in to the thread.
>-ThreadIdentifier createThread(ThreadFunction, void*, const char* threadName);
>+WTF_EXPORT_PRIVATE ThreadIdentifier createThread(ThreadFunction, void*, const char* threadName);
> 
> // Internal platform-specific createThread implementation.
>-ThreadIdentifier createThreadInternal(ThreadFunction, void*, const char* threadName);
>+WTF_EXPORT_PRIVATE ThreadIdentifier createThreadInternal(ThreadFunction, void*, const char* threadName);
> 
> // Called in the thread during initialization.
> // Helpful for platforms where the thread name must be set from within the thread.
> void initializeCurrentThreadInternal(const char* threadName);
> 
>-ThreadIdentifier currentThread();
>-int waitForThreadCompletion(ThreadIdentifier, void**);
>-void detachThread(ThreadIdentifier);
>+WTF_EXPORT_PRIVATE ThreadIdentifier currentThread();
>+WTF_EXPORT_PRIVATE int waitForThreadCompletion(ThreadIdentifier, void**);
>+WTF_EXPORT_PRIVATE void detachThread(ThreadIdentifier);
> 
>-void yield();
>+WTF_EXPORT_PRIVATE void yield();
> 
>-void lockAtomicallyInitializedStaticMutex();
>-void unlockAtomicallyInitializedStaticMutex();
>+WTF_EXPORT_PRIVATE void lockAtomicallyInitializedStaticMutex();
>+WTF_EXPORT_PRIVATE void unlockAtomicallyInitializedStaticMutex();
> 
> } // namespace WTF
> 
>Index: Source/JavaScriptCore/wtf/MainThread.h
>===================================================================
>--- Source/JavaScriptCore/wtf/MainThread.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/MainThread.h	(working copy)
>@@ -38,15 +38,15 @@
> typedef void MainThreadFunction(void*);
> 
> // Must be called from the main thread.
>-void initializeMainThread();
>+WTF_EXPORT_PRIVATE void initializeMainThread();
> 
>-void callOnMainThread(MainThreadFunction*, void* context);
>+WTF_EXPORT_PRIVATE void callOnMainThread(MainThreadFunction*, void* context);
> void callOnMainThreadAndWait(MainThreadFunction*, void* context);
> void cancelCallOnMainThread(MainThreadFunction*, void* context);
> 
>-void setMainThreadCallbacksPaused(bool paused);
>+WTF_EXPORT_PRIVATE void setMainThreadCallbacksPaused(bool);
> 
>-bool isMainThread();
>+WTF_EXPORT_PRIVATE bool isMainThread();
> 
> // NOTE: these functions are internal to the callOnMainThread implementation.
> void initializeMainThreadPlatform();
>Index: Source/JavaScriptCore/wtf/OSAllocator.h
>===================================================================
>--- Source/JavaScriptCore/wtf/OSAllocator.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/OSAllocator.h	(working copy)
>@@ -46,7 +46,7 @@
>     // releaseDecommitted should be called on a region of VM allocated by a single reservation,
>     // the memory must all currently be in a decommitted state.
>     static void* reserveUncommitted(size_t, Usage = UnknownUsage, bool writable = true, bool executable = false);
>-    static void releaseDecommitted(void*, size_t);
>+    WTF_EXPORT_PRIVATE static void releaseDecommitted(void*, size_t);
> 
>     // These methods are symmetric; they commit or decommit a region of VM (uncommitted VM should
>     // never be accessed, since the OS may not have attached physical memory for these regions).
>@@ -57,7 +57,7 @@
>     // These methods are symmetric; reserveAndCommit allocates VM in an committed state,
>     // decommitAndRelease should be called on a region of VM allocated by a single reservation,
>     // the memory must all currently be in a committed state.
>-    static void* reserveAndCommit(size_t, Usage = UnknownUsage, bool writable = true, bool executable = false);
>+    WTF_EXPORT_PRIVATE static void* reserveAndCommit(size_t, Usage = UnknownUsage, bool writable = true, bool executable = false);
>     static void decommitAndRelease(void* base, size_t size);
> 
>     // These methods are akin to reserveAndCommit/decommitAndRelease, above - however rather than
>Index: Source/JavaScriptCore/wtf/FastMalloc.h
>===================================================================
>--- Source/JavaScriptCore/wtf/FastMalloc.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/FastMalloc.h	(working copy)
>@@ -29,12 +29,12 @@
> namespace WTF {
> 
>     // These functions call CRASH() if an allocation fails.
>-    void* fastMalloc(size_t);
>-    void* fastZeroedMalloc(size_t);
>-    void* fastCalloc(size_t numElements, size_t elementSize);
>-    void* fastRealloc(void*, size_t);
>-    char* fastStrDup(const char*);
>-    size_t fastMallocSize(const void*);
>+    WTF_EXPORT_PRIVATE void* fastMalloc(size_t);
>+    WTF_EXPORT_PRIVATE void* fastZeroedMalloc(size_t);
>+    WTF_EXPORT_PRIVATE void* fastCalloc(size_t numElements, size_t elementSize);
>+    WTF_EXPORT_PRIVATE void* fastRealloc(void*, size_t);
>+    WTF_EXPORT_PRIVATE char* fastStrDup(const char*);
>+    WTF_EXPORT_PRIVATE size_t fastMallocSize(const void*);
> 
>     struct TryMallocReturnValue {
>         TryMallocReturnValue(void* data)
>@@ -68,12 +68,12 @@
>         return returnValue;
>     }
> 
>-    TryMallocReturnValue tryFastMalloc(size_t n);
>-    TryMallocReturnValue tryFastZeroedMalloc(size_t n);
>-    TryMallocReturnValue tryFastCalloc(size_t n_elements, size_t element_size);
>-    TryMallocReturnValue tryFastRealloc(void* p, size_t n);
>+    WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastMalloc(size_t n);
>+    WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastZeroedMalloc(size_t n);
>+    WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastCalloc(size_t n_elements, size_t element_size);
>+    WTF_EXPORT_PRIVATE TryMallocReturnValue tryFastRealloc(void* p, size_t n);
> 
>-    void fastFree(void*);
>+    WTF_EXPORT_PRIVATE void fastFree(void*);
> 
> #ifndef NDEBUG    
>     void fastMallocForbid();
>Index: Source/JavaScriptCore/wtf/ThreadSpecific.h
>===================================================================
>--- Source/JavaScriptCore/wtf/ThreadSpecific.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/ThreadSpecific.h	(working copy)
>@@ -216,8 +216,8 @@
> // 2) We do not need to hold many instances of ThreadSpecific<> data. This fixed number should be far enough.
> const int kMaxTlsKeySize = 256;
> 
>-long& tlsKeyCount();
>-DWORD* tlsKeys();
>+WTF_EXPORT_PRIVATE long& tlsKeyCount();
>+WTF_EXPORT_PRIVATE DWORD* tlsKeys();
> 
> template<typename T>
> inline ThreadSpecific<T>::ThreadSpecific()
>Index: Source/JavaScriptCore/wtf/WTFThreadData.h
>===================================================================
>--- Source/JavaScriptCore/wtf/WTFThreadData.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/WTFThreadData.h	(working copy)
>@@ -89,8 +89,8 @@
> class WTFThreadData {
>     WTF_MAKE_NONCOPYABLE(WTFThreadData);
> public:
>-    WTFThreadData();
>-    ~WTFThreadData();
>+    WTF_EXPORT_PRIVATE WTFThreadData();
>+    WTF_EXPORT_PRIVATE ~WTFThreadData();
> 
>     AtomicStringTable* atomicStringTable()
>     {
>Index: Source/JavaScriptCore/wtf/DateMath.h
>===================================================================
>--- Source/JavaScriptCore/wtf/DateMath.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/DateMath.h	(working copy)
>@@ -59,7 +59,7 @@
> 
> // Not really math related, but this is currently the only shared place to put these.
> double parseES5DateFromNullTerminatedCharacters(const char* dateString);
>-double parseDateFromNullTerminatedCharacters(const char* dateString);
>+WTF_EXPORT_PRIVATE double parseDateFromNullTerminatedCharacters(const char* dateString);
> double timeClip(double);
> 
> inline double jsCurrentTime()
>@@ -82,15 +82,15 @@
> const double msPerMonth = 2592000000.0;
> 
> // Returns the number of days from 1970-01-01 to the specified date.
>-double dateToDaysFrom1970(int year, int month, int day);
>-int msToYear(double ms);
>-int dayInYear(double ms, int year);
>-int monthFromDayInYear(int dayInYear, bool leapYear);
>-int dayInMonthFromDayInYear(int dayInYear, bool leapYear);
>+WTF_EXPORT_PRIVATE double dateToDaysFrom1970(int year, int month, int day);
>+WTF_EXPORT_PRIVATE int msToYear(double ms);
>+WTF_EXPORT_PRIVATE int dayInYear(double ms, int year);
>+WTF_EXPORT_PRIVATE int monthFromDayInYear(int dayInYear, bool leapYear);
>+WTF_EXPORT_PRIVATE int dayInMonthFromDayInYear(int dayInYear, bool leapYear);
> 
> // Returns offset milliseconds for UTC and DST.
>-int32_t calculateUTCOffset();
>-double calculateDSTOffset(double ms, double utcOffset);
>+WTF_EXPORT_PRIVATE int32_t calculateUTCOffset();
>+WTF_EXPORT_PRIVATE double calculateDSTOffset(double ms, double utcOffset);
> 
> } // namespace WTF
> 
>Index: Source/JavaScriptCore/wtf/unicode/Collator.h
>===================================================================
>--- Source/JavaScriptCore/wtf/unicode/Collator.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/unicode/Collator.h	(working copy)
>@@ -45,13 +45,13 @@
>     public:
>         enum Result { Equal = 0, Greater = 1, Less = -1 };
> 
>-        Collator(const char* locale); // Parsing is lenient; e.g. language identifiers (such as "en-US") are accepted, too.
>-        ~Collator();
>-        void setOrderLowerFirst(bool);
>+        WTF_EXPORT_PRIVATE Collator(const char* locale); // Parsing is lenient; e.g. language identifiers (such as "en-US") are accepted, too.
>+        WTF_EXPORT_PRIVATE ~Collator();
>+        WTF_EXPORT_PRIVATE void setOrderLowerFirst(bool);
> 
>         static PassOwnPtr<Collator> userDefault();
> 
>-        Result collate(const ::UChar*, size_t, const ::UChar*, size_t) const;
>+        WTF_EXPORT_PRIVATE Result collate(const ::UChar*, size_t, const ::UChar*, size_t) const;
> 
>     private:
> #if USE(ICU_UNICODE) && !UCONFIG_NO_COLLATION
>Index: Source/JavaScriptCore/wtf/unicode/UTF8.h
>===================================================================
>--- Source/JavaScriptCore/wtf/unicode/UTF8.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/unicode/UTF8.h	(working copy)
>@@ -62,11 +62,11 @@
>     // to the replacement character; otherwise (when the flag is set to strict)
>     // they constitute an error.
> 
>-    ConversionResult convertUTF8ToUTF16(
>+    WTF_EXPORT_PRIVATE ConversionResult convertUTF8ToUTF16(
>                     const char** sourceStart, const char* sourceEnd, 
>                     UChar** targetStart, UChar* targetEnd, bool strict = true);
> 
>-    ConversionResult convertUTF16ToUTF8(
>+    WTF_EXPORT_PRIVATE ConversionResult convertUTF16ToUTF8(
>                     const UChar** sourceStart, const UChar* sourceEnd, 
>                     char** targetStart, char* targetEnd, bool strict = true);
> 
>Index: Source/JavaScriptCore/wtf/CurrentTime.h
>===================================================================
>--- Source/JavaScriptCore/wtf/CurrentTime.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/CurrentTime.h	(working copy)
>@@ -39,7 +39,7 @@
> // Returns the current UTC time in seconds, counted from January 1, 1970.
> // Precision varies depending on platform but is usually as good or better
> // than a millisecond.
>-double currentTime();
>+WTF_EXPORT_PRIVATE double currentTime();
> 
> // Same thing, in milliseconds.
> inline double currentTimeMS()
>Index: Source/JavaScriptCore/wtf/DecimalNumber.h
>===================================================================
>--- Source/JavaScriptCore/wtf/DecimalNumber.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/DecimalNumber.h	(working copy)
>@@ -81,10 +81,10 @@
>         ASSERT(m_significand[0] != '0' || !m_exponent);
>     }
> 
>-    unsigned bufferLengthForStringDecimal() const;
>+    WTF_EXPORT_PRIVATE unsigned bufferLengthForStringDecimal() const;
>     unsigned bufferLengthForStringExponential() const;
> 
>-    unsigned toStringDecimal(UChar* buffer, unsigned bufferLength) const;
>+    WTF_EXPORT_PRIVATE unsigned toStringDecimal(UChar* buffer, unsigned bufferLength) const;
>     unsigned toStringExponential(UChar* buffer, unsigned bufferLength) const;
> 
>     bool sign() const { return m_sign; }
>Index: Source/JavaScriptCore/wtf/MD5.h
>===================================================================
>--- Source/JavaScriptCore/wtf/MD5.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/MD5.h	(working copy)
>@@ -35,7 +35,7 @@
> 
> namespace WTF {
> 
>-class MD5 {
>+class WTF_EXPORT_PRIVATE MD5 {
> public:
>     MD5();
> 
>Index: Source/JavaScriptCore/wtf/dtoa.h
>===================================================================
>--- Source/JavaScriptCore/wtf/dtoa.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/dtoa.h	(working copy)
>@@ -30,18 +30,18 @@
> 
> // s00: input string. Must not be 0 and must be terminated by 0.
> // se: *se will have the last consumed character position + 1.
>-double strtod(const char* s00, char** se);
>+WTF_EXPORT_PRIVATE double strtod(const char* s00, char** se);
> 
> typedef char DtoaBuffer[80];
> 
>-void dtoa(DtoaBuffer result, double dd, bool& sign, int& exponent, unsigned& precision);
>+WTF_EXPORT_PRIVATE void dtoa(DtoaBuffer result, double dd, bool& sign, int& exponent, unsigned& precision);
> void dtoaRoundSF(DtoaBuffer result, double dd, int ndigits, bool& sign, int& exponent, unsigned& precision);
> void dtoaRoundDP(DtoaBuffer result, double dd, int ndigits, bool& sign, int& exponent, unsigned& precision);
> 
> // Size = 80 for sizeof(DtoaBuffer) + some sign bits, decimal point, 'e', exponent digits.
> const unsigned NumberToStringBufferLength = 96;
> typedef UChar NumberToStringBuffer[NumberToStringBufferLength];
>-unsigned numberToString(double, NumberToStringBuffer);
>+WTF_EXPORT_PRIVATE unsigned numberToString(double, NumberToStringBuffer);
> 
> } // namespace WTF
> 
>Index: Source/JavaScriptCore/wtf/NullPtr.cpp
>===================================================================
>--- Source/JavaScriptCore/wtf/NullPtr.cpp	(revision 82010)
>+++ Source/JavaScriptCore/wtf/NullPtr.cpp	(working copy)
>@@ -24,6 +24,7 @@
> 
> */
> 
>+#include "config.h"
> #include "NullPtr.h"
> 
> #include "Platform.h"
>Index: Source/JavaScriptCore/wtf/CryptographicallyRandomNumber.h
>===================================================================
>--- Source/JavaScriptCore/wtf/CryptographicallyRandomNumber.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/CryptographicallyRandomNumber.h	(working copy)
>@@ -32,7 +32,7 @@
> 
> #if USE(OS_RANDOMNESS)
> uint32_t cryptographicallyRandomNumber();
>-void cryptographicallyRandomValues(void* buffer, size_t length);
>+WTF_EXPORT_PRIVATE void cryptographicallyRandomValues(void* buffer, size_t length);
> #endif
> 
> }
>Index: Source/JavaScriptCore/wtf/ThreadingPrimitives.h
>===================================================================
>--- Source/JavaScriptCore/wtf/ThreadingPrimitives.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/ThreadingPrimitives.h	(working copy)
>@@ -100,12 +100,12 @@
> class Mutex {
>     WTF_MAKE_NONCOPYABLE(Mutex); WTF_MAKE_FAST_ALLOCATED;
> public:
>-    Mutex();
>-    ~Mutex();
>+    WTF_EXPORT_PRIVATE Mutex();
>+    WTF_EXPORT_PRIVATE ~Mutex();
> 
>-    void lock();
>-    bool tryLock();
>-    void unlock();
>+    WTF_EXPORT_PRIVATE void lock();
>+    WTF_EXPORT_PRIVATE bool tryLock();
>+    WTF_EXPORT_PRIVATE void unlock();
> 
> public:
>     PlatformMutex& impl() { return m_mutex; }
>@@ -136,15 +136,15 @@
> class ThreadCondition {
>     WTF_MAKE_NONCOPYABLE(ThreadCondition);
> public:
>-    ThreadCondition();
>-    ~ThreadCondition();
>+    WTF_EXPORT_PRIVATE ThreadCondition();
>+    WTF_EXPORT_PRIVATE ~ThreadCondition();
>     
>-    void wait(Mutex& mutex);
>+    WTF_EXPORT_PRIVATE void wait(Mutex&);
>     // Returns true if the condition was signaled before absoluteTime, false if the absoluteTime was reached or is in the past.
>     // The absoluteTime is in seconds, starting on January 1, 1970. The time is assumed to use the same time zone as WTF::currentTime().
>-    bool timedWait(Mutex&, double absoluteTime);
>-    void signal();
>-    void broadcast();
>+    WTF_EXPORT_PRIVATE bool timedWait(Mutex&, double absoluteTime);
>+    WTF_EXPORT_PRIVATE void signal();
>+    WTF_EXPORT_PRIVATE void broadcast();
>     
> private:
>     PlatformCondition m_condition;
>Index: Source/JavaScriptCore/wtf/RandomNumber.h
>===================================================================
>--- Source/JavaScriptCore/wtf/RandomNumber.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/RandomNumber.h	(working copy)
>@@ -30,7 +30,7 @@
> 
>     // Returns a pseudo-random number in the range [0, 1), attempts to be
>     // cryptographically secure if possible on the target platform
>-    double randomNumber();
>+    WTF_EXPORT_PRIVATE double randomNumber();
> 
> }
> 
>Index: Source/JavaScriptCore/wtf/text/AtomicString.h
>===================================================================
>--- Source/JavaScriptCore/wtf/text/AtomicString.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/text/AtomicString.h	(working copy)
>@@ -38,27 +38,31 @@
> 
> class AtomicString {
> public:
>-    static void init();
>+    WTF_EXPORT_PRIVATE static void init();
> 
>-    AtomicString() { }
>-    AtomicString(const char* s) : m_string(add(s)) { }
>+    WTF_EXPORT_PRIVATE AtomicString() { }
>+    // copy constructor needs to be explicitly defined so we can specify proper dll linkage
>+    WTF_EXPORT_PRIVATE AtomicString(const AtomicString& s) : m_string(s.m_string) { }
>+    WTF_EXPORT_PRIVATE AtomicString(const char* s) : m_string(add(s)) { }
>     AtomicString(const UChar* s, unsigned length) : m_string(add(s, length)) { }
>     AtomicString(const UChar* s, unsigned length, unsigned existingHash) : m_string(add(s, length, existingHash)) { }
>     AtomicString(const UChar* s) : m_string(add(s)) { }
>     ATOMICSTRING_CONVERSION AtomicString(StringImpl* imp) : m_string(add(imp)) { }
>     AtomicString(AtomicStringImpl* imp) : m_string(imp) { }
>-    ATOMICSTRING_CONVERSION AtomicString(const String& s) : m_string(add(s.impl())) { }
>+    WTF_EXPORT_PRIVATE ATOMICSTRING_CONVERSION AtomicString(const String& s) : m_string(add(s.impl())) { }
> 
>     // Hash table deleted values, which are only constructed and never copied or destroyed.
>-    AtomicString(WTF::HashTableDeletedValueType) : m_string(WTF::HashTableDeletedValue) { }
>-    bool isHashTableDeletedValue() const { return m_string.isHashTableDeletedValue(); }
>+    WTF_EXPORT_PRIVATE AtomicString(WTF::HashTableDeletedValueType) : m_string(WTF::HashTableDeletedValue) { }
>+    WTF_EXPORT_PRIVATE bool isHashTableDeletedValue() const { return m_string.isHashTableDeletedValue(); }
> 
>-    static AtomicStringImpl* find(const UChar* s, unsigned length, unsigned existingHash);
>+    WTF_EXPORT_PRIVATE ~AtomicString() { }
> 
>+    WTF_EXPORT_PRIVATE static AtomicStringImpl* find(const UChar*, unsigned length, unsigned existingHash);
>+
>     operator const String&() const { return m_string; }
>     const String& string() const { return m_string; };
> 
>-    AtomicStringImpl* impl() const { return static_cast<AtomicStringImpl *>(m_string.impl()); }
>+    WTF_EXPORT_PRIVATE AtomicStringImpl* impl() const { return static_cast<AtomicStringImpl *>(m_string.impl()); }
>     
>     const UChar* characters() const { return m_string.characters(); }
>     unsigned length() const { return m_string.length(); }
>@@ -82,7 +86,7 @@
>     bool endsWith(const String& s, bool caseSensitive = true) const
>         { return m_string.endsWith(s, caseSensitive); }
>     
>-    AtomicString lower() const;
>+    WTF_EXPORT_PRIVATE AtomicString lower() const;
>     AtomicString upper() const { return AtomicString(impl()->upper()); }
>     
>     int toInt(bool* ok = 0) const { return m_string.toInt(ok); }
>@@ -110,14 +114,14 @@
> 
>     // AtomicString::fromUTF8 will return a null string if
>     // the input data contains invalid UTF-8 sequences.
>-    static AtomicString fromUTF8(const char*, size_t);
>-    static AtomicString fromUTF8(const char*);
>+    WTF_EXPORT_PRIVATE static AtomicString fromUTF8(const char*, size_t);
>+    WTF_EXPORT_PRIVATE static AtomicString fromUTF8(const char*);
> 
> private:
>     String m_string;
>     
>-    static PassRefPtr<StringImpl> add(const char*);
>-    static PassRefPtr<StringImpl> add(const UChar*, unsigned length);
>+    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> add(const char*);
>+    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> add(const UChar*, unsigned length);
>     static PassRefPtr<StringImpl> add(const UChar*, unsigned length, unsigned existingHash);
>     static PassRefPtr<StringImpl> add(const UChar*);
>     ALWAYS_INLINE PassRefPtr<StringImpl> add(StringImpl* r)
>@@ -126,12 +130,12 @@
>             return r;
>         return addSlowCase(r);
>     }
>-    static PassRefPtr<StringImpl> addSlowCase(StringImpl*);
>+    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> addSlowCase(StringImpl*);
> };
> 
> inline bool operator==(const AtomicString& a, const AtomicString& b) { return a.impl() == b.impl(); }
>-bool operator==(const AtomicString& a, const char* b);
>-bool operator==(const AtomicString& a, const Vector<UChar>& b);
>+WTF_EXPORT_PRIVATE bool operator==(const AtomicString&, const char*);
>+WTF_EXPORT_PRIVATE bool operator==(const AtomicString&, const Vector<UChar>&);
> inline bool operator==(const AtomicString& a, const String& b) { return equal(a.impl(), b.impl()); }
> inline bool operator==(const char* a, const AtomicString& b) { return b == a; }
> inline bool operator==(const String& a, const AtomicString& b) { return equal(a.impl(), b.impl()); }
>Index: Source/JavaScriptCore/wtf/text/CString.h
>===================================================================
>--- Source/JavaScriptCore/wtf/text/CString.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/text/CString.h	(working copy)
>@@ -52,10 +52,10 @@
> class CString {
> public:
>     CString() { }
>-    CString(const char*);
>-    CString(const char*, size_t length);
>+    WTF_EXPORT_PRIVATE CString(const char*);
>+    WTF_EXPORT_PRIVATE CString(const char*, size_t length);
>     CString(CStringBuffer* buffer) : m_buffer(buffer) { }
>-    static CString newUninitialized(size_t length, char*& characterBuffer);
>+    WTF_EXPORT_PRIVATE static CString newUninitialized(size_t length, char*& characterBuffer);
> 
>     const char* data() const
>     {
>@@ -77,7 +77,7 @@
>     RefPtr<CStringBuffer> m_buffer;
> };
> 
>-bool operator==(const CString& a, const CString& b);
>+WTF_EXPORT_PRIVATE bool operator==(const CString& a, const CString& b);
> inline bool operator!=(const CString& a, const CString& b) { return !(a == b); }
> 
> } // namespace WTF
>Index: Source/JavaScriptCore/wtf/text/StringBuilder.h
>===================================================================
>--- Source/JavaScriptCore/wtf/text/StringBuilder.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/text/StringBuilder.h	(working copy)
>@@ -38,8 +38,8 @@
>     {
>     }
> 
>-    void append(const UChar*, unsigned);
>-    void append(const char*, unsigned);
>+    WTF_EXPORT_PRIVATE void append(const UChar*, unsigned);
>+    WTF_EXPORT_PRIVATE void append(const char*, unsigned);
> 
>     void append(const String& string)
>     {
>@@ -99,11 +99,11 @@
> 
>     bool isEmpty() const { return !length(); }
> 
>-    void reserveCapacity(unsigned newCapacity);
>+    WTF_EXPORT_PRIVATE void reserveCapacity(unsigned newCapacity);
> 
>-    void resize(unsigned newSize);
>+    WTF_EXPORT_PRIVATE void resize(unsigned newSize);
> 
>-    void shrinkToFit();
>+    WTF_EXPORT_PRIVATE void shrinkToFit();
> 
>     UChar operator[](unsigned i) const
>     {
>@@ -124,7 +124,7 @@
> private:
>     void allocateBuffer(const UChar* currentCharacters, unsigned requiredLength);
>     UChar* appendUninitialized(unsigned length);
>-    void reifyString();
>+    WTF_EXPORT_PRIVATE void reifyString();
> 
>     unsigned m_length;
>     String m_string;
>Index: Source/JavaScriptCore/wtf/text/WTFString.h
>===================================================================
>--- Source/JavaScriptCore/wtf/text/WTFString.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/text/WTFString.h	(working copy)
>@@ -67,8 +67,8 @@
> 
> bool charactersAreAllASCII(const UChar*, size_t);
> bool charactersAreAllLatin1(const UChar*, size_t);
>-int charactersToIntStrict(const UChar*, size_t, bool* ok = 0, int base = 10);
>-unsigned charactersToUIntStrict(const UChar*, size_t, bool* ok = 0, int base = 10);
>+WTF_EXPORT_PRIVATE int charactersToIntStrict(const UChar*, size_t, bool* ok = 0, int base = 10);
>+WTF_EXPORT_PRIVATE unsigned charactersToUIntStrict(const UChar*, size_t, bool* ok = 0, int base = 10);
> int64_t charactersToInt64Strict(const UChar*, size_t, bool* ok = 0, int base = 10);
> uint64_t charactersToUInt64Strict(const UChar*, size_t, bool* ok = 0, int base = 10);
> intptr_t charactersToIntPtrStrict(const UChar*, size_t, bool* ok = 0, int base = 10);
>@@ -79,7 +79,7 @@
> uint64_t charactersToUInt64(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
> intptr_t charactersToIntPtr(const UChar*, size_t, bool* ok = 0); // ignores trailing garbage
> 
>-double charactersToDouble(const UChar*, size_t, bool* ok = 0, bool* didReadNumber = 0);
>+WTF_EXPORT_PRIVATE double charactersToDouble(const UChar*, size_t, bool* ok = 0, bool* didReadNumber = 0);
> float charactersToFloat(const UChar*, size_t, bool* ok = 0, bool* didReadNumber = 0);
> 
> template<bool isSpecialCharacter(UChar)> bool isAllSpecialCharacters(const UChar*, size_t);
>@@ -87,10 +87,10 @@
> class String {
> public:
>     // Construct a null string, distinguishable from an empty string.
>-    String() { }
>+    WTF_EXPORT_PRIVATE String() { }
> 
>     // Construct a string with UTF-16 data.
>-    String(const UChar* characters, unsigned length);
>+    WTF_EXPORT_PRIVATE String(const UChar* characters, unsigned length);
> 
>     // Construct a string by copying the contents of a vector.  To avoid
>     // copying, consider using String::adopt instead.
>@@ -98,18 +98,18 @@
>     explicit String(const Vector<UChar, inlineCapacity>&);
> 
>     // Construct a string with UTF-16 data, from a null-terminated source.
>-    String(const UChar*);
>+    WTF_EXPORT_PRIVATE String(const UChar*);
> 
>     // Construct a string with latin1 data.
>-    String(const char* characters, unsigned length);
>+    WTF_EXPORT_PRIVATE String(const char* characters, unsigned length);
> 
>     // Construct a string with latin1 data, from a null-terminated source.
>-    String(const char* characters);
>+    WTF_EXPORT_PRIVATE String(const char* characters);
> 
>     // Construct a string referencing an existing StringImpl.
>-    String(StringImpl* impl) : m_impl(impl) { }
>-    String(PassRefPtr<StringImpl> impl) : m_impl(impl) { }
>-    String(RefPtr<StringImpl> impl) : m_impl(impl) { }
>+    WTF_EXPORT_PRIVATE String(StringImpl* impl) : m_impl(impl) { }
>+    WTF_EXPORT_PRIVATE String(PassRefPtr<StringImpl> impl) : m_impl(impl) { }
>+    WTF_EXPORT_PRIVATE String(RefPtr<StringImpl> impl) : m_impl(impl) { }
> 
>     // Inline the destructor.
>     ALWAYS_INLINE ~String() { }
>@@ -139,9 +139,9 @@
>         return m_impl->characters();
>     }
> 
>-    CString ascii() const;
>-    CString latin1() const;
>-    CString utf8(bool strict = false) const;
>+    WTF_EXPORT_PRIVATE CString ascii() const;
>+    WTF_EXPORT_PRIVATE CString latin1() const;
>+    WTF_EXPORT_PRIVATE CString utf8(bool strict = false) const;
> 
>     UChar operator[](unsigned index) const
>     {
>@@ -150,15 +150,15 @@
>         return m_impl->characters()[index];
>     }
> 
>-    static String number(short);
>-    static String number(unsigned short);
>-    static String number(int);
>-    static String number(unsigned);
>-    static String number(long);
>-    static String number(unsigned long);
>-    static String number(long long);
>-    static String number(unsigned long long);
>-    static String number(double);
>+    WTF_EXPORT_PRIVATE static String number(short);
>+    WTF_EXPORT_PRIVATE static String number(unsigned short);
>+    WTF_EXPORT_PRIVATE static String number(int);
>+    WTF_EXPORT_PRIVATE static String number(unsigned);
>+    WTF_EXPORT_PRIVATE static String number(long);
>+    WTF_EXPORT_PRIVATE static String number(unsigned long);
>+    WTF_EXPORT_PRIVATE static String number(long long);
>+    WTF_EXPORT_PRIVATE static String number(unsigned long long);
>+    WTF_EXPORT_PRIVATE static String number(double);
> 
>     // Find a single character or string, also with match function & latin1 forms.
>     size_t find(UChar c, unsigned start = 0) const
>@@ -177,9 +177,9 @@
>         { return m_impl ? m_impl->reverseFind(str.impl(), start) : notFound; }
> 
>     // Case insensitive string matching.
>-    size_t findIgnoringCase(const char* str, unsigned start = 0) const
>+    WTF_EXPORT_PRIVATE size_t findIgnoringCase(const char* str, unsigned start = 0) const
>         { return m_impl ? m_impl->findIgnoringCase(str, start) : notFound; }
>-    size_t findIgnoringCase(const String& str, unsigned start = 0) const
>+    WTF_EXPORT_PRIVATE size_t findIgnoringCase(const String& str, unsigned start = 0) const
>         { return m_impl ? m_impl->findIgnoringCase(str.impl(), start) : notFound; }
>     size_t reverseFindIgnoringCase(const String& str, unsigned start = UINT_MAX) const
>         { return m_impl ? m_impl->reverseFindIgnoringCase(str.impl(), start) : notFound; }
>@@ -192,9 +192,9 @@
>     size_t reverseFind(const String& str, unsigned start, bool caseSensitive) const
>         { return caseSensitive ? reverseFind(str, start) : reverseFindIgnoringCase(str, start); }
> 
>-    const UChar* charactersWithNullTermination();
>+    WTF_EXPORT_PRIVATE const UChar* charactersWithNullTermination();
>     
>-    UChar32 characterStartingAt(unsigned) const; // Ditto.
>+    WTF_EXPORT_PRIVATE UChar32 characterStartingAt(unsigned) const; // Ditto.
>     
>     bool contains(UChar c) const { return find(c) != notFound; }
>     bool contains(const char* str, bool caseSensitive = true) const { return find(str, 0, caseSensitive) != notFound; }
>@@ -205,11 +205,11 @@
>     bool endsWith(const String& s, bool caseSensitive = true) const
>         { return m_impl ? m_impl->endsWith(s.impl(), caseSensitive) : s.isEmpty(); }
> 
>-    void append(const String&);
>-    void append(char);
>-    void append(UChar);
>-    void append(const UChar*, unsigned length);
>-    void insert(const String&, unsigned pos);
>+    WTF_EXPORT_PRIVATE void append(const String&);
>+    WTF_EXPORT_PRIVATE void append(char);
>+    WTF_EXPORT_PRIVATE void append(UChar);
>+    WTF_EXPORT_PRIVATE void append(const UChar*, unsigned length);
>+    WTF_EXPORT_PRIVATE void insert(const String&, unsigned pos);
>     void insert(const UChar*, unsigned length, unsigned pos);
> 
>     String& replace(UChar a, UChar b) { if (m_impl) m_impl = m_impl->replace(a, b); return *this; }
>@@ -221,31 +221,31 @@
>     void makeUpper() { if (m_impl) m_impl = m_impl->upper(); }
>     void makeSecure(UChar aChar) { if (m_impl) m_impl = m_impl->secure(aChar); }
> 
>-    void truncate(unsigned len);
>-    void remove(unsigned pos, int len = 1);
>+    WTF_EXPORT_PRIVATE void truncate(unsigned len);
>+    WTF_EXPORT_PRIVATE void remove(unsigned pos, int len = 1);
> 
>-    String substring(unsigned pos, unsigned len = UINT_MAX) const;
>+    WTF_EXPORT_PRIVATE String substring(unsigned pos, unsigned len = UINT_MAX) const;
>     String substringSharingImpl(unsigned pos, unsigned len = UINT_MAX) const;
>     String left(unsigned len) const { return substring(0, len); }
>     String right(unsigned len) const { return substring(length() - len, len); }
> 
>     // Returns a lowercase/uppercase version of the string
>-    String lower() const;
>-    String upper() const;
>+    WTF_EXPORT_PRIVATE String lower() const;
>+    WTF_EXPORT_PRIVATE String upper() const;
> 
>-    String stripWhiteSpace() const;
>-    String simplifyWhiteSpace() const;
>+    WTF_EXPORT_PRIVATE String stripWhiteSpace() const;
>+    WTF_EXPORT_PRIVATE String simplifyWhiteSpace() const;
> 
>-    String removeCharacters(CharacterMatchFunctionPtr) const;
>+    WTF_EXPORT_PRIVATE String removeCharacters(CharacterMatchFunctionPtr) const;
>     template<bool isSpecialCharacter(UChar)> bool isAllSpecialCharacters() const;
> 
>     // Return the string with case folded for case insensitive comparison.
>-    String foldCase() const;
>+    WTF_EXPORT_PRIVATE String foldCase() const;
> 
> #if !PLATFORM(QT)
>-    static String format(const char *, ...) WTF_ATTRIBUTE_PRINTF(1, 2);
>+    WTF_EXPORT_PRIVATE static String format(const char *, ...) WTF_ATTRIBUTE_PRINTF(1, 2);
> #else
>-    static String format(const char *, ...);
>+    WTF_EXPORT_PRIVATE static String format(const char *, ...);
> #endif
> 
>     // Returns an uninitialized string. The characters needs to be written
>@@ -253,34 +253,34 @@
>     // Failure to do this will have unpredictable results.
>     static String createUninitialized(unsigned length, UChar*& data) { return StringImpl::createUninitialized(length, data); }
> 
>-    void split(const String& separator, Vector<String>& result) const;
>-    void split(const String& separator, bool allowEmptyEntries, Vector<String>& result) const;
>-    void split(UChar separator, Vector<String>& result) const;
>-    void split(UChar separator, bool allowEmptyEntries, Vector<String>& result) const;
>+    WTF_EXPORT_PRIVATE void split(const String& separator, Vector<String>& result) const;
>+    WTF_EXPORT_PRIVATE void split(const String& separator, bool allowEmptyEntries, Vector<String>& result) const;
>+    WTF_EXPORT_PRIVATE void split(UChar separator, Vector<String>& result) const;
>+    WTF_EXPORT_PRIVATE void split(UChar separator, bool allowEmptyEntries, Vector<String>& result) const;
> 
>-    int toIntStrict(bool* ok = 0, int base = 10) const;
>-    unsigned toUIntStrict(bool* ok = 0, int base = 10) const;
>-    int64_t toInt64Strict(bool* ok = 0, int base = 10) const;
>-    uint64_t toUInt64Strict(bool* ok = 0, int base = 10) const;
>-    intptr_t toIntPtrStrict(bool* ok = 0, int base = 10) const;
>+    WTF_EXPORT_PRIVATE int toIntStrict(bool* ok = 0, int base = 10) const;
>+    WTF_EXPORT_PRIVATE unsigned toUIntStrict(bool* ok = 0, int base = 10) const;
>+    WTF_EXPORT_PRIVATE int64_t toInt64Strict(bool* ok = 0, int base = 10) const;
>+    WTF_EXPORT_PRIVATE uint64_t toUInt64Strict(bool* ok = 0, int base = 10) const;
>+    WTF_EXPORT_PRIVATE intptr_t toIntPtrStrict(bool* ok = 0, int base = 10) const;
> 
>-    int toInt(bool* ok = 0) const;
>-    unsigned toUInt(bool* ok = 0) const;
>+    WTF_EXPORT_PRIVATE int toInt(bool* ok = 0) const;
>+    WTF_EXPORT_PRIVATE unsigned toUInt(bool* ok = 0) const;
>     int64_t toInt64(bool* ok = 0) const;
>-    uint64_t toUInt64(bool* ok = 0) const;
>-    intptr_t toIntPtr(bool* ok = 0) const;
>-    double toDouble(bool* ok = 0, bool* didReadNumber = 0) const;
>-    float toFloat(bool* ok = 0, bool* didReadNumber = 0) const;
>+    WTF_EXPORT_PRIVATE uint64_t toUInt64(bool* ok = 0) const;
>+    WTF_EXPORT_PRIVATE intptr_t toIntPtr(bool* ok = 0) const;
>+    WTF_EXPORT_PRIVATE double toDouble(bool* ok = 0, bool* didReadNumber = 0) const;
>+    WTF_EXPORT_PRIVATE float toFloat(bool* ok = 0, bool* didReadNumber = 0) const;
> 
>     bool percentage(int& percentage) const;
> 
>     // Returns a StringImpl suitable for use on another thread.
>-    String crossThreadString() const;
>+    WTF_EXPORT_PRIVATE String crossThreadString() const;
>     // Makes a deep copy. Helpful only if you need to use a String on another thread
>     // (use crossThreadString if the method call doesn't need to be threadsafe).
>     // Since the underlying StringImpl objects are immutable, there's no other reason
>     // to ever prefer copy() over plain old assignment.
>-    String threadsafeCopy() const;
>+    WTF_EXPORT_PRIVATE String threadsafeCopy() const;
> 
>     // Prevent Strings from being implicitly convertable to bool as it will be ambiguous on any platform that
>     // allows implicit conversion to another pointer type (e.g., Mac allows implicit conversion to NSString*).
>@@ -309,8 +309,8 @@
> #endif
> 
> #if PLATFORM(WX)
>-    String(const wxString&);
>-    operator wxString() const;
>+    WTF_EXPORT_PRIVATE String(const wxString&);
>+    WTF_EXPORT_PRIVATE operator wxString() const;
> #endif
> 
> #if PLATFORM(HAIKU)
>@@ -324,11 +324,11 @@
> 
>     // String::fromUTF8 will return a null string if
>     // the input data contains invalid UTF-8 sequences.
>-    static String fromUTF8(const char*, size_t);
>-    static String fromUTF8(const char*);
>+    WTF_EXPORT_PRIVATE static String fromUTF8(const char*, size_t);
>+    WTF_EXPORT_PRIVATE static String fromUTF8(const char*);
> 
>     // Tries to convert the passed in string to UTF-8, but will fall back to Latin-1 if the string is not valid UTF-8.
>-    static String fromUTF8WithLatin1Fallback(const char*, size_t);
>+    WTF_EXPORT_PRIVATE static String fromUTF8WithLatin1Fallback(const char*, size_t);
>     
>     // Determines the writing direction using the Unicode Bidi Algorithm rules P2 and P3.
>     WTF::Unicode::Direction defaultWritingDirection(bool* hasStrongDirectionality = 0) const
>@@ -345,7 +345,7 @@
> 
>     // Hash table deleted values, which are only constructed and never copied or destroyed.
>     String(WTF::HashTableDeletedValueType) : m_impl(WTF::HashTableDeletedValue) { }
>-    bool isHashTableDeletedValue() const { return m_impl.isHashTableDeletedValue(); }
>+    WTF_EXPORT_PRIVATE bool isHashTableDeletedValue() const { return m_impl.isHashTableDeletedValue(); }
> 
> private:
>     RefPtr<StringImpl> m_impl;
>@@ -356,9 +356,9 @@
> QDataStream& operator>>(QDataStream& stream, String& str);
> #endif
> 
>-String operator+(const String&, const String&);
>-String operator+(const String&, const char*);
>-String operator+(const char*, const String&);
>+WTF_EXPORT_PRIVATE String operator+(const String&, const String&);
>+WTF_EXPORT_PRIVATE String operator+(const String&, const char*);
>+WTF_EXPORT_PRIVATE String operator+(const char*, const String&);
> 
> inline String& operator+=(String& a, const String& b) { a.append(b); return a; }
> 
>@@ -419,7 +419,7 @@
>     return !(ored & 0xFF00);
> }
> 
>-int codePointCompare(const String&, const String&);
>+WTF_EXPORT_PRIVATE int codePointCompare(const String&, const String&);
> 
> inline size_t find(const UChar* characters, unsigned length, UChar matchCharacter, unsigned index = 0)
> {
>Index: Source/JavaScriptCore/wtf/text/StringImpl.h
>===================================================================
>--- Source/JavaScriptCore/wtf/text/StringImpl.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/text/StringImpl.h	(working copy)
>@@ -141,11 +141,11 @@
>     }
> 
> public:
>-    ~StringImpl();
>+    WTF_EXPORT_PRIVATE ~StringImpl();
> 
>-    static PassRefPtr<StringImpl> create(const UChar*, unsigned length);
>-    static PassRefPtr<StringImpl> create(const char*, unsigned length);
>-    static PassRefPtr<StringImpl> create(const char*);
>+    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> create(const UChar*, unsigned length);
>+    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> create(const char*, unsigned length);
>+    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> create(const char*);
>     static PassRefPtr<StringImpl> create(const UChar*, unsigned length, PassRefPtr<SharedUChar> sharedBuffer);
>     static ALWAYS_INLINE PassRefPtr<StringImpl> create(PassRefPtr<StringImpl> rep, unsigned offset, unsigned length)
>     {
>@@ -159,7 +159,7 @@
>         return adoptRef(new StringImpl(rep->m_data + offset, length, ownerRep));
>     }
> 
>-    static PassRefPtr<StringImpl> createUninitialized(unsigned length, UChar*& data);
>+    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> createUninitialized(unsigned length, UChar*& data);
>     static ALWAYS_INLINE PassRefPtr<StringImpl> tryCreateUninitialized(unsigned length, UChar*& output)
>     {
>         if (!length) {
>@@ -195,10 +195,10 @@
>         }
>         return empty();
>     }
>-    static PassRefPtr<StringImpl> adopt(StringBuffer&);
>+    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> adopt(StringBuffer&);
> 
>     SharedUChar* sharedBuffer();
>-    const UChar* characters() const { return m_data; }
>+    WTF_EXPORT_PRIVATE const UChar* characters() const { return m_data; }
> 
>     size_t cost()
>     {
>@@ -241,7 +241,7 @@
>     ALWAYS_INLINE void deref() { m_refCountAndFlags -= s_refCountIncrement; if (!(m_refCountAndFlags & (s_refCountMask | s_refCountFlagStatic))) delete this; }
>     ALWAYS_INLINE bool hasOneRef() const { return (m_refCountAndFlags & (s_refCountMask | s_refCountFlagStatic)) == s_refCountIncrement; }
> 
>-    static StringImpl* empty();
>+    WTF_EXPORT_PRIVATE static StringImpl* empty();
> 
>     static void copyChars(UChar* destination, const UChar* source, unsigned numCharacters)
>     {
>@@ -259,12 +259,12 @@
>     // Since StringImpl objects are immutable, there's no other reason to make a copy.
>     PassRefPtr<StringImpl> threadsafeCopy() const;
> 
>-    PassRefPtr<StringImpl> substring(unsigned pos, unsigned len = UINT_MAX);
>+    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> substring(unsigned pos, unsigned len = UINT_MAX);
> 
>     UChar operator[](unsigned i) { ASSERT(i < m_length); return m_data[i]; }
>     UChar32 characterStartingAt(unsigned);
> 
>-    bool containsOnlyWhitespace();
>+    WTF_EXPORT_PRIVATE bool containsOnlyWhitespace();
> 
>     int toIntStrict(bool* ok = 0, int base = 10);
>     unsigned toUIntStrict(bool* ok = 0, int base = 10);
>@@ -272,7 +272,7 @@
>     uint64_t toUInt64Strict(bool* ok = 0, int base = 10);
>     intptr_t toIntPtrStrict(bool* ok = 0, int base = 10);
> 
>-    int toInt(bool* ok = 0); // ignores trailing garbage
>+    WTF_EXPORT_PRIVATE int toInt(bool* ok = 0); // ignores trailing garbage
>     unsigned toUInt(bool* ok = 0); // ignores trailing garbage
>     int64_t toInt64(bool* ok = 0); // ignores trailing garbage
>     uint64_t toUInt64(bool* ok = 0); // ignores trailing garbage
>@@ -281,39 +281,39 @@
>     double toDouble(bool* ok = 0, bool* didReadNumber = 0);
>     float toFloat(bool* ok = 0, bool* didReadNumber = 0);
> 
>-    PassRefPtr<StringImpl> lower();
>-    PassRefPtr<StringImpl> upper();
>+    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> lower();
>+    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> upper();
> 
>     enum LastCharacterBehavior { ObscureLastCharacter, DisplayLastCharacter };
> 
>-    PassRefPtr<StringImpl> secure(UChar, LastCharacterBehavior = ObscureLastCharacter);
>+    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> secure(UChar, LastCharacterBehavior = ObscureLastCharacter);
>     PassRefPtr<StringImpl> foldCase();
> 
>     PassRefPtr<StringImpl> stripWhiteSpace();
>-    PassRefPtr<StringImpl> simplifyWhiteSpace();
>+    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> simplifyWhiteSpace();
> 
>     PassRefPtr<StringImpl> removeCharacters(CharacterMatchFunctionPtr);
> 
>-    size_t find(UChar, unsigned index = 0);
>-    size_t find(CharacterMatchFunctionPtr, unsigned index = 0);
>-    size_t find(const char*, unsigned index = 0);
>-    size_t find(StringImpl*, unsigned index = 0);
>-    size_t findIgnoringCase(const char*, unsigned index = 0);
>-    size_t findIgnoringCase(StringImpl*, unsigned index = 0);
>+    WTF_EXPORT_PRIVATE size_t find(UChar, unsigned index = 0);
>+    WTF_EXPORT_PRIVATE size_t find(CharacterMatchFunctionPtr, unsigned index = 0);
>+    WTF_EXPORT_PRIVATE size_t find(const char*, unsigned index = 0);
>+    WTF_EXPORT_PRIVATE size_t find(StringImpl*, unsigned index = 0);
>+    WTF_EXPORT_PRIVATE size_t findIgnoringCase(const char*, unsigned index = 0);
>+    WTF_EXPORT_PRIVATE size_t findIgnoringCase(StringImpl*, unsigned index = 0);
> 
>-    size_t reverseFind(UChar, unsigned index = UINT_MAX);
>-    size_t reverseFind(StringImpl*, unsigned index = UINT_MAX);
>-    size_t reverseFindIgnoringCase(StringImpl*, unsigned index = UINT_MAX);
>+    WTF_EXPORT_PRIVATE size_t reverseFind(UChar, unsigned index = UINT_MAX);
>+    WTF_EXPORT_PRIVATE size_t reverseFind(StringImpl*, unsigned index = UINT_MAX);
>+    WTF_EXPORT_PRIVATE size_t reverseFindIgnoringCase(StringImpl*, unsigned index = UINT_MAX);
> 
>     bool startsWith(StringImpl* str, bool caseSensitive = true) { return (caseSensitive ? reverseFind(str, 0) : reverseFindIgnoringCase(str, 0)) == 0; }
>-    bool endsWith(StringImpl*, bool caseSensitive = true);
>+    WTF_EXPORT_PRIVATE bool endsWith(StringImpl*, bool caseSensitive = true);
> 
>-    PassRefPtr<StringImpl> replace(UChar, UChar);
>-    PassRefPtr<StringImpl> replace(UChar, StringImpl*);
>-    PassRefPtr<StringImpl> replace(StringImpl*, StringImpl*);
>-    PassRefPtr<StringImpl> replace(unsigned index, unsigned len, StringImpl*);
>+    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> replace(UChar, UChar);
>+    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> replace(UChar, StringImpl*);
>+    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> replace(StringImpl*, StringImpl*);
>+    WTF_EXPORT_PRIVATE PassRefPtr<StringImpl> replace(unsigned index, unsigned len, StringImpl*);
> 
>-    WTF::Unicode::Direction defaultWritingDirection(bool* hasStrongDirectionality = 0);
>+    WTF_EXPORT_PRIVATE WTF::Unicode::Direction defaultWritingDirection(bool* hasStrongDirectionality = 0);
> 
> #if USE(CF)
>     CFStringRef createCFString();
>@@ -326,7 +326,7 @@
>     // This number must be at least 2 to avoid sharing empty, null as well as 1 character strings from SmallStrings.
>     static const unsigned s_copyCharsInlineCutOff = 20;
> 
>-    static PassRefPtr<StringImpl> createStrippingNullCharactersSlowCase(const UChar*, unsigned length);
>+    WTF_EXPORT_PRIVATE static PassRefPtr<StringImpl> createStrippingNullCharactersSlowCase(const UChar*, unsigned length);
>     
>     BufferOwnership bufferOwnership() const { return static_cast<BufferOwnership>(m_refCountAndFlags & s_refCountMaskBufferOwnership); }
>     bool isStatic() const { return m_refCountAndFlags & s_refCountFlagStatic; }
>@@ -339,17 +339,17 @@
>     mutable unsigned m_hash;
> };
> 
>-bool equal(const StringImpl*, const StringImpl*);
>-bool equal(const StringImpl*, const char*);
>+WTF_EXPORT_PRIVATE bool equal(const StringImpl*, const StringImpl*);
>+WTF_EXPORT_PRIVATE bool equal(const StringImpl*, const char*);
> inline bool equal(const char* a, StringImpl* b) { return equal(b, a); }
> 
>-bool equalIgnoringCase(StringImpl*, StringImpl*);
>-bool equalIgnoringCase(StringImpl*, const char*);
>+WTF_EXPORT_PRIVATE bool equalIgnoringCase(StringImpl*, StringImpl*);
>+WTF_EXPORT_PRIVATE bool equalIgnoringCase(StringImpl*, const char*);
> inline bool equalIgnoringCase(const char* a, StringImpl* b) { return equalIgnoringCase(b, a); }
>-bool equalIgnoringCase(const UChar* a, const char* b, unsigned length);
>+WTF_EXPORT_PRIVATE bool equalIgnoringCase(const UChar*, const char*, unsigned length);
> inline bool equalIgnoringCase(const char* a, const UChar* b, unsigned length) { return equalIgnoringCase(b, a, length); }
> 
>-bool equalIgnoringNullity(StringImpl*, StringImpl*);
>+WTF_EXPORT_PRIVATE bool equalIgnoringNullity(StringImpl*, StringImpl*);
> 
> template<size_t inlineCapacity>
> bool equalIgnoringNullity(const Vector<UChar, inlineCapacity>& a, StringImpl* b)
>Index: Source/JavaScriptCore/wtf/ByteArray.h
>===================================================================
>--- Source/JavaScriptCore/wtf/ByteArray.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/ByteArray.h	(working copy)
>@@ -80,7 +80,7 @@
>             }
>         }
> 
>-        static PassRefPtr<ByteArray> create(size_t size);
>+        WTF_EXPORT_PRIVATE static PassRefPtr<ByteArray> create(size_t);
> 
>     private:
>         ByteArray(size_t size)
>Index: Source/JavaScriptCore/wtf/Platform.h
>===================================================================
>--- Source/JavaScriptCore/wtf/Platform.h	(revision 82010)
>+++ Source/JavaScriptCore/wtf/Platform.h	(working copy)
>@@ -1193,6 +1193,9 @@
>    since most ports try to support sub-project independence, adding new headers
>    to WTF causes many ports to break, and so this way we can address the build
>    breakages one port at a time. */
>+#if PLATFORM(WX)
>+#define WTF_USE_EXPORT_MACROS 1
>+#else
> #define WTF_USE_EXPORT_MACROS 0
>-
>+#endif
> #endif /* WTF_Platform_h */
>Index: Source/JavaScriptCore/interpreter/Interpreter.h
>===================================================================
>--- Source/JavaScriptCore/interpreter/Interpreter.h	(revision 82010)
>+++ Source/JavaScriptCore/interpreter/Interpreter.h	(working copy)
>@@ -100,8 +100,8 @@
>         JSValue execute(EvalExecutable* evalNode, CallFrame* exec, JSObject* thisObj, ScopeChainNode* scopeChain);
> 
>         JSValue retrieveArguments(CallFrame*, JSFunction*) const;
>-        JSValue retrieveCaller(CallFrame*, JSFunction*) const;
>-        void retrieveLastCaller(CallFrame*, int& lineNumber, intptr_t& sourceID, UString& sourceURL, JSValue& function) const;
>+        JS_EXPORT_PRIVATE JSValue retrieveCaller(CallFrame*, JSFunction*) const;
>+        JS_EXPORT_PRIVATE void retrieveLastCaller(CallFrame*, int& lineNumber, intptr_t& sourceID, UString& sourceURL, JSValue& function) const;
>         
>         void getArgumentsData(CallFrame*, JSFunction*&, ptrdiff_t& firstParameterIndex, Register*& argv, int& argc);
>         
>Index: Source/JavaScriptCore/yarr/YarrPattern.h
>===================================================================
>--- Source/JavaScriptCore/yarr/YarrPattern.h	(revision 82010)
>+++ Source/JavaScriptCore/yarr/YarrPattern.h	(working copy)
>@@ -313,7 +313,7 @@
> };
> 
> struct YarrPattern {
>-    YarrPattern(const UString& pattern, bool ignoreCase, bool multiline, const char** error);
>+    JS_EXPORT_PRIVATE YarrPattern(const UString& pattern, bool ignoreCase, bool multiline, const char** error);
> 
>     ~YarrPattern()
>     {
>Index: Source/JavaScriptCore/yarr/Yarr.h
>===================================================================
>--- Source/JavaScriptCore/yarr/Yarr.h	(revision 82010)
>+++ Source/JavaScriptCore/yarr/Yarr.h	(working copy)
>@@ -57,8 +57,8 @@
>     JSRegExpErrorInternal = -4
> };
> 
>-PassOwnPtr<BytecodePattern> byteCompile(YarrPattern&, BumpPointerAllocator*);
>-int interpret(BytecodePattern*, const UChar* input, unsigned start, unsigned length, int* output);
>+JS_EXPORT_PRIVATE PassOwnPtr<BytecodePattern> byteCompile(YarrPattern&, BumpPointerAllocator*);
>+JS_EXPORT_PRIVATE int interpret(BytecodePattern*, const UChar* input, unsigned start, unsigned length, int* output);
> 
> } } // namespace JSC::Yarr
> 
>Index: Source/JavaScriptCore/ChangeLog
>===================================================================
>--- Source/JavaScriptCore/ChangeLog	(revision 82044)
>+++ Source/JavaScriptCore/ChangeLog	(working copy)
>@@ -1,3 +1,102 @@
>+2011-03-26  Kevin Ollivier  <kevino@theolliviers.com>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Need a short description and bug URL (OOPS!)
>+
>+        * bytecompiler/BytecodeGenerator.h:
>+        * collector/handles/HandleHeap.h:
>+        * config.h:
>+        * debugger/Debugger.h:
>+        * debugger/DebuggerCallFrame.h:
>+        * interpreter/Interpreter.h:
>+        * parser/SourceProviderCache.h:
>+        * profiler/Profiler.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/Heap.h:
>+        * runtime/Identifier.h:
>+        (JSC::Identifier::toUInt32):
>+        (JSC::Identifier::equal):
>+        * runtime/InitializeThreading.h:
>+        * runtime/InternalFunction.h:
>+        * runtime/JSArray.h:
>+        * runtime/JSByteArray.h:
>+        * runtime/JSCell.h:
>+        (JSC::JSCell::JSCell::classInfo):
>+        (JSC::JSCell::JSCell::vptr):
>+        (JSC::JSCell::JSCell::setVPtr):
>+        (JSC::JSCell::JSCell::isString):
>+        * runtime/JSFunction.h:
>+        * runtime/JSGlobalData.h:
>+        * runtime/JSGlobalObject.h:
>+        * runtime/JSLock.h:
>+        * runtime/JSObject.h:
>+        * runtime/JSObjectWithGlobalObject.h:
>+        * runtime/JSValue.h:
>+        * runtime/JSVariableObject.h:
>+        * runtime/JSWrapperObject.h:
>+        * runtime/Lookup.h:
>+        * runtime/MarkedSpace.h:
>+        * runtime/ObjectPrototype.h:
>+        * runtime/PropertyDescriptor.h:
>+        * runtime/PropertyNameArray.h:
>+        (JSC::PropertyNameArray::add):
>+        * runtime/PropertySlot.h:
>+        * runtime/RegExp.h:
>+        * runtime/RegExpObject.h:
>+        * runtime/RopeImpl.h:
>+        * runtime/ScopeChain.h:
>+        * runtime/SmallStrings.h:
>+        * runtime/StringObject.h:
>+        * runtime/Structure.h:
>+        * runtime/TimeoutChecker.h:
>+        * runtime/UString.h:
>+        (JSC::UString::UString):
>+        * wscript:
>+        * wtf/ByteArray.h:
>+        * wtf/CryptographicallyRandomNumber.h:
>+        * wtf/CurrentTime.h:
>+        * wtf/DateMath.h:
>+        * wtf/DecimalNumber.h:
>+        * wtf/FastMalloc.h:
>+        * wtf/MD5.h:
>+        * wtf/MainThread.h:
>+        * wtf/NullPtr.cpp:
>+        * wtf/NullPtr.h:
>+        * wtf/OSAllocator.h:
>+        * wtf/Platform.h:
>+        * wtf/RandomNumber.h:
>+        * wtf/RefCountedLeakCounter.h:
>+        * wtf/ThreadSpecific.h:
>+        * wtf/Threading.h:
>+        * wtf/ThreadingPrimitives.h:
>+        * wtf/WTFThreadData.h:
>+        * wtf/dtoa.h:
>+        * wtf/text/AtomicString.h:
>+        (WTF::AtomicString::AtomicString):
>+        (WTF::AtomicString::isHashTableDeletedValue):
>+        (WTF::AtomicString::~AtomicString):
>+        (WTF::AtomicString::impl):
>+        * wtf/text/CString.h:
>+        * wtf/text/StringBuilder.h:
>+        * wtf/text/StringImpl.h:
>+        (WTF::StringImpl::characters):
>+        * wtf/text/WTFString.h:
>+        (WTF::String::String):
>+        (WTF::String::findIgnoringCase):
>+        (WTF::String::isHashTableDeletedValue):
>+        * wtf/unicode/Collator.h:
>+        * wtf/unicode/UTF8.h:
>+        * yarr/Yarr.h:
>+        * yarr/YarrPattern.h:
>+
> 2011-03-25  Oliver Hunt  <oliver@apple.com>
> 
>         Reviewed by Darin Adler.
>Index: Source/JavaScriptCore/wscript
>===================================================================
>--- Source/JavaScriptCore/wscript	(revision 82010)
>+++ Source/JavaScriptCore/wscript	(working copy)
>@@ -47,6 +47,7 @@
> def build(bld):
>     import Options
> 
>+    bld.env.LIBDIR = output_dir
>     full_dirs = get_dirs_for_features(jscore_dir, features=[build_port], dirs=jscore_dirs)
> 
>     includes = common_includes + full_dirs
>@@ -55,9 +56,10 @@
> 
>     # 1. A simple program
>     jscore = bld.new_task_gen(
>-        features = 'cxx cstaticlib',
>+        features = 'cxx cshlib implib',
>         includes = '. .. assembler DerivedSources ForwardingHeaders ' + ' '.join(includes),
>         source = sources,
>+        defines = ['BUILDING_JavaScriptCore'],
>         target = 'jscore',
>         uselib = 'WX ICU ' + get_config(),
>         uselib_local = '',
>Index: Source/JavaScriptCore/parser/SourceProviderCache.h
>===================================================================
>--- Source/JavaScriptCore/parser/SourceProviderCache.h	(revision 82010)
>+++ Source/JavaScriptCore/parser/SourceProviderCache.h	(working copy)
>@@ -33,10 +33,10 @@
> class SourceProviderCache {
> public:
>     SourceProviderCache() : m_contentByteSize(0) {}
>-    ~SourceProviderCache();
>+    JS_EXPORT_PRIVATE ~SourceProviderCache();
> 
>-    void clear();
>-    unsigned byteSize() const;
>+    JS_EXPORT_PRIVATE void clear();
>+    JS_EXPORT_PRIVATE unsigned byteSize() const;
>     void add(int sourcePosition, PassOwnPtr<SourceProviderCacheItem>, unsigned size);
>     const SourceProviderCacheItem* get(int sourcePosition) const { return m_map.get(sourcePosition); }
> 
>Index: Source/JavaScriptCore/profiler/Profiler.h
>===================================================================
>--- Source/JavaScriptCore/profiler/Profiler.h	(revision 82010)
>+++ Source/JavaScriptCore/profiler/Profiler.h	(working copy)
>@@ -53,11 +53,11 @@
>             return &s_sharedEnabledProfilerReference;
>         }
> 
>-        static Profiler* profiler(); 
>+        JS_EXPORT_PRIVATE static Profiler* profiler(); 
>         static CallIdentifier createCallIdentifier(ExecState* exec, JSValue, const UString& sourceURL, int lineNumber);
> 
>-        void startProfiling(ExecState*, const UString& title);
>-        PassRefPtr<Profile> stopProfiling(ExecState*, const UString& title);
>+        JS_EXPORT_PRIVATE void startProfiling(ExecState*, const UString& title);
>+        JS_EXPORT_PRIVATE PassRefPtr<Profile> stopProfiling(ExecState*, const UString& title);
>         void stopProfiling(JSGlobalObject*);
> 
>         void willExecute(ExecState* callerCallFrame, JSValue function);
>Index: Source/JavaScriptCore/debugger/DebuggerCallFrame.h
>===================================================================
>--- Source/JavaScriptCore/debugger/DebuggerCallFrame.h	(revision 82010)
>+++ Source/JavaScriptCore/debugger/DebuggerCallFrame.h	(working copy)
>@@ -51,10 +51,10 @@
>         JSGlobalObject* dynamicGlobalObject() const { return m_callFrame->dynamicGlobalObject(); }
>         ScopeChainNode* scopeChain() const { return m_callFrame->scopeChain(); }
>         const UString* functionName() const;
>-        UString calculatedFunctionName() const;
>-        Type type() const;
>-        JSObject* thisObject() const;
>-        JSValue evaluate(const UString&, JSValue& exception) const;
>+        JS_EXPORT_PRIVATE UString calculatedFunctionName() const;
>+        JS_EXPORT_PRIVATE Type type() const;
>+        JS_EXPORT_PRIVATE JSObject* thisObject() const;
>+        JS_EXPORT_PRIVATE JSValue evaluate(const UString&, JSValue& exception) const;
>         JSValue exception() const { return m_exception; }
> 
>     private:
>Index: Source/JavaScriptCore/debugger/Debugger.h
>===================================================================
>--- Source/JavaScriptCore/debugger/Debugger.h	(revision 82010)
>+++ Source/JavaScriptCore/debugger/Debugger.h	(working copy)
>@@ -34,7 +34,7 @@
>     class SourceProvider;
>     class UString;
> 
>-    class Debugger {
>+    class JS_EXPORT_PRIVATE Debugger {
>     public:
>         virtual ~Debugger();
> 
>Index: Source/JavaScriptCore/collector/handles/HandleHeap.h
>===================================================================
>--- Source/JavaScriptCore/collector/handles/HandleHeap.h	(revision 82010)
>+++ Source/JavaScriptCore/collector/handles/HandleHeap.h	(working copy)
>@@ -62,7 +62,7 @@
>     // Should only be called during teardown.
>     void clearWeakPointers();
> 
>-    void writeBarrier(HandleSlot, const JSValue&);
>+    JS_EXPORT_PRIVATE void writeBarrier(HandleSlot, const JSValue&);
> 
> #if !ASSERT_DISABLED
>     Finalizer* getFinalizer(HandleSlot handle)
>@@ -112,7 +112,7 @@
>     static HandleSlot toHandle(Node*);
>     static Node* toNode(HandleSlot);
> 
>-    void grow();
>+    JS_EXPORT_PRIVATE void grow();
> 
>     JSGlobalData* m_globalData;
>     BlockStack<Node> m_blockStack;
>Index: Source/WebKit/wx/ChangeLog
>===================================================================
>--- Source/WebKit/wx/ChangeLog	(revision 82044)
>+++ Source/WebKit/wx/ChangeLog	(working copy)
>@@ -1,3 +1,13 @@
>+2011-03-26  Kevin Ollivier  <kevino@theolliviers.com>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Add export macros to all exported JSCore methods, and enable them for the wx port.
>+
>+        https://bugs.webkit.org/show_bug.cgi?id=27551
>+
>+        * wscript:
>+
> 2011-03-25  Andy Estes  <aestes@apple.com>
> 
>         Reviewed by Adele Peterson.
>Index: Source/WebKit/wx/wscript
>===================================================================
>--- Source/WebKit/wx/wscript	(revision 82010)
>+++ Source/WebKit/wx/wscript	(working copy)
>@@ -68,7 +68,7 @@
>     
> def pre_build(bld):
>     """
>-    The wxWebKit library should be rebuilt if jscore or webcore changes,
>+    The wxWebKit library should be rebuilt if webcore changes,
>     so we make those static libs as dependencies.
>     """
>     
>@@ -76,13 +76,10 @@
>     if sys.platform.startswith('win'):
>         ext = '.lib'
>     
>-    libjscore = os.path.join(output_dir, 'libjscore%s' % ext)
>     libwebcore = os.path.join(output_dir, 'libwebcore%s' % ext)
>     
>-    assert os.path.exists(libjscore)
>     assert os.path.exists(libwebcore)
>     
>-    bld.env.CXXDEPS_JSCORE = Utils.h_file(libjscore)
>     bld.env.CXXDEPS_WEBCORE = Utils.h_file(libwebcore)
>     
> def build(bld):
>Index: Source/WebCore/config.h
>===================================================================
>--- Source/WebCore/config.h	(revision 82010)
>+++ Source/WebCore/config.h	(working copy)
>@@ -64,8 +64,8 @@
> #else
> #define WEBKIT_EXPORTDATA __declspec(dllimport)
> #endif
>-#define WTF_EXPORT_PRIVATE JS_EXPORTDATA
>-#define JS_EXPORT_PRIVATE JS_EXPORTDATA
>+#define WTF_EXPORT_PRIVATE
>+#define JS_EXPORT_PRIVATE
> #define JS_EXPORTCLASS JS_EXPORTDATA
> #else
> #define JS_EXPORTDATA
>Index: Source/WebCore/ChangeLog
>===================================================================
>--- Source/WebCore/ChangeLog	(revision 82044)
>+++ Source/WebCore/ChangeLog	(working copy)
>@@ -1,3 +1,13 @@
>+2011-03-26  Kevin Ollivier  <kevino@theolliviers.com>
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Add export macros to all exported JSCore methods, and enable them for the wx port.
>+
>+        https://bugs.webkit.org/show_bug.cgi?id=27551
>+
>+        * config.h:
>+
> 2011-03-26  Kwang Yul Seo  <skyul@company100.net>
> 
>         Reviewed by Benjamin Poulain.

Actions: View | Formatted Diff | Diff

Attachments on bug 27551: 33277 | 33357 | 33358 | 33626 | 33627 | 33773 | 34737 | 34831 | 34832 | 58961 | 59038 | 59052 | 59298 | 59596 | 61720 | 65843 | 65865 | 84895 | 84903 | 84910 | 84946 | 84952 | 84962 | 84975 | 84999 | 87006 | 87029 | 87051 | 87077 | 87659 | 88532 | 88543 | 88953 | 88955 | 94823 | 94826 | 94829 | 94832 | 94836 | 96518 | 96523 | 96524 | 96526 | 100313 | 100437 | 100500 | 103555