Home | History | Annotate | Download | only in JavaScriptCore 
      1 /*
      2  *  Copyright (C) 1999-2000 Harri Porten (porten (at) kde.org)
      3  *  Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
      4  *  Copyright (C) 2006 Bjoern Graf (bjoern.graf (at) gmail.com)
      5  *
      6  *  This library is free software; you can redistribute it and/or
      7  *  modify it under the terms of the GNU Library General Public
      8  *  License as published by the Free Software Foundation; either
      9  *  version 2 of the License, or (at your option) any later version.
     10  *
     11  *  This library is distributed in the hope that it will be useful,
     12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
     13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     14  *  Library General Public License for more details.
     15  *
     16  *  You should have received a copy of the GNU Library General Public License
     17  *  along with this library; see the file COPYING.LIB.  If not, write to
     18  *  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     19  *  Boston, MA 02110-1301, USA.
     20  *
     21  */
     22 
     23 #include "config.h"
     24 
     25 #include "BytecodeGenerator.h"
     26 #include "Completion.h"
     27 #include "CurrentTime.h"
     28 #include "InitializeThreading.h"
     29 #include "JSArray.h"
     30 #include "JSFunction.h"
     31 #include "JSLock.h"
     32 #include "JSString.h"
     33 #include "PrototypeFunction.h"
     34 #include "SamplingTool.h"
     35 #include <math.h>
     36 #include <stdio.h>
     37 #include <stdlib.h>
     38 #include <string.h>
     39 
     40 #if !OS(WINDOWS)
     41 #include <unistd.h>
     42 #endif
     43 
     44 #if HAVE(READLINE)
     45 #include <readline/history.h>
     46 #include <readline/readline.h>
     47 #endif
     48 
     49 #if HAVE(SYS_TIME_H)
     50 #include <sys/time.h>
     51 #endif
     52 
     53 #if HAVE(SIGNAL_H)
     54 #include <signal.h>
     55 #endif
     56 
     57 #if COMPILER(MSVC) && !OS(WINCE)
     58 #include <crtdbg.h>
     59 #include <mmsystem.h>
     60 #include <windows.h>
     61 #endif
     62 
     63 #if PLATFORM(QT)
     64 #include <QCoreApplication>
     65 #include <QDateTime>
     66 #endif
     67 
     68 using namespace JSC;
     69 using namespace WTF;
     70 
     71 static void cleanupGlobalData(JSGlobalData*);
     72 static bool fillBufferWithContentsOfFile(const UString& fileName, Vector<char>& buffer);
     73 
     74 static JSValue JSC_HOST_CALL functionPrint(ExecState*, JSObject*, JSValue, const ArgList&);
     75 static JSValue JSC_HOST_CALL functionDebug(ExecState*, JSObject*, JSValue, const ArgList&);
     76 static JSValue JSC_HOST_CALL functionGC(ExecState*, JSObject*, JSValue, const ArgList&);
     77 static JSValue JSC_HOST_CALL functionVersion(ExecState*, JSObject*, JSValue, const ArgList&);
     78 static JSValue JSC_HOST_CALL functionRun(ExecState*, JSObject*, JSValue, const ArgList&);
     79 static JSValue JSC_HOST_CALL functionLoad(ExecState*, JSObject*, JSValue, const ArgList&);
     80 static JSValue JSC_HOST_CALL functionCheckSyntax(ExecState*, JSObject*, JSValue, const ArgList&);
     81 static JSValue JSC_HOST_CALL functionReadline(ExecState*, JSObject*, JSValue, const ArgList&);
     82 static NO_RETURN JSValue JSC_HOST_CALL functionQuit(ExecState*, JSObject*, JSValue, const ArgList&);
     83 
     84 #if ENABLE(SAMPLING_FLAGS)
     85 static JSValue JSC_HOST_CALL functionSetSamplingFlags(ExecState*, JSObject*, JSValue, const ArgList&);
     86 static JSValue JSC_HOST_CALL functionClearSamplingFlags(ExecState*, JSObject*, JSValue, const ArgList&);
     87 #endif
     88 
     89 struct Script {
     90     bool isFile;
     91     char* argument;
     92 
     93     Script(bool isFile, char *argument)
     94         : isFile(isFile)
     95         , argument(argument)
     96     {
     97     }
     98 };
     99 
    100 struct Options {
    101     Options()
    102         : interactive(false)
    103         , dump(false)
    104     {
    105     }
    106 
    107     bool interactive;
    108     bool dump;
    109     Vector<Script> scripts;
    110     Vector<UString> arguments;
    111 };
    112 
    113 static const char interactivePrompt[] = "> ";
    114 static const UString interpreterName("Interpreter");
    115 
    116 class StopWatch {
    117 public:
    118     void start();
    119     void stop();
    120     long getElapsedMS(); // call stop() first
    121 
    122 private:
    123     double m_startTime;
    124     double m_stopTime;
    125 };
    126 
    127 void StopWatch::start()
    128 {
    129     m_startTime = currentTime();
    130 }
    131 
    132 void StopWatch::stop()
    133 {
    134     m_stopTime = currentTime();
    135 }
    136 
    137 long StopWatch::getElapsedMS()
    138 {
    139     return static_cast<long>((m_stopTime - m_startTime) * 1000);
    140 }
    141 
    142 class GlobalObject : public JSGlobalObject {
    143 public:
    144     GlobalObject(const Vector<UString>& arguments);
    145     virtual UString className() const { return "global"; }
    146 };
    147 COMPILE_ASSERT(!IsInteger<GlobalObject>::value, WTF_IsInteger_GlobalObject_false);
    148 ASSERT_CLASS_FITS_IN_CELL(GlobalObject);
    149 
    150 GlobalObject::GlobalObject(const Vector<UString>& arguments)
    151     : JSGlobalObject()
    152 {
    153     putDirectFunction(globalExec(), new (globalExec()) NativeFunctionWrapper(globalExec(), prototypeFunctionStructure(), 1, Identifier(globalExec(), "debug"), functionDebug));
    154     putDirectFunction(globalExec(), new (globalExec()) NativeFunctionWrapper(globalExec(), prototypeFunctionStructure(), 1, Identifier(globalExec(), "print"), functionPrint));
    155     putDirectFunction(globalExec(), new (globalExec()) NativeFunctionWrapper(globalExec(), prototypeFunctionStructure(), 0, Identifier(globalExec(), "quit"), functionQuit));
    156     putDirectFunction(globalExec(), new (globalExec()) NativeFunctionWrapper(globalExec(), prototypeFunctionStructure(), 0, Identifier(globalExec(), "gc"), functionGC));
    157     putDirectFunction(globalExec(), new (globalExec()) NativeFunctionWrapper(globalExec(), prototypeFunctionStructure(), 1, Identifier(globalExec(), "version"), functionVersion));
    158     putDirectFunction(globalExec(), new (globalExec()) NativeFunctionWrapper(globalExec(), prototypeFunctionStructure(), 1, Identifier(globalExec(), "run"), functionRun));
    159     putDirectFunction(globalExec(), new (globalExec()) NativeFunctionWrapper(globalExec(), prototypeFunctionStructure(), 1, Identifier(globalExec(), "load"), functionLoad));
    160     putDirectFunction(globalExec(), new (globalExec()) NativeFunctionWrapper(globalExec(), prototypeFunctionStructure(), 1, Identifier(globalExec(), "checkSyntax"), functionCheckSyntax));
    161     putDirectFunction(globalExec(), new (globalExec()) NativeFunctionWrapper(globalExec(), prototypeFunctionStructure(), 0, Identifier(globalExec(), "readline"), functionReadline));
    162 
    163 #if ENABLE(SAMPLING_FLAGS)
    164     putDirectFunction(globalExec(), new (globalExec()) NativeFunctionWrapper(globalExec(), prototypeFunctionStructure(), 1, Identifier(globalExec(), "setSamplingFlags"), functionSetSamplingFlags));
    165     putDirectFunction(globalExec(), new (globalExec()) NativeFunctionWrapper(globalExec(), prototypeFunctionStructure(), 1, Identifier(globalExec(), "clearSamplingFlags"), functionClearSamplingFlags));
    166 #endif
    167 
    168     JSObject* array = constructEmptyArray(globalExec());
    169     for (size_t i = 0; i < arguments.size(); ++i)
    170         array->put(globalExec(), i, jsString(globalExec(), arguments[i]));
    171     putDirect(Identifier(globalExec(), "arguments"), array);
    172 }
    173 
    174 JSValue JSC_HOST_CALL functionPrint(ExecState* exec, JSObject*, JSValue, const ArgList& args)
    175 {
    176     for (unsigned i = 0; i < args.size(); ++i) {
    177         if (i)
    178             putchar(' ');
    179 
    180         printf("%s", args.at(i).toString(exec).UTF8String().c_str());
    181     }
    182 
    183     putchar('\n');
    184     fflush(stdout);
    185     return jsUndefined();
    186 }
    187 
    188 JSValue JSC_HOST_CALL functionDebug(ExecState* exec, JSObject*, JSValue, const ArgList& args)
    189 {
    190     fprintf(stderr, "--> %s\n", args.at(0).toString(exec).UTF8String().c_str());
    191     return jsUndefined();
    192 }
    193 
    194 JSValue JSC_HOST_CALL functionGC(ExecState* exec, JSObject*, JSValue, const ArgList&)
    195 {
    196     JSLock lock(SilenceAssertionsOnly);
    197     exec->heap()->collectAllGarbage();
    198     return jsUndefined();
    199 }
    200 
    201 JSValue JSC_HOST_CALL functionVersion(ExecState*, JSObject*, JSValue, const ArgList&)
    202 {
    203     // We need this function for compatibility with the Mozilla JS tests but for now
    204     // we don't actually do any version-specific handling
    205     return jsUndefined();
    206 }
    207 
    208 JSValue JSC_HOST_CALL functionRun(ExecState* exec, JSObject*, JSValue, const ArgList& args)
    209 {
    210     StopWatch stopWatch;
    211     UString fileName = args.at(0).toString(exec);
    212     Vector<char> script;
    213     if (!fillBufferWithContentsOfFile(fileName, script))
    214         return throwError(exec, GeneralError, "Could not open file.");
    215 
    216     JSGlobalObject* globalObject = exec->lexicalGlobalObject();
    217 
    218     stopWatch.start();
    219     evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName));
    220     stopWatch.stop();
    221 
    222     return jsNumber(globalObject->globalExec(), stopWatch.getElapsedMS());
    223 }
    224 
    225 JSValue JSC_HOST_CALL functionLoad(ExecState* exec, JSObject* o, JSValue v, const ArgList& args)
    226 {
    227     UNUSED_PARAM(o);
    228     UNUSED_PARAM(v);
    229     UString fileName = args.at(0).toString(exec);
    230     Vector<char> script;
    231     if (!fillBufferWithContentsOfFile(fileName, script))
    232         return throwError(exec, GeneralError, "Could not open file.");
    233 
    234     JSGlobalObject* globalObject = exec->lexicalGlobalObject();
    235     Completion result = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName));
    236     if (result.complType() == Throw)
    237         exec->setException(result.value());
    238     return result.value();
    239 }
    240 
    241 JSValue JSC_HOST_CALL functionCheckSyntax(ExecState* exec, JSObject* o, JSValue v, const ArgList& args)
    242 {
    243     UNUSED_PARAM(o);
    244     UNUSED_PARAM(v);
    245     UString fileName = args.at(0).toString(exec);
    246     Vector<char> script;
    247     if (!fillBufferWithContentsOfFile(fileName, script))
    248         return throwError(exec, GeneralError, "Could not open file.");
    249 
    250     JSGlobalObject* globalObject = exec->lexicalGlobalObject();
    251     Completion result = checkSyntax(globalObject->globalExec(), makeSource(script.data(), fileName));
    252     if (result.complType() == Throw)
    253         exec->setException(result.value());
    254     return result.value();
    255 }
    256 
    257 #if ENABLE(SAMPLING_FLAGS)
    258 JSValue JSC_HOST_CALL functionSetSamplingFlags(ExecState* exec, JSObject*, JSValue, const ArgList& args)
    259 {
    260     for (unsigned i = 0; i < args.size(); ++i) {
    261         unsigned flag = static_cast<unsigned>(args.at(i).toNumber(exec));
    262         if ((flag >= 1) && (flag <= 32))
    263             SamplingFlags::setFlag(flag);
    264     }
    265     return jsNull();
    266 }
    267 
    268 JSValue JSC_HOST_CALL functionClearSamplingFlags(ExecState* exec, JSObject*, JSValue, const ArgList& args)
    269 {
    270     for (unsigned i = 0; i < args.size(); ++i) {
    271         unsigned flag = static_cast<unsigned>(args.at(i).toNumber(exec));
    272         if ((flag >= 1) && (flag <= 32))
    273             SamplingFlags::clearFlag(flag);
    274     }
    275     return jsNull();
    276 }
    277 #endif
    278 
    279 JSValue JSC_HOST_CALL functionReadline(ExecState* exec, JSObject*, JSValue, const ArgList&)
    280 {
    281     Vector<char, 256> line;
    282     int c;
    283     while ((c = getchar()) != EOF) {
    284         // FIXME: Should we also break on \r?
    285         if (c == '\n')
    286             break;
    287         line.append(c);
    288     }
    289     line.append('\0');
    290     return jsString(exec, line.data());
    291 }
    292 
    293 JSValue JSC_HOST_CALL functionQuit(ExecState* exec, JSObject*, JSValue, const ArgList&)
    294 {
    295     // Technically, destroying the heap in the middle of JS execution is a no-no,
    296     // but we want to maintain compatibility with the Mozilla test suite, so
    297     // we pretend that execution has terminated to avoid ASSERTs, then tear down the heap.
    298     exec->globalData().dynamicGlobalObject = 0;
    299 
    300     cleanupGlobalData(&exec->globalData());
    301     exit(EXIT_SUCCESS);
    302 
    303 #if COMPILER(MSVC) && OS(WINCE)
    304     // Without this, Visual Studio will complain that this method does not return a value.
    305     return jsUndefined();
    306 #endif
    307 }
    308 
    309 // Use SEH for Release builds only to get rid of the crash report dialog
    310 // (luckily the same tests fail in Release and Debug builds so far). Need to
    311 // be in a separate main function because the jscmain function requires object
    312 // unwinding.
    313 
    314 #if COMPILER(MSVC) && !defined(_DEBUG)
    315 #define TRY       __try {
    316 #define EXCEPT(x) } __except (EXCEPTION_EXECUTE_HANDLER) { x; }
    317 #else
    318 #define TRY
    319 #define EXCEPT(x)
    320 #endif
    321 
    322 int jscmain(int argc, char** argv, JSGlobalData*);
    323 
    324 int main(int argc, char** argv)
    325 {
    326 #if defined(_DEBUG) && OS(WINDOWS)
    327     _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
    328     _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
    329     _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
    330     _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
    331     _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
    332     _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
    333 #endif
    334 
    335 #if COMPILER(MSVC) && !OS(WINCE)
    336     timeBeginPeriod(1);
    337 #endif
    338 
    339 #if PLATFORM(QT)
    340     QCoreApplication app(argc, argv);
    341 #endif
    342 
    343     // Initialize JSC before getting JSGlobalData.
    344     JSC::initializeThreading();
    345 
    346     // We can't use destructors in the following code because it uses Windows
    347     // Structured Exception Handling
    348     int res = 0;
    349     JSGlobalData* globalData = JSGlobalData::create().releaseRef();
    350     TRY
    351         res = jscmain(argc, argv, globalData);
    352     EXCEPT(res = 3)
    353 
    354     cleanupGlobalData(globalData);
    355     return res;
    356 }
    357 
    358 static void cleanupGlobalData(JSGlobalData* globalData)
    359 {
    360     JSLock lock(SilenceAssertionsOnly);
    361     globalData->heap.destroy();
    362     globalData->deref();
    363 }
    364 
    365 static bool runWithScripts(GlobalObject* globalObject, const Vector<Script>& scripts, bool dump)
    366 {
    367     UString script;
    368     UString fileName;
    369     Vector<char> scriptBuffer;
    370 
    371     if (dump)
    372         BytecodeGenerator::setDumpsGeneratedCode(true);
    373 
    374     JSGlobalData* globalData = globalObject->globalData();
    375 
    376 #if ENABLE(SAMPLING_FLAGS)
    377     SamplingFlags::start();
    378 #endif
    379 
    380     bool success = true;
    381     for (size_t i = 0; i < scripts.size(); i++) {
    382         if (scripts[i].isFile) {
    383             fileName = scripts[i].argument;
    384             if (!fillBufferWithContentsOfFile(fileName, scriptBuffer))
    385                 return false; // fail early so we can catch missing files
    386             script = scriptBuffer.data();
    387         } else {
    388             script = scripts[i].argument;
    389             fileName = "[Command Line]";
    390         }
    391 
    392         globalData->startSampling();
    393 
    394         Completion completion = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script, fileName));
    395         success = success && completion.complType() != Throw;
    396         if (dump) {
    397             if (completion.complType() == Throw)
    398                 printf("Exception: %s\n", completion.value().toString(globalObject->globalExec()).ascii());
    399             else
    400                 printf("End: %s\n", completion.value().toString(globalObject->globalExec()).ascii());
    401         }
    402 
    403         globalData->stopSampling();
    404         globalObject->globalExec()->clearException();
    405     }
    406 
    407 #if ENABLE(SAMPLING_FLAGS)
    408     SamplingFlags::stop();
    409 #endif
    410     globalData->dumpSampleData(globalObject->globalExec());
    411 #if ENABLE(SAMPLING_COUNTERS)
    412     AbstractSamplingCounter::dump();
    413 #endif
    414     return success;
    415 }
    416 
    417 #define RUNNING_FROM_XCODE 0
    418 
    419 static void runInteractive(GlobalObject* globalObject)
    420 {
    421     while (true) {
    422 #if HAVE(READLINE) && !RUNNING_FROM_XCODE
    423         char* line = readline(interactivePrompt);
    424         if (!line)
    425             break;
    426         if (line[0])
    427             add_history(line);
    428         Completion completion = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(line, interpreterName));
    429         free(line);
    430 #else
    431         printf("%s", interactivePrompt);
    432         Vector<char, 256> line;
    433         int c;
    434         while ((c = getchar()) != EOF) {
    435             // FIXME: Should we also break on \r?
    436             if (c == '\n')
    437                 break;
    438             line.append(c);
    439         }
    440         if (line.isEmpty())
    441             break;
    442         line.append('\0');
    443         Completion completion = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(line.data(), interpreterName));
    444 #endif
    445         if (completion.complType() == Throw)
    446             printf("Exception: %s\n", completion.value().toString(globalObject->globalExec()).ascii());
    447         else
    448             printf("%s\n", completion.value().toString(globalObject->globalExec()).UTF8String().c_str());
    449 
    450         globalObject->globalExec()->clearException();
    451     }
    452     printf("\n");
    453 }
    454 
    455 static NO_RETURN void printUsageStatement(JSGlobalData* globalData, bool help = false)
    456 {
    457     fprintf(stderr, "Usage: jsc [options] [files] [-- arguments]\n");
    458     fprintf(stderr, "  -d         Dumps bytecode (debug builds only)\n");
    459     fprintf(stderr, "  -e         Evaluate argument as script code\n");
    460     fprintf(stderr, "  -f         Specifies a source file (deprecated)\n");
    461     fprintf(stderr, "  -h|--help  Prints this help message\n");
    462     fprintf(stderr, "  -i         Enables interactive mode (default if no files are specified)\n");
    463 #if HAVE(SIGNAL_H)
    464     fprintf(stderr, "  -s         Installs signal handlers that exit on a crash (Unix platforms only)\n");
    465 #endif
    466 
    467     cleanupGlobalData(globalData);
    468     exit(help ? EXIT_SUCCESS : EXIT_FAILURE);
    469 }
    470 
    471 static void parseArguments(int argc, char** argv, Options& options, JSGlobalData* globalData)
    472 {
    473     int i = 1;
    474     for (; i < argc; ++i) {
    475         const char* arg = argv[i];
    476         if (!strcmp(arg, "-f")) {
    477             if (++i == argc)
    478                 printUsageStatement(globalData);
    479             options.scripts.append(Script(true, argv[i]));
    480             continue;
    481         }
    482         if (!strcmp(arg, "-e")) {
    483             if (++i == argc)
    484                 printUsageStatement(globalData);
    485             options.scripts.append(Script(false, argv[i]));
    486             continue;
    487         }
    488         if (!strcmp(arg, "-i")) {
    489             options.interactive = true;
    490             continue;
    491         }
    492         if (!strcmp(arg, "-d")) {
    493             options.dump = true;
    494             continue;
    495         }
    496         if (!strcmp(arg, "-s")) {
    497 #if HAVE(SIGNAL_H)
    498             signal(SIGILL, _exit);
    499             signal(SIGFPE, _exit);
    500             signal(SIGBUS, _exit);
    501             signal(SIGSEGV, _exit);
    502 #endif
    503             continue;
    504         }
    505         if (!strcmp(arg, "--")) {
    506             ++i;
    507             break;
    508         }
    509         if (!strcmp(arg, "-h") || !strcmp(arg, "--help"))
    510             printUsageStatement(globalData, true);
    511         options.scripts.append(Script(true, argv[i]));
    512     }
    513 
    514     if (options.scripts.isEmpty())
    515         options.interactive = true;
    516 
    517     for (; i < argc; ++i)
    518         options.arguments.append(argv[i]);
    519 }
    520 
    521 int jscmain(int argc, char** argv, JSGlobalData* globalData)
    522 {
    523     JSLock lock(SilenceAssertionsOnly);
    524 
    525     Options options;
    526     parseArguments(argc, argv, options, globalData);
    527 
    528     GlobalObject* globalObject = new (globalData) GlobalObject(options.arguments);
    529     bool success = runWithScripts(globalObject, options.scripts, options.dump);
    530     if (options.interactive && success)
    531         runInteractive(globalObject);
    532 
    533     return success ? 0 : 3;
    534 }
    535 
    536 static bool fillBufferWithContentsOfFile(const UString& fileName, Vector<char>& buffer)
    537 {
    538     FILE* f = fopen(fileName.UTF8String().c_str(), "r");
    539     if (!f) {
    540         fprintf(stderr, "Could not open file: %s\n", fileName.UTF8String().c_str());
    541         return false;
    542     }
    543 
    544     size_t bufferSize = 0;
    545     size_t bufferCapacity = 1024;
    546 
    547     buffer.resize(bufferCapacity);
    548 
    549     while (!feof(f) && !ferror(f)) {
    550         bufferSize += fread(buffer.data() + bufferSize, 1, bufferCapacity - bufferSize, f);
    551         if (bufferSize == bufferCapacity) { // guarantees space for trailing '\0'
    552             bufferCapacity *= 2;
    553             buffer.resize(bufferCapacity);
    554         }
    555     }
    556     fclose(f);
    557     buffer[bufferSize] = '\0';
    558 
    559     return true;
    560 }
    561