[Win] testapi and testRegExp need to find support libraries.
[WebKit-https.git] / Source / JavaScriptCore / testRegExp.cpp
index 5502ed3..9286ce1 100644 (file)
 
 #include <wtf/CurrentTime.h>
 #include "InitializeThreading.h"
+#include "JSCInlines.h"
 #include "JSGlobalObject.h"
-#include "UStringBuilder.h"
 #include <errno.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <wtf/text/StringBuilder.h>
 
 #if !OS(WINDOWS)
 #include <unistd.h>
 #include <windows.h>
 #endif
 
-#if PLATFORM(QT)
-#include <QCoreApplication>
-#include <QDateTime>
-#endif
+namespace JSC {
+WTF_IMPORT extern const struct HashTable globalObjectTable;
+}
 
 const int MaxLineLength = 100 * 1024;
 
 using namespace JSC;
 using namespace WTF;
 
-static void cleanupGlobalData(JSGlobalData*);
-
 struct CommandLine {
     CommandLine()
         : interactive(false)
@@ -65,8 +63,8 @@ struct CommandLine {
 
     bool interactive;
     bool verbose;
-    Vector<UString> arguments;
-    Vector<UString> files;
+    Vector<String> arguments;
+    Vector<String> files;
 };
 
 class StopWatch {
@@ -82,12 +80,12 @@ private:
 
 void StopWatch::start()
 {
-    m_startTime = currentTime();
+    m_startTime = monotonicallyIncreasingTime();
 }
 
 void StopWatch::stop()
 {
-    m_stopTime = currentTime();
+    m_stopTime = monotonicallyIncreasingTime();
 }
 
 long StopWatch::getElapsedMS()
@@ -102,7 +100,7 @@ struct RegExpTest {
     {
     }
 
-    UString subject;
+    String subject;
     int offset;
     int result;
     Vector<int, 32> expectVector;
@@ -110,40 +108,41 @@ struct RegExpTest {
 
 class GlobalObject : public JSGlobalObject {
 private:
-    GlobalObject(JSGlobalData&, Structure*, const Vector<UString>& arguments);
+    GlobalObject(VM&, Structure*, const Vector<String>& arguments);
 
 public:
     typedef JSGlobalObject Base;
 
-    static GlobalObject* create(JSGlobalData& globalData, Structure* structure, const Vector<UString>& arguments)
+    static GlobalObject* create(VM& vm, Structure* structure, const Vector<String>& arguments)
     {
-        return new (NotNull, allocateCell<GlobalObject>(globalData.heap)) GlobalObject(globalData, structure, arguments);
+        GlobalObject* globalObject = new (NotNull, allocateCell<GlobalObject>(vm.heap)) GlobalObject(vm, structure, arguments);
+        vm.heap.addFinalizer(globalObject, destroy);
+        return globalObject;
     }
 
-    static const ClassInfo s_info;
+    DECLARE_INFO;
+
+    static const bool needsDestructor = false;
 
-    static Structure* createStructure(JSGlobalData& globalData, JSValue prototype)
+    static Structure* createStructure(VM& vm, JSValue prototype)
     {
-        return Structure::create(globalData, 0, prototype, TypeInfo(GlobalObjectType, StructureFlags), &s_info);
+        return Structure::create(vm, 0, prototype, TypeInfo(GlobalObjectType, StructureFlags), info());
     }
 
 protected:
-    void finishCreation(JSGlobalData& globalData, const Vector<UString>& arguments)
+    void finishCreation(VM& vm, const Vector<String>& arguments)
     {
-        Base::finishCreation(globalData);
+        Base::finishCreation(vm);
         UNUSED_PARAM(arguments);
     }
 };
 
-COMPILE_ASSERT(!IsInteger<GlobalObject>::value, WTF_IsInteger_GlobalObject_false);
-ASSERT_CLASS_FITS_IN_CELL(GlobalObject);
+const ClassInfo GlobalObject::s_info = { "global", &JSGlobalObject::s_info, &globalObjectTable, CREATE_METHOD_TABLE(GlobalObject) };
 
-const ClassInfo GlobalObject::s_info = { "global", &JSGlobalObject::s_info, 0, ExecState::globalObjectTable, CREATE_METHOD_TABLE(GlobalObject) };
-
-GlobalObject::GlobalObject(JSGlobalData& globalData, Structure* structure, const Vector<UString>& arguments)
-    : JSGlobalObject(globalData, structure)
+GlobalObject::GlobalObject(VM& vm, Structure* structure, const Vector<String>& arguments)
+    : JSGlobalObject(vm, structure)
 {
-    finishCreation(globalData, arguments);
+    finishCreation(vm, arguments);
 }
 
 // Use SEH for Release builds only to get rid of the crash report dialog
@@ -151,7 +150,7 @@ GlobalObject::GlobalObject(JSGlobalData& globalData, Structure* structure, const
 // be in a separate main function because the realMain function requires object
 // unwinding.
 
-#if COMPILER(MSVC) && !COMPILER(INTEL) && !defined(_DEBUG) && !OS(WINCE)
+#if COMPILER(MSVC) && !defined(_DEBUG) && !OS(WINCE)
 #define TRY       __try {
 #define EXCEPT(x) } __except (EXCEPTION_EXECUTE_HANDLER) { x; }
 #else
@@ -159,7 +158,7 @@ GlobalObject::GlobalObject(JSGlobalData& globalData, Structure* structure, const
 #define EXCEPT(x)
 #endif
 
-int realMain(int argc, char** argv, JSGlobalData*);
+int realMain(int argc, char** argv);
 
 int main(int argc, char** argv)
 {
@@ -183,39 +182,24 @@ int main(int argc, char** argv)
     timeBeginPeriod(1);
 #endif
 
-#if PLATFORM(QT)
-    QCoreApplication app(argc, argv);
-#endif
-
-    // Initialize JSC before getting JSGlobalData.
+    // Initialize JSC before getting VM.
     JSC::initializeThreading();
 
     // We can't use destructors in the following code because it uses Windows
     // Structured Exception Handling
     int res = 0;
-    JSGlobalData* globalData = JSGlobalData::create(ThreadStackTypeLarge, LargeHeap).leakRef();
     TRY
-        res = realMain(argc, argv, globalData);
+        res = realMain(argc, argv);
     EXCEPT(res = 3)
-
-    cleanupGlobalData(globalData);
     return res;
 }
 
-static void cleanupGlobalData(JSGlobalData* globalData)
-{
-    JSLock lock(SilenceAssertionsOnly);
-    globalData->clearBuiltinStructures();
-    globalData->heap.destroy();
-    globalData->deref();
-}
-
-static bool testOneRegExp(JSGlobalData& globalData, RegExp* regexp, RegExpTest* regExpTest, bool verbose, unsigned int lineNumber)
+static bool testOneRegExp(VM& vm, RegExp* regexp, RegExpTest* regExpTest, bool verbose, unsigned int lineNumber)
 {
     bool result = true;
     Vector<int, 32> outVector;
     outVector.resize(regExpTest->expectVector.size());
-    int matchResult = regexp->match(globalData, regExpTest->subject, regExpTest->offset, outVector);
+    int matchResult = regexp->match(vm, regExpTest->subject, regExpTest->offset, outVector);
 
     if (matchResult != regExpTest->result) {
         result = false;
@@ -252,7 +236,7 @@ static bool testOneRegExp(JSGlobalData& globalData, RegExp* regexp, RegExpTest*
     return result;
 }
 
-static int scanString(char* buffer, int bufferLength, UStringBuilder& builder, char termChar)
+static int scanString(char* buffer, int bufferLength, StringBuilder& builder, char termChar)
 {
     bool escape = false;
     
@@ -318,9 +302,9 @@ static int scanString(char* buffer, int bufferLength, UStringBuilder& builder, c
     return -1;
 }
 
-static RegExp* parseRegExpLine(JSGlobalData& globalData, char* line, int lineLength)
+static RegExp* parseRegExpLine(VM& vm, char* line, int lineLength)
 {
-    UStringBuilder pattern;
+    StringBuilder pattern;
     
     if (line[0] != '/')
         return 0;
@@ -332,12 +316,12 @@ static RegExp* parseRegExpLine(JSGlobalData& globalData, char* line, int lineLen
 
     ++i;
 
-    return RegExp::create(globalData, pattern.toUString(), regExpFlags(line + i));
+    return RegExp::create(vm, pattern.toString(), regExpFlags(line + i));
 }
 
 static RegExpTest* parseTestLine(char* line, int lineLength)
 {
-    UStringBuilder subjectString;
+    StringBuilder subjectString;
     
     if ((line[0] != ' ') || (line[1] != '"'))
         return 0;
@@ -376,7 +360,7 @@ static RegExpTest* parseTestLine(char* line, int lineLength)
     
     RegExpTest* result = new RegExpTest();
     
-    result->subject = subjectString.toUString();
+    result->subject = subjectString.toString();
     result->offset = offset;
     result->result = matchResult;
 
@@ -407,16 +391,16 @@ static RegExpTest* parseTestLine(char* line, int lineLength)
     return result;
 }
 
-static bool runFromFiles(GlobalObject* globalObject, const Vector<UString>& files, bool verbose)
+static bool runFromFiles(GlobalObject* globalObject, const Vector<String>& files, bool verbose)
 {
-    UString script;
-    UString fileName;
+    String script;
+    String fileName;
     Vector<char> scriptBuffer;
     unsigned tests = 0;
     unsigned failures = 0;
     char* lineBuffer = new char[MaxLineLength + 1];
 
-    JSGlobalData& globalData = globalObject->globalData();
+    VM& vm = globalObject->vm();
 
     bool success = true;
     for (size_t i = 0; i < files.size(); i++) {
@@ -444,13 +428,13 @@ static bool runFromFiles(GlobalObject* globalObject, const Vector<UString>& file
                 continue;
 
             if (linePtr[0] == '/') {
-                regexp = parseRegExpLine(globalData, linePtr, lineLength);
+                regexp = parseRegExpLine(vm, linePtr, lineLength);
             } else if (linePtr[0] == ' ') {
                 RegExpTest* regExpTest = parseTestLine(linePtr, lineLength);
                 
                 if (regexp && regExpTest) {
                     ++tests;
-                    if (!testOneRegExp(globalData, regexp, regExpTest, verbose, lineNumber)) {
+                    if (!testOneRegExp(vm, regexp, regExpTest, verbose, lineNumber)) {
                         failures++;
                         printf("Failure on line %u\n", lineNumber);
                     }
@@ -471,32 +455,31 @@ static bool runFromFiles(GlobalObject* globalObject, const Vector<UString>& file
 
     delete[] lineBuffer;
 
-    globalData.dumpSampleData(globalObject->globalExec());
+    vm.dumpSampleData(globalObject->globalExec());
 #if ENABLE(REGEXP_TRACING)
-    globalData.dumpRegExpTrace();
+    vm.dumpRegExpTrace();
 #endif
     return success;
 }
 
 #define RUNNING_FROM_XCODE 0
 
-static NO_RETURN void printUsageStatement(JSGlobalData* globalData, bool help = false)
+static NO_RETURN void printUsageStatement(bool help = false)
 {
     fprintf(stderr, "Usage: regexp_test [options] file\n");
     fprintf(stderr, "  -h|--help  Prints this help message\n");
     fprintf(stderr, "  -v|--verbose  Verbose output\n");
 
-    cleanupGlobalData(globalData);
     exit(help ? EXIT_SUCCESS : EXIT_FAILURE);
 }
 
-static void parseArguments(int argc, char** argv, CommandLine& options, JSGlobalData* globalData)
+static void parseArguments(int argc, char** argv, CommandLine& options)
 {
     int i = 1;
     for (; i < argc; ++i) {
         const char* arg = argv[i];
         if (!strcmp(arg, "-h") || !strcmp(arg, "--help"))
-            printUsageStatement(globalData, true);
+            printUsageStatement(true);
         if (!strcmp(arg, "-v") || !strcmp(arg, "--verbose"))
             options.verbose = true;
         else
@@ -507,15 +490,23 @@ static void parseArguments(int argc, char** argv, CommandLine& options, JSGlobal
         options.arguments.append(argv[i]);
 }
 
-int realMain(int argc, char** argv, JSGlobalData* globalData)
+int realMain(int argc, char** argv)
 {
-    JSLock lock(SilenceAssertionsOnly);
+    VM* vm = VM::create(LargeHeap).leakRef();
+    JSLockHolder locker(vm);
 
     CommandLine options;
-    parseArguments(argc, argv, options, globalData);
+    parseArguments(argc, argv, options);
 
-    GlobalObject* globalObject = GlobalObject::create(*globalData, GlobalObject::createStructure(*globalData, jsNull()), options.arguments);
+    GlobalObject* globalObject = GlobalObject::create(*vm, GlobalObject::createStructure(*vm, jsNull()), options.arguments);
     bool success = runFromFiles(globalObject, options.files, options.verbose);
 
     return success ? 0 : 3;
 }
+
+#if OS(WINDOWS)
+extern "C" __declspec(dllexport) int WINAPI dllLauncherEntryPoint(int argc, const char* argv[])
+{
+    return main(argc, const_cast<char**>(argv));
+}
+#endif