COMMIT_MESSAGE (1/2)

 1JavaScriptCore:
 2
 32009-07-24 Kenneth Rohde Christiansen <kenneth.christiansen@openbossa.org>, Simon Hausmann <simon.hausmann@nokia.com>
 4
 5 Reviewed by NOBODY (OOPS!).
 6
 7 Make it possible to build JavaScriptCore as shared library without
 8 exported symbol lists.
 9
 10 Added JS_EXPORTDATA to all the classes that are accessed from WebCore,
 11 to ensure their visibility.
 12
 13 * API/OpaqueJSString.h: Use JS_EXPORTDATA.
 14 * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj: Disable
 15 MSVC warning about inconsistent linkage.
 16 * JavaScriptCore.vcproj/jsc/jsc.vcproj: Ditto.
 17 * JavaScriptCore.xcodeproj/project.pbxproj: Include ProfileGenerator.h
 18 in the private headers, as it is included from Profiler.h, which is
 19 also included from WebCore.
 20 * bytecompiler/BytecodeGenerator.h: Use JS_EXPORTDATA.
 21 * config.h: Define JS_EXPORTDATA accordingly with gcc; Define it to
 22 dllimport with MSVC.
 23 * debugger/Debugger.h: Use JS_EXPORTDATA.
 24 * debugger/DebuggerCallFrame.h: Ditto.
 25 * interpreter/Interpreter.h: Ditto.
 26 * jsc.pro: Link against JSC as shared library.
 27 * parser/Nodes.h: Use JS_EXPORTDATA.
 28 * parser/Parser.h: Ditto.
 29 * parser/ParserArena.h: Ditto.
 30 * pcre/pcre.h: Ditto.
 31 * profiler/Profile.h: Use JS_EXPORTDATA.
 32 * profiler/Profiler.h: Use JS_EXPORTDATA and replace ProfileGenerator
 33 forward declaration with inclusion to fix MSVC compilation, which requires
 34 its visiblity when marking Profiler with dllexport.
 35 * runtime/ArgList.h: Use JS_EXPORTDATA.
 36 * runtime/BooleanObject.h: Ditto.
 37 * runtime/CallData.h: Ditto.
 38 * runtime/Collector.h: Ditto.
 39 * runtime/Completion.h: Ditto.
 40 * runtime/ConstructData.h: Ditto.
 41 * runtime/DateInstance.h: Ditto.
 42 * runtime/Error.h: Ditto.
 43 * runtime/FunctionConstructor.h: Ditto.
 44 * runtime/Identifier.h: Ditto.
 45 * runtime/InitializeThreading.h: Ditto.
 46 * runtime/InternalFunction.h: Moved JS_EXPORTDATA from InternalFunction::info to
 47 InternalFunction, to export the entire class.
 48 * runtime/JSArray.h: Use JS_EXPORTDATA.
 49 * runtime/JSByteArray.h: Ditto.
 50 * runtime/JSCell.h: Ditto.
 51 * runtime/JSGlobalData.h: Ditto.
 52 * runtime/JSGlobalObject.h: Ditto.
 53 * runtime/JSImmediate.h: Ditto.
 54 * runtime/JSLock.h: Ditto.
 55 * runtime/JSNumberCell.h: Ditto.
 56 * runtime/JSObject.h: Ditto.
 57 * runtime/JSString.h: Ditto.
 58 * runtime/JSVariableObject.h: Ditto.
 59 * runtime/JSWrapperObject.h: Ditto.
 60 * runtime/Lookup.h: Ditto.
 61 * runtime/NumberObject.h: Ditto.
 62 * runtime/ObjectPrototype.h: Ditto.
 63 * runtime/PropertyNameArray.h: Ditto.
 64 * runtime/PrototypeFunction.h: Ditto.
 65 * runtime/RegExp.h: Ditto.
 66 * runtime/RegExpObject.h: Ditto.
 67 * runtime/SmallStrings.h: Ditto.
 68 * runtime/StringObject.h: Moved JS_EXPORTDATA from StringObject::info to StringObject, to
 69 export the entire class.
 70 * runtime/Structure.h: Use JS_EXPORTDATA.
 71 * runtime/TimeoutChecker.h: Ditto.
 72 * runtime/UString.h: Replaced single export of UString::Rep::{null,empty}BaseString with
 73 export of entire class. Also export a few helper functions.
 74 * wtf/ByteArray.h: Use JS_EXPORTDATA.
 75 * wtf/CurrentTime.h: Ditto.
 76 * wtf/FastMalloc.h: Ditto.
 77 * wtf/MainThread.h: Ditto.
 78 * wtf/RandomNumber.h: Ditto.
 79 * wtf/Threading.h: Ditto.
 80 * wtf/dtoa.h: Ditto.
 81 * wtf/unicode/UTF8.h: Ditto.
 82 * wtf/unicode/UTF8.cpp: Include config.h in order to compile with MSVC.
 83
 84WebCore:
 85
 862009-07-24 Kenneth Rohde Christiansen <kenneth.christiansen@openbossa.org>, Simon Hausmann <simon.hausmann@nokia.com>
 87
 88 Reviewed by NOBODY (OOPS!).
 89
 90 Define JS_EXPORTDATA and WEBKIT_EXPORTDATA for gcc.
 91
 92 Link QTMovieWin against JavaScriptCore for the exported
 93 WTF symbols.
 94
 95 * WebCore.vcproj/QTMovieWin.vcproj: Link QTMovieWin against JSC dll,
 96 for the exported WTF symbols.
 97 * config.h: Tweak for gcc.
 98
 99WebKit/cf:
 100
 1012009-07-24 Simon Hausmann <simon.hausmann@nokia.com>
 102
 103 Reviewed by NOBODY (OOPS!).
 104
 105 Fix compilation on the Mac, don't re-define JS_EXPORTDATA empty but
 106 re-use the definition from WebKitPrefix.h.
 107
 108 * WebCoreSupport/WebInspectorClientCF.cpp:
 109
 110WebKit/mac:
 111
 1122009-07-24 Simon Hausmann <simon.hausmann@nokia.com>
 113
 114 Reviewed by NOBODY (OOPS!).
 115
 116 Duplicate the JS_EXPORTDATA and WEBKIT_EXPORTDATA definition from
 117 WebCore/config.h to fix compilation against JavaScriptCore and
 118 WebCore on the Mac.
 119
 120 * WebKitPrefix.h:
 121
 122WebKit/win:
 123
 1242009-07-24 Simon Hausmann <simon.hausmann@nokia.com>
 125
 126 Reviewed by NOBODY (OOPS!).
 127
 128 Fix compilation, disable bogus DLL linkage warnings and
 129 define JS_EXPORTDATA like in JavaScriptCore/config.h, to
 130 fix symbol import form JavaScriptCore.
 131
 132 * WebKit.vcproj/WebKit.vcproj: Tweak.
 133 * WebKitDLL.h: Define JS_EXPORTDATA.
 134
 135WebKitLibraries:
 136
 1372009-07-30 Simon Hausmann <simon.hausmann@nokia.com>
 138
 139 Reviewed by NOBODY (OOPS!).
 140
 141 Disable MSVC warning 4251 about the need to the types of member variables
 142 that aren't exported yet. We decide to ignore this warning, as fixing it
 143 requires explicitly exporting all template instantiations used in exported
 144 classes' member variables. All of that doesn't seem to be necessary, as
 145 the successful use of .def files with hand-picked symbols prooves.
 146
 147 As a side-note Qt for example has this particular warning globally
 148 disabled (via pragma in qglobal.h) and it's working just fine for
 149 everyone.
 150
 151 * win/tools/vsprops/common.vsprops:
 152
 153WebKitTools:
 154
 1552009-07-28 Simon Hausmann <simon.hausmann@nokia.com>
 156
 157 Reviewed by NOBODY (OOPS!).
 158
 159 Fix compilation on the Mac.
 160
 161 * DumpRenderTree/config.h: Move FastMalloc.h inclusion until after the definition of
 162 JS_EXPORTDATA.
 163 * DumpRenderTree/pthreads/JavaScriptThreadingPthreads.cpp: Include config.h for the
 164 export macros.

JavaScriptCore/API/OpaqueJSString.h

@@namespace JSC {
3333 class JSGlobalData;
3434}
3535
36 struct OpaqueJSString : public ThreadSafeShared<OpaqueJSString> {
 36struct JS_EXPORTDATA OpaqueJSString : public ThreadSafeShared<OpaqueJSString> {
3737
3838 static PassRefPtr<OpaqueJSString> create() // null
3939 {

JavaScriptCore/ChangeLog

 12009-07-24 Kenneth Rohde Christiansen <kenneth.christiansen@openbossa.org>, Simon Hausmann <simon.hausmann@nokia.com>
 2
 3 Reviewed by NOBODY (OOPS!).
 4
 5 Make it possible to build JavaScriptCore as shared library without
 6 exported symbol lists.
 7
 8 Added JS_EXPORTDATA to all the classes that are accessed from WebCore,
 9 to ensure their visibility.
 10
 11 * API/OpaqueJSString.h: Use JS_EXPORTDATA.
 12 * JavaScriptCore.vcproj/JavaScriptCore/JavaScriptCore.vcproj: Disable
 13 MSVC warning about inconsistent linkage.
 14 * JavaScriptCore.vcproj/jsc/jsc.vcproj: Ditto.
 15 * JavaScriptCore.xcodeproj/project.pbxproj: Include ProfileGenerator.h
 16 in the private headers, as it is included from Profiler.h, which is
 17 also included from WebCore.
 18 * bytecompiler/BytecodeGenerator.h: Use JS_EXPORTDATA.
 19 * config.h: Define JS_EXPORTDATA accordingly with gcc; Define it to
 20 dllimport with MSVC.
 21 * debugger/Debugger.h: Use JS_EXPORTDATA.
 22 * debugger/DebuggerCallFrame.h: Ditto.
 23 * interpreter/Interpreter.h: Ditto.
 24 * jsc.pro: Link against JSC as shared library.
 25 * parser/Nodes.h: Use JS_EXPORTDATA.
 26 * parser/Parser.h: Ditto.
 27 * parser/ParserArena.h: Ditto.
 28 * pcre/pcre.h: Ditto.
 29 * profiler/Profile.h: Use JS_EXPORTDATA.
 30 * profiler/Profiler.h: Use JS_EXPORTDATA and replace ProfileGenerator
 31 forward declaration with inclusion to fix MSVC compilation, which requires
 32 its visiblity when marking Profiler with dllexport.
 33 * runtime/ArgList.h: Use JS_EXPORTDATA.
 34 * runtime/BooleanObject.h: Ditto.
 35 * runtime/CallData.h: Ditto.
 36 * runtime/Collector.h: Ditto.
 37 * runtime/Completion.h: Ditto.
 38 * runtime/ConstructData.h: Ditto.
 39 * runtime/DateInstance.h: Ditto.
 40 * runtime/Error.h: Ditto.
 41 * runtime/FunctionConstructor.h: Ditto.
 42 * runtime/Identifier.h: Ditto.
 43 * runtime/InitializeThreading.h: Ditto.
 44 * runtime/InternalFunction.h: Moved JS_EXPORTDATA from InternalFunction::info to
 45 InternalFunction, to export the entire class.
 46 * runtime/JSArray.h: Use JS_EXPORTDATA.
 47 * runtime/JSByteArray.h: Ditto.
 48 * runtime/JSCell.h: Ditto.
 49 * runtime/JSGlobalData.h: Ditto.
 50 * runtime/JSGlobalObject.h: Ditto.
 51 * runtime/JSImmediate.h: Ditto.
 52 * runtime/JSLock.h: Ditto.
 53 * runtime/JSNumberCell.h: Ditto.
 54 * runtime/JSObject.h: Ditto.
 55 * runtime/JSString.h: Ditto.
 56 * runtime/JSVariableObject.h: Ditto.
 57 * runtime/JSWrapperObject.h: Ditto.
 58 * runtime/Lookup.h: Ditto.
 59 * runtime/NumberObject.h: Ditto.
 60 * runtime/ObjectPrototype.h: Ditto.
 61 * runtime/PropertyNameArray.h: Ditto.
 62 * runtime/PrototypeFunction.h: Ditto.
 63 * runtime/RegExp.h: Ditto.
 64 * runtime/RegExpObject.h: Ditto.
 65 * runtime/SmallStrings.h: Ditto.
 66 * runtime/StringObject.h: Moved JS_EXPORTDATA from StringObject::info to StringObject, to
 67 export the entire class.
 68 * runtime/Structure.h: Use JS_EXPORTDATA.
 69 * runtime/TimeoutChecker.h: Ditto.
 70 * runtime/UString.h: Replaced single export of UString::Rep::{null,empty}BaseString with
 71 export of entire class. Also export a few helper functions.
 72 * wtf/ByteArray.h: Use JS_EXPORTDATA.
 73 * wtf/CurrentTime.h: Ditto.
 74 * wtf/FastMalloc.h: Ditto.
 75 * wtf/MainThread.h: Ditto.
 76 * wtf/RandomNumber.h: Ditto.
 77 * wtf/Threading.h: Ditto.
 78 * wtf/dtoa.h: Ditto.
 79 * wtf/unicode/UTF8.h: Ditto.
 80 * wtf/unicode/UTF8.cpp: Include config.h in order to compile with MSVC.
 81
1822009-07-29 Laszlo Gombos <laszlo.1.gombos@nokia.com>
283
384 Reviewed by George Staikos.

JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj

173173 95AB83420DA4322500BC83F3 /* Profiler.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 95AB832E0DA42CAD00BC83F3 /* Profiler.cpp */; };
174174 95AB83560DA43C3000BC83F3 /* ProfileNode.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 95AB83540DA43B4400BC83F3 /* ProfileNode.cpp */; };
175175 95CD45760E1C4FDD0085358E /* ProfileGenerator.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 95CD45740E1C4FDD0085358E /* ProfileGenerator.cpp */; };
176  95CD45770E1C4FDD0085358E /* ProfileGenerator.h in Headers */ = {isa = PBXBuildFile; fileRef = 95CD45750E1C4FDD0085358E /* ProfileGenerator.h */; settings = {ATTRIBUTES = (); }; };
 176 95CD45770E1C4FDD0085358E /* ProfileGenerator.h in Headers */ = {isa = PBXBuildFile; fileRef = 95CD45750E1C4FDD0085358E /* ProfileGenerator.h */; settings = {ATTRIBUTES = (Private, ); }; };
177177 95E3BC050E1AE68200B2D1C1 /* CallIdentifier.h in Headers */ = {isa = PBXBuildFile; fileRef = 95E3BC040E1AE68200B2D1C1 /* CallIdentifier.h */; settings = {ATTRIBUTES = (Private, ); }; };
178178 95F6E6950E5B5F970091E860 /* JSProfilerPrivate.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 95988BA90E477BEC00D28D4D /* JSProfilerPrivate.cpp */; };
179179 960097A60EBABB58007A7297 /* LabelScope.h in Headers */ = {isa = PBXBuildFile; fileRef = 960097A50EBABB58007A7297 /* LabelScope.h */; };

JavaScriptCore/bytecompiler/BytecodeGenerator.h

@@namespace JSC {
6161 FinallyContext finallyContext;
6262 };
6363
64  class BytecodeGenerator : public WTF::FastAllocBase {
 64 class JS_EXPORTDATA BytecodeGenerator : public WTF::FastAllocBase {
6565 public:
6666 typedef DeclarationStacks::VarStack VarStack;
6767 typedef DeclarationStacks::FunctionStack FunctionStack;

JavaScriptCore/config.h

2525
2626#include <wtf/Platform.h>
2727
28 #if PLATFORM(WIN_OS) && !defined(BUILDING_WX__) && !COMPILER(GCC)
29 #if defined(BUILDING_JavaScriptCore) || defined(BUILDING_WTF)
30 #define JS_EXPORTDATA __declspec(dllexport)
 28#undef JS_EXPORTDATA
 29#if COMPILER(GCC)
 30 #define JS_EXPORTDATA __attribute__((visibility("default")))
 31#elif PLATFORM(WIN_OS) && !defined(BUILDING_WX__)
 32 #if defined(BUILDING_JavaScriptCore) || defined(BUILDING_WTF)
 33 #define JS_EXPORTDATA __declspec(dllexport)
 34 #else
 35 #define JS_EXPORTDATA __declspec(dllimport)
 36 #endif
3137#else
32 #define JS_EXPORTDATA __declspec(dllimport)
33 #endif
34 #else
35 #define JS_EXPORTDATA
 38 #define JS_EXPORTDATA
3639#endif
3740
3841#if PLATFORM(WIN_OS)

JavaScriptCore/debugger/Debugger.h

@@namespace JSC {
3232 class SourceCode;
3333 class UString;
3434
35  class Debugger {
 35 class JS_EXPORTDATA Debugger {
3636 public:
3737 Debugger();
3838 virtual ~Debugger();

JavaScriptCore/debugger/DebuggerCallFrame.h

2525 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2727 */
28 
 28
2929#ifndef DebuggerCallFrame_h
3030#define DebuggerCallFrame_h
3131
3232#include "CallFrame.h"
3333
3434namespace JSC {
35 
36  class DebuggerCallFrame {
 35
 36 class JS_EXPORTDATA DebuggerCallFrame {
3737 public:
3838 enum Type { ProgramType, FunctionType };
3939

JavaScriptCore/interpreter/Interpreter.h

@@namespace JSC {
6666
6767 enum { MaxMainThreadReentryDepth = 256, MaxSecondaryThreadReentryDepth = 32 };
6868
69  class Interpreter : public FastAllocBase {
 69 class JS_EXPORTDATA Interpreter : public FastAllocBase {
7070 friend class JIT;
7171 friend class CachedCall;
7272 public:

JavaScriptCore/parser/Nodes.h

@@namespace JSC {
159159 int m_line;
160160 };
161161
162  class ExpressionNode : public Node {
 162 class JS_EXPORTDATA ExpressionNode : public Node {
163163 public:
164164 ExpressionNode(JSGlobalData*, ResultType = ResultType::unknownType());
165165

@@namespace JSC {
187187 ResultType m_resultType;
188188 };
189189
190  class StatementNode : public Node {
 190 class JS_EXPORTDATA StatementNode : public Node {
191191 public:
192192 StatementNode(JSGlobalData*);
193193

@@namespace JSC {
15391539 OwnPtr<EvalCodeBlock> m_code;
15401540 };
15411541
1542  class FunctionBodyNode : public ScopeNode {
 1542 class JS_EXPORTDATA FunctionBodyNode : public ScopeNode {
15431543 friend class JIT;
15441544 public:
15451545#if ENABLE(JIT)

JavaScriptCore/parser/Parser.h

@@namespace JSC {
3939
4040 template <typename T> struct ParserArenaData : ParserArenaDeletable { T data; };
4141
42  class Parser : public Noncopyable {
 42 class JS_EXPORTDATA Parser : public Noncopyable {
4343 public:
4444 template <class ParsedNode> PassRefPtr<ParsedNode> parse(ExecState*, Debugger*, const SourceCode&, int* errLine = 0, UString* errMsg = 0);
4545 template <class ParsedNode> PassRefPtr<ParsedNode> reparse(JSGlobalData*, ParsedNode*);

JavaScriptCore/parser/ParserArena.h

@@namespace JSC {
3535 class ParserArenaDeletable;
3636 class ParserArenaRefCounted;
3737
38  class ParserArena {
 38 class JS_EXPORTDATA ParserArena {
3939 public:
4040 void swap(ParserArena& otherArena)
4141 {

JavaScriptCore/pcre/pcre.h

@@const int JSRegExpErrorHitLimit = -2;
5555const int JSRegExpErrorNoMemory = -3;
5656const int JSRegExpErrorInternal = -4;
5757
58 JSRegExp* jsRegExpCompile(const UChar* pattern, int patternLength,
 58JS_EXPORTDATA JSRegExp* jsRegExpCompile(const UChar* pattern, int patternLength,
5959 JSRegExpIgnoreCaseOption, JSRegExpMultilineOption,
6060 unsigned* numSubpatterns, const char** errorMessage);
6161
62 int jsRegExpExecute(const JSRegExp*,
 62JS_EXPORTDATA int jsRegExpExecute(const JSRegExp*,
6363 const UChar* subject, int subjectLength, int startOffset,
6464 int* offsetsVector, int offsetsVectorLength);
6565
66 void jsRegExpFree(JSRegExp*);
 66JS_EXPORTDATA void jsRegExpFree(JSRegExp*);
6767
6868#endif

JavaScriptCore/profiler/Profile.h

3333
3434namespace JSC {
3535
36  class Profile : public RefCounted<Profile> {
 36 class JS_EXPORTDATA Profile : public RefCounted<Profile> {
3737 public:
3838 static PassRefPtr<Profile> create(const UString& title, unsigned uid);
3939 virtual ~Profile();

JavaScriptCore/profiler/Profiler.h

3030#define Profiler_h
3131
3232#include "Profile.h"
 33#include "ProfileGenerator.h"
3334#include <wtf/PassRefPtr.h>
3435#include <wtf/RefPtr.h>
3536#include <wtf/Vector.h>

@@namespace JSC {
4041 class JSGlobalData;
4142 class JSObject;
4243 class JSValue;
43  class ProfileGenerator;
4444 class UString;
4545 struct CallIdentifier;
4646
47  class Profiler : public FastAllocBase {
 47 class JS_EXPORTDATA Profiler : public FastAllocBase {
4848 public:
4949 static Profiler** enabledProfilerReference()
5050 {
5151 return &s_sharedEnabledProfilerReference;
5252 }
5353
54  static Profiler* profiler();
 54 static Profiler* profiler();
5555 static CallIdentifier createCallIdentifier(JSGlobalData*, JSValue, const UString& sourceURL, int lineNumber);
5656
5757 void startProfiling(ExecState*, const UString& title);

JavaScriptCore/runtime/ArgList.h

3131
3232namespace JSC {
3333
34  class MarkedArgumentBuffer : public Noncopyable {
 34 class JS_EXPORTDATA MarkedArgumentBuffer : public Noncopyable {
3535 private:
3636 static const unsigned inlineCapacity = 8;
3737 typedef Vector<Register, inlineCapacity> VectorType;

@@namespace JSC {
171171 void operator delete(void*, size_t);
172172 };
173173
174  class ArgList {
 174 class JS_EXPORTDATA ArgList {
175175 friend class JIT;
176176 public:
177177 typedef JSValue* iterator;

JavaScriptCore/runtime/BooleanObject.h

2525
2626namespace JSC {
2727
28  class BooleanObject : public JSWrapperObject {
 28 class JS_EXPORTDATA BooleanObject : public JSWrapperObject {
2929 public:
3030 explicit BooleanObject(PassRefPtr<Structure>);
3131

JavaScriptCore/runtime/CallData.h

@@namespace JSC {
4848
4949 typedef JSValue (JSC_HOST_CALL *NativeFunction)(ExecState*, JSObject*, JSValue thisValue, const ArgList&);
5050
51  union CallData {
 51 union JS_EXPORTDATA CallData {
5252 struct {
5353 NativeFunction function;
5454 } native;

@@namespace JSC {
5858 } js;
5959 };
6060
61  JSValue call(ExecState*, JSValue functionObject, CallType, const CallData&, JSValue thisValue, const ArgList&);
 61 JS_EXPORTDATA JSValue call(ExecState*, JSValue functionObject, CallType, const CallData&, JSValue thisValue, const ArgList&);
6262
6363} // namespace JSC
6464

JavaScriptCore/runtime/Collector.h

@@namespace JSC {
6363 OperationInProgress operationInProgress;
6464 };
6565
66  class Heap : public Noncopyable {
 66 class JS_EXPORTDATA Heap : public Noncopyable {
6767 public:
6868 class Thread;
6969 typedef CollectorHeapIterator<PrimaryHeap> iterator;

JavaScriptCore/runtime/Completion.h

@@namespace JSC {
3737 * Completion objects are used to convey the return status and value
3838 * from functions.
3939 */
40  class Completion {
 40 class JS_EXPORTDATA Completion {
4141 public:
4242 Completion(ComplType type = Normal, JSValue value = JSValue())
4343 : m_type(type)

@@namespace JSC {
5555 JSValue m_value;
5656 };
5757
58  Completion checkSyntax(ExecState*, const SourceCode&);
59  Completion evaluate(ExecState*, ScopeChain&, const SourceCode&, JSValue thisValue = JSValue());
 58 JS_EXPORTDATA Completion checkSyntax(ExecState*, const SourceCode&);
 59 JS_EXPORTDATA Completion evaluate(ExecState*, ScopeChain&, const SourceCode&, JSValue thisValue = JSValue());
6060
6161} // namespace JSC
6262

JavaScriptCore/runtime/ConstructData.h

@@namespace JSC {
4646
4747 typedef JSObject* (*NativeConstructor)(ExecState*, JSObject*, const ArgList&);
4848
49  union ConstructData {
 49 union JS_EXPORTDATA ConstructData {
5050 struct {
5151 NativeConstructor function;
5252 } native;

@@namespace JSC {
5656 } js;
5757 };
5858
59  JSObject* construct(ExecState*, JSValue constructor, ConstructType, const ConstructData&, const ArgList&);
 59 JS_EXPORTDATA JSObject* construct(ExecState*, JSValue constructor, ConstructType, const ConstructData&, const ArgList&);
6060
6161} // namespace JSC
6262

JavaScriptCore/runtime/DateInstance.h

@@namespace WTF {
2929
3030namespace JSC {
3131
32  class DateInstance : public JSWrapperObject {
 32 class JS_EXPORTDATA DateInstance : public JSWrapperObject {
3333 public:
3434 explicit DateInstance(PassRefPtr<Structure>);
3535 virtual ~DateInstance();

JavaScriptCore/runtime/Error.h

@@namespace JSC {
5555 static JSObject* create(ExecState*, ErrorType, const char* message);
5656 };
5757
58  JSObject* throwError(ExecState*, ErrorType, const UString& message, int lineNumber, intptr_t sourceID, const UString& sourceURL);
59  JSObject* throwError(ExecState*, ErrorType, const UString& message);
60  JSObject* throwError(ExecState*, ErrorType, const char* message);
61  JSObject* throwError(ExecState*, ErrorType);
 58 JS_EXPORTDATA JSObject* throwError(ExecState*, ErrorType, const UString& message, int lineNumber, intptr_t sourceID, const UString& sourceURL);
 59 JS_EXPORTDATA JSObject* throwError(ExecState*, ErrorType, const UString& message);
 60 JS_EXPORTDATA JSObject* throwError(ExecState*, ErrorType, const char* message);
 61 JS_EXPORTDATA JSObject* throwError(ExecState*, ErrorType);
6262
6363} // namespace JSC
6464

JavaScriptCore/runtime/FunctionConstructor.h

@@namespace JSC {
2929 class ProgramNode;
3030 class FunctionBodyNode;
3131
32  class FunctionConstructor : public InternalFunction {
 32 class JS_EXPORTDATA FunctionConstructor : public InternalFunction {
3333 public:
3434 FunctionConstructor(ExecState*, PassRefPtr<Structure>, FunctionPrototype*);
3535

@@namespace JSC {
3838 virtual CallType getCallData(CallData&);
3939 };
4040
41  JSObject* constructFunction(ExecState*, const ArgList&, const Identifier& functionName, const UString& sourceURL, int lineNumber);
42  JSObject* constructFunction(ExecState*, const ArgList&);
 41 JS_EXPORTDATA JSObject* constructFunction(ExecState*, const ArgList&, const Identifier& functionName, const UString& sourceURL, int lineNumber);
 42 JS_EXPORTDATA JSObject* constructFunction(ExecState*, const ArgList&);
4343
44  FunctionBodyNode* extractFunctionBody(ProgramNode*);
 44 JS_EXPORTDATA FunctionBodyNode* extractFunctionBody(ProgramNode*);
4545
4646} // namespace JSC
4747

JavaScriptCore/runtime/Identifier.h

@@namespace JSC {
2828
2929 class ExecState;
3030
31  class Identifier {
 31 class JS_EXPORTDATA Identifier {
3232 friend class Structure;
3333 public:
3434 Identifier() { }

JavaScriptCore/runtime/InitializeThreading.h

2525 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
2626 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2727 */
28 
 28
2929#ifndef InitializeThreading_h
3030#define InitializeThreading_h
3131

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

JavaScriptCore/runtime/InternalFunction.h

@@namespace JSC {
3131
3232 class FunctionPrototype;
3333
34  class InternalFunction : public JSObject {
 34 class JS_EXPORTDATA InternalFunction : public JSObject {
3535 public:
3636 virtual const ClassInfo* classInfo() const;
37  static JS_EXPORTDATA const ClassInfo info;
 37 static const ClassInfo info;
3838
3939 const UString& name(JSGlobalData*);
4040 const UString displayName(JSGlobalData*);

JavaScriptCore/runtime/JSArray.h

@@namespace JSC {
112112
113113 JSArray* asArray(JSValue);
114114
115  JSArray* constructEmptyArray(ExecState*);
116  JSArray* constructEmptyArray(ExecState*, unsigned initialLength);
117  JSArray* constructArray(ExecState*, JSValue singleItemValue);
118  JSArray* constructArray(ExecState*, const ArgList& values);
 115 JS_EXPORTDATA JSArray* constructEmptyArray(ExecState*);
 116 JS_EXPORTDATA JSArray* constructEmptyArray(ExecState*, unsigned initialLength);
 117 JS_EXPORTDATA JSArray* constructArray(ExecState*, JSValue singleItemValue);
 118 JS_EXPORTDATA JSArray* constructArray(ExecState*, const ArgList& values);
119119
120120 inline JSArray* asArray(JSValue value)
121121 {

JavaScriptCore/runtime/JSByteArray.h

3232
3333namespace JSC {
3434
35  class JSByteArray : public JSObject {
 35 class JS_EXPORTDATA JSByteArray : public JSObject {
3636 friend struct VPtrSet;
3737 public:
3838 bool canAccessIndex(unsigned i) { return i < m_storage->length(); }

JavaScriptCore/runtime/JSCell.h

3131
3232namespace JSC {
3333
34  class JSCell : public NoncopyableCustomAllocated {
 34 class JS_EXPORTDATA JSCell : public NoncopyableCustomAllocated {
3535 friend class GetterSetter;
3636 friend class Heap;
3737 friend class JIT;

JavaScriptCore/runtime/JSGlobalData.h

@@namespace JSC {
6161 struct Instruction;
6262 struct VPtrSet;
6363
64  class JSGlobalData : public RefCounted<JSGlobalData> {
 64 class JS_EXPORTDATA JSGlobalData : public RefCounted<JSGlobalData> {
6565 public:
6666 struct ClientData {
6767 virtual ~ClientData() = 0;

JavaScriptCore/runtime/JSGlobalObject.h

@@namespace JSC {
5151
5252 typedef Vector<ExecState*, 16> ExecStateStack;
5353
54  class JSGlobalObject : public JSVariableObject {
 54 class JS_EXPORTDATA JSGlobalObject : public JSVariableObject {
5555 protected:
5656 using JSVariableObject::JSVariableObjectData;
5757

JavaScriptCore/runtime/JSImmediate.h

@@namespace JSC {
129129 * values are encoded in the same manner as the default format.
130130 */
131131
132  class JSImmediate {
 132 class JS_EXPORTDATA JSImmediate {
133133 private:
134134 friend class JIT;
135135 friend class JSValue;

@@namespace JSC {
542542 }
543543
544544 // These are identical logic to the JSValue functions above, and faster than jsNumber(number).toInt32().
545  int32_t toInt32(double);
546  uint32_t toUInt32(double);
547  int32_t toInt32SlowCase(double, bool& ok);
548  uint32_t toUInt32SlowCase(double, bool& ok);
 545 JS_EXPORTDATA int32_t toInt32(double);
 546 JS_EXPORTDATA uint32_t toUInt32(double);
 547 JS_EXPORTDATA int32_t toInt32SlowCase(double, bool& ok);
 548 JS_EXPORTDATA uint32_t toUInt32SlowCase(double, bool& ok);
549549
550550 inline JSValue::JSValue(JSNullTag)
551551 {

JavaScriptCore/runtime/JSLock.h

@@namespace JSC {
5252
5353 enum JSLockBehavior { SilenceAssertionsOnly, LockForReal };
5454
55  class JSLock : public Noncopyable {
 55 class JS_EXPORTDATA JSLock : public Noncopyable {
5656 public:
5757 JSLock(ExecState*);
5858

JavaScriptCore/runtime/JSNumberCell.h

3232
3333namespace JSC {
3434
35  extern const double NaN;
36  extern const double Inf;
 35 JS_EXPORTDATA extern const double NaN;
 36 JS_EXPORTDATA extern const double Inf;
3737
38  JSValue jsNumberCell(ExecState*, double);
39  JSValue jsAPIMangledNumber(ExecState*, double);
 38 JS_EXPORTDATA JSValue jsNumberCell(ExecState*, double);
 39 JS_EXPORTDATA JSValue jsAPIMangledNumber(ExecState*, double);
4040
4141#if !USE(ALTERNATE_JSIMMEDIATE)
4242

@@namespace JSC {
4949 struct ClassInfo;
5050 struct Instruction;
5151
52  class JSNumberCell : public JSCell {
 52 class JS_EXPORTDATA JSNumberCell : public JSCell {
5353 friend class JIT;
5454 friend JSValue jsNumberCell(JSGlobalData*, double);
55  friend JSValue jsNumberCell(ExecState*, double);
56  friend JSValue jsAPIMangledNumber(ExecState*, double);
 55 friend JS_EXPORTDATA JSValue jsNumberCell(ExecState*, double);
 56 friend JS_EXPORTDATA JSValue jsAPIMangledNumber(ExecState*, double);
5757 public:
5858 double value() const { return m_value; }
5959

JavaScriptCore/runtime/JSObject.h

@@namespace JSC {
6464 typedef EncodedJSValue* PropertyStorage;
6565 typedef const EncodedJSValue* ConstPropertyStorage;
6666
67  class JSObject : public JSCell {
 67 class JS_EXPORTDATA JSObject : public JSCell {
6868 friend class BatchedTransitionOptimizer;
6969 friend class JIT;
7070 friend class JSCell;

@@namespace JSC {
234234 };
235235 };
236236
237  JSObject* asObject(JSValue);
 237 JS_EXPORTDATA JSObject* asObject(JSValue);
238238
239  JSObject* constructEmptyObject(ExecState*);
 239 JS_EXPORTDATA JSObject* constructEmptyObject(ExecState*);
240240
241241inline JSObject* asObject(JSValue value)
242242{

JavaScriptCore/runtime/JSString.h

@@namespace JSC {
3333
3434 class JSString;
3535
36  JSString* jsEmptyString(JSGlobalData*);
37  JSString* jsEmptyString(ExecState*);
38  JSString* jsString(JSGlobalData*, const UString&); // returns empty string if passed null string
39  JSString* jsString(ExecState*, const UString&); // returns empty string if passed null string
40 
41  JSString* jsSingleCharacterString(JSGlobalData*, UChar);
42  JSString* jsSingleCharacterString(ExecState*, UChar);
43  JSString* jsSingleCharacterSubstring(JSGlobalData*, const UString&, unsigned offset);
44  JSString* jsSingleCharacterSubstring(ExecState*, const UString&, unsigned offset);
45  JSString* jsSubstring(JSGlobalData*, const UString&, unsigned offset, unsigned length);
46  JSString* jsSubstring(ExecState*, const UString&, unsigned offset, unsigned length);
 36 JS_EXPORTDATA JSString* jsEmptyString(JSGlobalData*);
 37 JS_EXPORTDATA JSString* jsEmptyString(ExecState*);
 38 JS_EXPORTDATA JSString* jsString(JSGlobalData*, const UString&); // returns empty string if passed null string
 39 JS_EXPORTDATA JSString* jsString(ExecState*, const UString&); // returns empty string if passed null string
 40
 41 JS_EXPORTDATA JSString* jsSingleCharacterString(JSGlobalData*, UChar);
 42 JS_EXPORTDATA JSString* jsSingleCharacterString(ExecState*, UChar);
 43 JS_EXPORTDATA JSString* jsSingleCharacterSubstring(JSGlobalData*, const UString&, unsigned offset);
 44 JS_EXPORTDATA JSString* jsSingleCharacterSubstring(ExecState*, const UString&, unsigned offset);
 45 JS_EXPORTDATA JSString* jsSubstring(JSGlobalData*, const UString&, unsigned offset, unsigned length);
 46 JS_EXPORTDATA JSString* jsSubstring(ExecState*, const UString&, unsigned offset, unsigned length);
4747
4848 // Non-trivial strings are two or more characters long.
4949 // These functions are faster than just calling jsString.
50  JSString* jsNontrivialString(JSGlobalData*, const UString&);
51  JSString* jsNontrivialString(ExecState*, const UString&);
52  JSString* jsNontrivialString(JSGlobalData*, const char*);
53  JSString* jsNontrivialString(ExecState*, const char*);
 50 JS_EXPORTDATA JSString* jsNontrivialString(JSGlobalData*, const UString&);
 51 JS_EXPORTDATA JSString* jsNontrivialString(ExecState*, const UString&);
 52 JS_EXPORTDATA JSString* jsNontrivialString(JSGlobalData*, const char*);
 53 JS_EXPORTDATA JSString* jsNontrivialString(ExecState*, const char*);
5454
5555 // Should be used for strings that are owned by an object that will
5656 // likely outlive the JSValue this makes, such as the parse tree or a
5757 // DOM object that contains a UString
58  JSString* jsOwnedString(JSGlobalData*, const UString&);
59  JSString* jsOwnedString(ExecState*, const UString&);
 58 JS_EXPORTDATA JSString* jsOwnedString(JSGlobalData*, const UString&);
 59 JS_EXPORTDATA JSString* jsOwnedString(ExecState*, const UString&);
6060
61  class JSString : public JSCell {
 61 class JS_EXPORTDATA JSString : public JSCell {
6262 friend class JIT;
6363 friend struct VPtrSet;
6464

JavaScriptCore/runtime/JSVariableObject.h

@@namespace JSC {
4040
4141 class Register;
4242
43  class JSVariableObject : public JSObject {
 43 class JS_EXPORTDATA JSVariableObject : public JSObject {
4444 friend class JIT;
4545
4646 public:

@@namespace JSC {
5050
5151 virtual bool deleteProperty(ExecState*, const Identifier&);
5252 virtual void getPropertyNames(ExecState*, PropertyNameArray&);
53 
 53
5454 virtual bool isVariableObject() const;
5555 virtual bool isDynamicScope() const = 0;
5656

JavaScriptCore/runtime/JSWrapperObject.h

2525#include "JSObject.h"
2626
2727namespace JSC {
28 
 28
2929 // This class is used as a base for classes such as String,
3030 // Number, Boolean and Date which are wrappers for primitive types.
31  class JSWrapperObject : public JSObject {
 31 class JS_EXPORTDATA JSWrapperObject : public JSObject {
3232 protected:
3333 explicit JSWrapperObject(PassRefPtr<Structure>);
3434

JavaScriptCore/runtime/Lookup.h

@@namespace JSC {
104104 HashEntry* m_next;
105105 };
106106
107  struct HashTable {
 107 struct JS_EXPORTDATA HashTable {
108108
109109 int compactSize;
110110 int compactHashSizeMask;

@@namespace JSC {
162162 void createTable(JSGlobalData*) const;
163163 };
164164
165  void setUpStaticFunctionSlot(ExecState*, const HashEntry*, JSObject* thisObject, const Identifier& propertyName, PropertySlot&);
 165 JS_EXPORTDATA void setUpStaticFunctionSlot(ExecState*, const HashEntry*, JSObject* thisObject, const Identifier& propertyName, PropertySlot&);
166166
167167 /**
168168 * This method does it all (looking in the hashtable, checking for function

JavaScriptCore/runtime/NumberObject.h

2525
2626namespace JSC {
2727
28  class NumberObject : public JSWrapperObject {
 28 class JS_EXPORTDATA NumberObject : public JSWrapperObject {
2929 public:
3030 explicit NumberObject(PassRefPtr<Structure>);
3131

JavaScriptCore/runtime/ObjectPrototype.h

@@namespace JSC {
3030 ObjectPrototype(ExecState*, PassRefPtr<Structure>, Structure* prototypeFunctionStructure);
3131 };
3232
33  JSValue JSC_HOST_CALL objectProtoFuncToString(ExecState*, JSObject*, JSValue, const ArgList&);
 33 JS_EXPORTDATA JSValue JSC_HOST_CALL objectProtoFuncToString(ExecState*, JSObject*, JSValue, const ArgList&);
3434
3535} // namespace JSC
3636

JavaScriptCore/runtime/PropertyNameArray.h

@@namespace JSC {
5858 RefPtr<StructureChain> m_cachedPrototypeChain;
5959 };
6060
61  class PropertyNameArray {
 61 class JS_EXPORTDATA PropertyNameArray {
6262 public:
6363 typedef PropertyNameArrayData::const_iterator const_iterator;
6464

JavaScriptCore/runtime/PrototypeFunction.h

2929
3030namespace JSC {
3131
32  class PrototypeFunction : public InternalFunction {
 32 class JS_EXPORTDATA PrototypeFunction : public InternalFunction {
3333 public:
3434 PrototypeFunction(ExecState*, int length, const Identifier&, NativeFunction);
3535 PrototypeFunction(ExecState*, PassRefPtr<Structure>, int length, const Identifier&, NativeFunction);

JavaScriptCore/runtime/RegExp.h

@@namespace JSC {
3636
3737 class JSGlobalData;
3838
39  class RegExp : public RefCounted<RegExp> {
 39 class JS_EXPORTDATA RegExp : public RefCounted<RegExp> {
4040 public:
4141 static PassRefPtr<RegExp> create(JSGlobalData* globalData, const UString& pattern);
4242 static PassRefPtr<RegExp> create(JSGlobalData* globalData, const UString& pattern, const UString& flags);

JavaScriptCore/runtime/RegExpObject.h

2626
2727namespace JSC {
2828
29  class RegExpObject : public JSObject {
 29 class JS_EXPORTDATA RegExpObject : public JSObject {
3030 public:
3131 RegExpObject(PassRefPtr<Structure>, PassRefPtr<RegExp>);
3232 virtual ~RegExpObject();

JavaScriptCore/runtime/SmallStrings.h

@@namespace JSC {
3636
3737 class SmallStringsStorage;
3838
39  class SmallStrings : public Noncopyable {
 39 class JS_EXPORTDATA SmallStrings : public Noncopyable {
4040 public:
4141 SmallStrings();
4242 ~SmallStrings();

JavaScriptCore/runtime/StringObject.h

2626
2727namespace JSC {
2828
29  class StringObject : public JSWrapperObject {
 29 class JS_EXPORTDATA StringObject : public JSWrapperObject {
3030 public:
3131 StringObject(ExecState*, PassRefPtr<Structure>);
3232 StringObject(ExecState*, PassRefPtr<Structure>, const UString&);

@@namespace JSC {
4141 virtual void getPropertyNames(ExecState*, PropertyNameArray&);
4242
4343 virtual const ClassInfo* classInfo() const { return &info; }
44  static const JS_EXPORTDATA ClassInfo info;
 44 static const ClassInfo info;
4545
4646 JSString* internalValue() const { return asString(JSWrapperObject::internalValue());}
4747

JavaScriptCore/runtime/Structure.h

@@namespace JSC {
4848 class PropertyNameArray;
4949 class PropertyNameArrayData;
5050
51  class Structure : public RefCounted<Structure> {
 51 class JS_EXPORTDATA Structure : public RefCounted<Structure> {
5252 public:
5353 friend class JIT;
5454 static PassRefPtr<Structure> create(JSValue prototype, const TypeInfo& typeInfo)

JavaScriptCore/runtime/TimeoutChecker.h

@@namespace JSC {
3535
3636 class ExecState;
3737
38  class TimeoutChecker {
 38 class JS_EXPORTDATA TimeoutChecker {
3939 public:
4040 TimeoutChecker();
4141

JavaScriptCore/runtime/UString.h

@@namespace JSC {
4141 using WTF::PlacementNewAdopt;
4242
4343 class IdentifierTable;
44 
45  class CString {
 44
 45 class JS_EXPORTDATA CString {
4646 public:
4747 CString()
4848 : m_length(0)

@@namespace JSC {
7373
7474 typedef Vector<char, 32> CStringBuffer;
7575
76  class UString {
 76 class JS_EXPORTDATA UString {
7777 friend class JIT;
7878
7979 public:
8080 typedef CrossThreadRefCounted<OwnFastMallocPtr<UChar> > SharedUChar;
8181 struct BaseString;
82  struct Rep : Noncopyable {
 82 struct JS_EXPORTDATA Rep : Noncopyable {
8383 friend class JIT;
8484
8585 static PassRefPtr<Rep> create(UChar* buffer, int length)

@@namespace JSC {
185185
186186 friend class SmallStringsStorage;
187187 friend void initializeUString();
188  JS_EXPORTDATA static BaseString* nullBaseString;
189  JS_EXPORTDATA static BaseString* emptyBaseString;
 188 static BaseString* nullBaseString;
 189 static BaseString* emptyBaseString;
190190 };
191191
192192

@@namespace JSC {
431431 return UString(result ? result.release() : UString::nullRep());
432432 }
433433
434  int compare(const UString&, const UString&);
 434 JS_EXPORTDATA int compare(const UString&, const UString&);
435435
436  bool equal(const UString::Rep*, const UString::Rep*);
 436 JS_EXPORTDATA bool equal(const UString::Rep*, const UString::Rep*);
437437
438438 inline PassRefPtr<UString::Rep> UString::Rep::create(PassRefPtr<UString::Rep> rep, int offset, int length)
439439 {

JavaScriptCore/wtf/ByteArray.h

3030#include <wtf/RefCounted.h>
3131
3232namespace WTF {
33  class ByteArray : public RefCountedBase {
 33 class JS_EXPORTDATA ByteArray : public RefCountedBase {
3434 public:
3535 unsigned length() const { return m_size; }
3636

JavaScriptCore/wtf/CurrentTime.h

3535namespace WTF {
3636
3737 // Returns the current system (UTC) time in seconds, starting January 1, 1970.
38  // Precision varies depending on a platform but usually is as good or better
 38 // Precision varies depending on a platform but usually is as good or better
3939 // than a millisecond.
40  double currentTime();
 40 JS_EXPORTDATA double currentTime();
4141
4242} // namespace WTF
4343
4444using WTF::currentTime;
4545
4646#endif // CurrentTime_h
47 

JavaScriptCore/wtf/FastMalloc.h

2828namespace WTF {
2929
3030 // These functions call CRASH() if an allocation fails.
31  void* fastMalloc(size_t n);
32  void* fastZeroedMalloc(size_t n);
33  void* fastCalloc(size_t n_elements, size_t element_size);
34  void* fastRealloc(void* p, size_t n);
 31 JS_EXPORTDATA void* fastMalloc(size_t n);
 32 JS_EXPORTDATA void* fastZeroedMalloc(size_t n);
 33 JS_EXPORTDATA void* fastCalloc(size_t n_elements, size_t element_size);
 34 JS_EXPORTDATA void* fastRealloc(void* p, size_t n);
3535
3636 // These functions return NULL if an allocation fails.
37  void* tryFastMalloc(size_t n);
38  void* tryFastZeroedMalloc(size_t n);
39  void* tryFastCalloc(size_t n_elements, size_t element_size);
40  void* tryFastRealloc(void* p, size_t n);
 37 JS_EXPORTDATA void* tryFastMalloc(size_t n);
 38 JS_EXPORTDATA void* tryFastZeroedMalloc(size_t n);
 39 JS_EXPORTDATA void* tryFastCalloc(size_t n_elements, size_t element_size);
 40 JS_EXPORTDATA void* tryFastRealloc(void* p, size_t n);
4141
42  void fastFree(void* p);
 42 JS_EXPORTDATA void fastFree(void* p);
4343
4444#ifndef NDEBUG
4545 void fastMallocForbid();

JavaScriptCore/wtf/MainThread.h

@@class Mutex;
3636
3737typedef void MainThreadFunction(void*);
3838
39 void callOnMainThread(MainThreadFunction*, void* context);
 39JS_EXPORTDATA void callOnMainThread(MainThreadFunction*, void* context);
4040
41 void setMainThreadCallbacksPaused(bool paused);
 41JS_EXPORTDATA void setMainThreadCallbacksPaused(bool paused);
4242
4343// Must be called from the main thread (Darwin is an exception to this rule).
44 void initializeMainThread();
 44JS_EXPORTDATA void initializeMainThread();
4545
4646// These functions are internal to the callOnMainThread implementation.
4747void initializeMainThreadPlatform();

JavaScriptCore/wtf/RandomNumber.h

@@namespace WTF {
3030
3131 // Returns a pseudo-random number in the range [0, 1), attempts to be
3232 // cryptographically secure if possible on the target platform
33  double randomNumber();
 33 JS_EXPORTDATA double randomNumber();
3434
3535 // Returns a pseudo-random number in the range [0, 1), attempts to
3636 // produce a reasonable "random" number fast.
3737 // We only need this because rand_s is so slow on windows.
38  double weakRandomNumber();
 38 JS_EXPORTDATA double weakRandomNumber();
3939
4040}
4141

JavaScriptCore/wtf/Threading.h

@@typedef void* (*ThreadFunction)(void* argument);
110110
111111// Returns 0 if thread creation failed.
112112// The thread name must be a literal since on some platforms it's passed in to the thread.
113 ThreadIdentifier createThread(ThreadFunction, void*, const char* threadName);
 113JS_EXPORTDATA ThreadIdentifier createThread(ThreadFunction, void*, const char* threadName);
114114
115115// Internal platform-specific createThread implementation.
116 ThreadIdentifier createThreadInternal(ThreadFunction, void*, const char* threadName);
 116JS_EXPORTDATA ThreadIdentifier createThreadInternal(ThreadFunction, void*, const char* threadName);
117117
118118// Called in the thread during initialization.
119119// Helpful for platforms where the thread name must be set from within the thread.
120 void setThreadNameInternal(const char* threadName);
 120JS_EXPORTDATA void setThreadNameInternal(const char* threadName);
121121
122 ThreadIdentifier currentThread();
123 bool isMainThread();
124 int waitForThreadCompletion(ThreadIdentifier, void**);
125 void detachThread(ThreadIdentifier);
 122JS_EXPORTDATA ThreadIdentifier currentThread();
 123JS_EXPORTDATA bool isMainThread();
 124JS_EXPORTDATA int waitForThreadCompletion(ThreadIdentifier, void**);
 125JS_EXPORTDATA void detachThread(ThreadIdentifier);
126126
127127#if USE(PTHREADS)
128128typedef pthread_mutex_t PlatformMutex;

@@typedef void* PlatformReadWriteLock;
159159typedef void* PlatformCondition;
160160#endif
161161
162 class Mutex : public Noncopyable {
 162class JS_EXPORTDATA Mutex : public Noncopyable {
163163public:
164164 Mutex();
165165 ~Mutex();

@@private:
176176
177177typedef Locker<Mutex> MutexLocker;
178178
179 class ReadWriteLock : public Noncopyable {
 179class JS_EXPORTDATA ReadWriteLock : public Noncopyable {
180180public:
181181 ReadWriteLock();
182182 ~ReadWriteLock();

@@public:
310310
311311// This function must be called from the main thread. It is safe to call it repeatedly.
312312// 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.
313 void initializeThreading();
 313JS_EXPORTDATA void initializeThreading();
314314
315 void lockAtomicallyInitializedStaticMutex();
316 void unlockAtomicallyInitializedStaticMutex();
 315JS_EXPORTDATA void lockAtomicallyInitializedStaticMutex();
 316JS_EXPORTDATA void unlockAtomicallyInitializedStaticMutex();
317317
318318} // namespace WTF
319319

JavaScriptCore/wtf/dtoa.h

@@namespace WTF {
2929
3030 extern WTF::Mutex* s_dtoaP5Mutex;
3131
32  double strtod(const char* s00, char** se);
33  void dtoa(char* result, double d, int ndigits, int* decpt, int* sign, char** rve);
 32 JS_EXPORTDATA double strtod(const char* s00, char** se);
 33 JS_EXPORTDATA void dtoa(char* result, double d, int ndigits, int* decpt, int* sign, char** rve);
3434
3535} // namespace WTF
3636

JavaScriptCore/wtf/unicode/UTF8.cpp

2323 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2424 */
2525
 26#include "config.h"
2627#include "UTF8.h"
2728
2829namespace WTF {

JavaScriptCore/wtf/unicode/UTF8.h

@@namespace WTF {
3434 // Given a first byte, gives the length of the UTF-8 sequence it begins.
3535 // Returns 0 for bytes that are not legal starts of UTF-8 sequences.
3636 // Only allows sequences of up to 4 bytes, since that works for all Unicode characters (U-00000000 to U-0010FFFF).
37  int UTF8SequenceLength(char);
 37 JS_EXPORTDATA int UTF8SequenceLength(char);
3838
3939 // Takes a null-terminated C-style string with a UTF-8 sequence in it and converts it to a character.
4040 // Only allows Unicode characters (U-00000000 to U-0010FFFF).
4141 // Returns -1 if the sequence is not valid (including presence of extra bytes).
42  int decodeUTF8Sequence(const char*);
 42 JS_EXPORTDATA int decodeUTF8Sequence(const char*);
4343
4444 typedef enum {
4545 conversionOK, // conversion successful

@@namespace WTF {
6262 // to the replacement character; otherwise (when the flag is set to strict)
6363 // they constitute an error.
6464
65  ConversionResult convertUTF8ToUTF16(
66  const char** sourceStart, const char* sourceEnd,
 65 JS_EXPORTDATA ConversionResult convertUTF8ToUTF16(
 66 const char** sourceStart, const char* sourceEnd,
6767 UChar** targetStart, UChar* targetEnd, bool strict = true);
6868
69  ConversionResult convertUTF16ToUTF8(
70  const UChar** sourceStart, const UChar* sourceEnd,
 69 JS_EXPORTDATA ConversionResult convertUTF16ToUTF8(
 70 const UChar** sourceStart, const UChar* sourceEnd,
7171 char** targetStart, char* targetEnd, bool strict = true);
7272 }
7373}

WebCore/ChangeLog

 12009-07-24 Kenneth Rohde Christiansen <kenneth.christiansen@openbossa.org>, Simon Hausmann <simon.hausmann@nokia.com>
 2
 3 Reviewed by NOBODY (OOPS!).
 4
 5 Define JS_EXPORTDATA and WEBKIT_EXPORTDATA for gcc.
 6
 7 Link QTMovieWin against JavaScriptCore for the exported
 8 WTF symbols.
 9
 10 * WebCore.vcproj/QTMovieWin.vcproj: Link QTMovieWin against JSC dll,
 11 for the exported WTF symbols.
 12 * config.h: Tweak for gcc.
 13
1142009-07-30 Xan Lopez <xlopez@igalia.com>
215
316 Reviewed by Maciej Stachowiak.

WebCore/WebCore.vcproj/QTMovieWin.vcproj

5555 />
5656 <Tool
5757 Name="VCLinkerTool"
58  AdditionalDependencies="QTMLClient.lib WTF$(WebKitConfigSuffix).lib winmm.lib pthreadVC2$(LibraryConfigSuffix).lib Msimg32.lib user32.lib advapi32.lib"
 58 AdditionalDependencies="QTMLClient.lib JavaScriptCore$(WebKitDLLConfigSuffix).lib winmm.lib pthreadVC2$(LibraryConfigSuffix).lib Msimg32.lib user32.lib advapi32.lib"
5959 OutputFile="$(OutDir)\$(ProjectName)$(WebKitConfigSuffix).dll"
6060 AdditionalLibraryDirectories="&quot;$(WebKitLibrariesDir)\QuickTime SDK\Libraries&quot;;&quot;$(ProgramFiles)\QuickTime SDK\Libraries&quot;"
6161 IgnoreDefaultLibraryNames="LIBCMT"

128128 />
129129 <Tool
130130 Name="VCLinkerTool"
131  AdditionalDependencies="QTMLClient.lib WTF$(WebKitConfigSuffix).lib winmm.lib pthreadVC2$(LibraryConfigSuffix).lib Msimg32.lib user32.lib advapi32.lib"
 131 AdditionalDependencies="QTMLClient.lib JavaScriptCore$(WebKitDLLConfigSuffix).lib winmm.lib pthreadVC2$(LibraryConfigSuffix).lib Msimg32.lib user32.lib advapi32.lib"
132132 OutputFile="$(OutDir)\$(ProjectName)$(WebKitConfigSuffix).dll"
133133 AdditionalLibraryDirectories="&quot;$(WebKitLibrariesDir)\QuickTime SDK\Libraries&quot;;&quot;$(ProgramFiles)\QuickTime SDK\Libraries&quot;"
134134 IgnoreDefaultLibraryNames="LIBCMT"

200200 />
201201 <Tool
202202 Name="VCLinkerTool"
203  AdditionalDependencies="QTMLClient.lib WTF$(WebKitConfigSuffix).lib winmm.lib pthreadVC2$(LibraryConfigSuffix).lib Msimg32.lib user32.lib advapi32.lib"
 203 AdditionalDependencies="QTMLClient.lib JavaScriptCore$(WebKitDLLConfigSuffix).lib winmm.lib pthreadVC2$(LibraryConfigSuffix).lib Msimg32.lib user32.lib advapi32.lib"
204204 OutputFile="$(OutDir)\$(ProjectName)$(WebKitConfigSuffix).dll"
205205 AdditionalLibraryDirectories="&quot;$(WebKitLibrariesDir)\QuickTime SDK\Libraries&quot;;&quot;$(ProgramFiles)\QuickTime SDK\Libraries&quot;"
206206 IgnoreDefaultLibraryNames="LIBCMT"

WebCore/config.h

2424
2525#include <wtf/Platform.h>
2626
27 #if PLATFORM(WIN_OS) && !defined(BUILDING_WX__) && !COMPILER(GCC)
28 #if defined(BUILDING_JavaScriptCore) || defined(BUILDING_WTF)
29 #define JS_EXPORTDATA __declspec(dllexport)
 27#undef JS_EXPORTDATA
 28#undef WEBKIT_EXPORTDATA
 29#if COMPILER(GCC)
 30 #define JS_EXPORTDATA __attribute__((visibility("default")))
 31 #define WEBKIT_EXPORTDATA __attribute__((visibility("default")))
 32#elif PLATFORM(WIN_OS) && !defined(BUILDING_WX__)
 33 #if defined(BUILDING_JavaScriptCore) || defined(BUILDING_WTF)
 34 #define JS_EXPORTDATA __declspec(dllexport)
 35 #else
 36 #define JS_EXPORTDATA __declspec(dllimport)
 37 #endif
 38 #if defined(BUILDING_WebCore) || defined(BUILDING_WebKit)
 39 #define WEBKIT_EXPORTDATA __declspec(dllexport)
 40 #else
 41 #define WEBKIT_EXPORTDATA __declspec(dllimport)
 42 #endif
3043#else
31 #define JS_EXPORTDATA __declspec(dllimport)
32 #endif
33 #if defined(BUILDING_WebCore) || defined(BUILDING_WebKit)
34 #define WEBKIT_EXPORTDATA __declspec(dllexport)
35 #else
36 #define WEBKIT_EXPORTDATA __declspec(dllimport)
37 #endif
38 #else
39 #define JS_EXPORTDATA
40 #define WEBKIT_EXPORTDATA
 44 #define JS_EXPORTDATA
 45 #define WEBKIT_EXPORTDATA
4146#endif
4247
4348#define MOBILE 0

WebKit/cf/ChangeLog

 12009-07-24 Simon Hausmann <simon.hausmann@nokia.com>
 2
 3 Reviewed by NOBODY (OOPS!).
 4
 5 Fix compilation on the Mac, don't re-define JS_EXPORTDATA empty but
 6 re-use the definition from WebKitPrefix.h.
 7
 8 * WebCoreSupport/WebInspectorClientCF.cpp:
 9
1102009-04-20 Steve Falkenburg <sfalken@apple.com>
211
312 Separate JavaScriptCore.dll from WebKit.dll.

WebKit/cf/WebCoreSupport/WebInspectorClientCF.cpp

4343#else
4444#define JS_EXPORTDATA __declspec(dllimport)
4545#endif
46 #else
47 #define JS_EXPORTDATA
4846#endif
4947
5048#include "WebInspectorClient.h"

WebKit/mac/ChangeLog

 12009-07-24 Simon Hausmann <simon.hausmann@nokia.com>
 2
 3 Reviewed by NOBODY (OOPS!).
 4
 5 Duplicate the JS_EXPORTDATA and WEBKIT_EXPORTDATA definition from
 6 WebCore/config.h to fix compilation against JavaScriptCore and
 7 WebCore on the Mac.
 8
 9 * WebKitPrefix.h:
 10
1112009-07-29 David Kilzer <ddkilzer@apple.com>
212
313 <http://webkit.org/b/27788> Don't export WebPluginController.h as a private header

WebKit/mac/WebKitPrefix.h

@@typedef float CGFloat;
8383#define WTF_USE_JSC 1
8484#define WTF_USE_V8 0
8585
 86#undef JS_EXPORTDATA
 87#undef WEBKIT_EXPORTDATA
 88#if COMPILER(GCC)
 89 #define JS_EXPORTDATA __attribute__((visibility("default")))
 90 #define WEBKIT_EXPORTDATA __attribute__((visibility("default")))
 91#elif PLATFORM(WIN_OS) && !defined(BUILDING_WX__) && !defined(BUILDING_QTMovieWin)
 92 #if defined(BUILDING_JavaScriptCore) || defined(BUILDING_WTF)
 93 #define JS_EXPORTDATA __declspec(dllexport)
 94 #else
 95 #define JS_EXPORTDATA __declspec(dllimport)
 96 #endif
 97 #if defined(BUILDING_WebCore) || defined(BUILDING_WebKit)
 98 #define WEBKIT_EXPORTDATA __declspec(dllexport)
 99 #else
 100 #define WEBKIT_EXPORTDATA __declspec(dllimport)
 101 #endif
 102#else
 103 #define JS_EXPORTDATA
 104 #define WEBKIT_EXPORTDATA
 105#endif
 106
86107#ifdef __cplusplus
87108#include <wtf/FastMalloc.h>
88109#endif

@@typedef float CGFloat;
92113/* Work around bug with C++ library that screws up Objective-C++ when exception support is disabled. */
93114#undef try
94115#undef catch
95 
96 #define JS_EXPORTDATA
97 #define WEBKIT_EXPORTDATA

WebKit/win/ChangeLog

 12009-07-24 Simon Hausmann <simon.hausmann@nokia.com>
 2
 3 Reviewed by NOBODY (OOPS!).
 4
 5 Fix compilation, disable bogus DLL linkage warnings and
 6 define JS_EXPORTDATA like in JavaScriptCore/config.h, to
 7 fix symbol import form JavaScriptCore.
 8
 9 * WebKit.vcproj/WebKit.vcproj: Tweak.
 10 * WebKitDLL.h: Define JS_EXPORTDATA.
 11
1122009-07-29 Brian Weinstein <bweinstein@apple.com>
213
314 Was doing the build fix wrong, NotImplemented.h is in WebCore.

WebKit/win/WebKitDLL.h

3030#define _HAS_EXCEPTIONS 0
3131#endif
3232
 33#if defined(WIN32) || defined(_WIN32)
 34#if defined(BUILDING_JavaScriptCore) || defined(BUILDING_WTF)
 35#define JS_EXPORTDATA __declspec(dllexport)
 36#else
 37#define JS_EXPORTDATA __declspec(dllimport)
 38#endif
 39#else
 40#define JS_EXPORTDATA
 41#endif
 42
3343#include <winsock2.h>
3444#include <windows.h>
3545#include <wtf/HashCountedSet.h>

WebKitLibraries/ChangeLog

 12009-07-30 Simon Hausmann <simon.hausmann@nokia.com>
 2
 3 Reviewed by NOBODY (OOPS!).
 4
 5 Disable MSVC warning 4251 about the need to the types of member variables
 6 that aren't exported yet. We decide to ignore this warning, as fixing it
 7 requires explicitly exporting all template instantiations used in exported
 8 classes' member variables. All of that doesn't seem to be necessary, as
 9 the successful use of .def files with hand-picked symbols prooves.
 10
 11 As a side-note Qt for example has this particular warning globally
 12 disabled (via pragma in qglobal.h) and it's working just fine for
 13 everyone.
 14
 15 * win/tools/vsprops/common.vsprops:
 16
1172009-07-27 Peter Kasting <pkasting@google.com>
218
319 Reviewed by Adam Roben.

WebKitLibraries/win/tools/vsprops/common.vsprops

1515 WarningLevel="4"
1616 WarnAsError="true"
1717 DebugInformationFormat="3"
18  DisableSpecificWarnings="4018;4068;4099;4100;4127;4138;4189;4244;4275;4291;4305;4344;4355;4389;4503;4505;4510;4512;4610;4706;4800;4951;4952;4996;6011;6031;6211;6246;6255;6387"
 18 DisableSpecificWarnings="4018;4068;4099;4100;4127;4138;4189;4244;4251;4275;4291;4305;4344;4355;4389;4503;4505;4510;4512;4610;4706;4800;4951;4952;4996;6011;6031;6211;6246;6255;6387"
1919 />
2020 <Tool
2121 Name="VCLibrarianTool"

WebKitTools/ChangeLog

 12009-07-28 Simon Hausmann <simon.hausmann@nokia.com>
 2
 3 Reviewed by NOBODY (OOPS!).
 4
 5 Fix compilation on the Mac.
 6
 7 * DumpRenderTree/config.h: Move FastMalloc.h inclusion until after the definition of
 8 JS_EXPORTDATA.
 9 * DumpRenderTree/pthreads/JavaScriptThreadingPthreads.cpp: Include config.h for the
 10 export macros.
 11
1122009-07-30 Tor Arne Vestbø <tor.arne.vestbo@nokia.com>
213
314 Reviewed by Eric Seidel.

WebKitTools/DumpRenderTree/config.h

2626
2727#include <wtf/Platform.h>
2828
29 #ifdef __cplusplus
30 #undef new
31 #undef delete
32 #include <wtf/FastMalloc.h>
33 #endif
34 
3529#if PLATFORM(WIN_OS) && !COMPILER(GCC)
3630#define JS_EXPORTDATA __declspec(dllimport)
3731#define WEBKIT_EXPORTDATA __declspec(dllimport)

4034#define WEBKIT_EXPORTDATA
4135#endif
4236
 37#ifdef __cplusplus
 38#undef new
 39#undef delete
 40#include <wtf/FastMalloc.h>
 41#endif
 42
4343#if PLATFORM(WIN)
4444#define WTF_PLATFORM_CF 1
4545#if defined(WIN_CAIRO)

WebKitTools/DumpRenderTree/pthreads/JavaScriptThreadingPthreads.cpp

2727 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
2828 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
2929 */
30 
 30
 31#include "config.h"
3132#include "JavaScriptThreading.h"
3233
3334#include <CoreFoundation/CoreFoundation.h>