jsc.cpp

   1 /*
   2  *  Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
   3  *  Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
   4  *  Copyright (C) 2006 Bjoern Graf (bjoern.graf@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 "InitializeThreading.h"
  28 #include "JSArray.h"
  29 #include "JSLock.h"
  30 #include "PrototypeFunction.h"
  31 #include "SamplingTool.h"
  32 #include <math.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <string.h>
  36
  37 #if !PLATFORM(WIN_OS)
  38 #include <unistd.h>
  39 #endif
  40
  41 #if HAVE(READLINE)
  42 #include <readline/history.h>
  43 #include <readline/readline.h>
  44 #endif
  45
  46 #if HAVE(SYS_TIME_H)
  47 #include <sys/time.h>
  48 #endif
  49
  50 #if PLATFORM(UNIX)
  51 #include <signal.h>
  52 #endif
  53
  54 #if COMPILER(MSVC) && !PLATFORM(WIN_CE)
  55 #include <crtdbg.h>
  56 #include <windows.h>
  57 #endif
  58
  59 #if PLATFORM(QT)
  60 #include <QCoreApplication>
  61 #include <QDateTime>
  62 #endif
  63
  64 using namespace JSC;
  65 using namespace WTF;
  66
  67 static void cleanupGlobalData(JSGlobalData*);
  68 static bool fillBufferWithContentsOfFile(const UString& fileName, Vector<char>& buffer);
  69
  70 static JSValuePtr functionPrint(ExecState*, JSObject*, JSValuePtr, const ArgList&);
  71 static JSValuePtr functionDebug(ExecState*, JSObject*, JSValuePtr, const ArgList&);
  72 static JSValuePtr functionGC(ExecState*, JSObject*, JSValuePtr, const ArgList&);
  73 static JSValuePtr functionVersion(ExecState*, JSObject*, JSValuePtr, const ArgList&);
  74 static JSValuePtr functionRun(ExecState*, JSObject*, JSValuePtr, const ArgList&);
  75 static JSValuePtr functionLoad(ExecState*, JSObject*, JSValuePtr, const ArgList&);
  76 static JSValuePtr functionReadline(ExecState*, JSObject*, JSValuePtr, const ArgList&);
  77 static NO_RETURN JSValuePtr functionQuit(ExecState*, JSObject*, JSValuePtr, const ArgList&);
  78
  79 struct Options {
  80     Options()
  81         : interactive(false)
  82         , dump(false)
  83     {
  84     }
  85
  86     bool interactive;
  87     bool dump;
  88     Vector<UString> fileNames;
  89     Vector<UString> arguments;
  90 };
  91
  92 static const char interactivePrompt[] = "> ";
  93 static const UString interpreterName("Interpreter");
  94
  95 class StopWatch {
  96 public:
  97     void start();
  98     void stop();
  99     long getElapsedMS(); // call stop() first
 100
 101 private:
 102 #if PLATFORM(QT)
 103     uint m_startTime;
 104     uint m_stopTime;
 105 #elif PLATFORM(WIN_OS)
 106     DWORD m_startTime;
 107     DWORD m_stopTime;
 108 #else
 109     // Windows does not have timeval, disabling this class for now (bug 7399)
 110     timeval m_startTime;
 111     timeval m_stopTime;
 112 #endif
 113 };
 114
 115 void StopWatch::start()
 116 {
 117 #if PLATFORM(QT)
 118     QDateTime t = QDateTime::currentDateTime();
 119     m_startTime = t.toTime_t() * 1000 + t.time().msec();
 120 #elif PLATFORM(WIN_OS)
 121     m_startTime = timeGetTime();
 122 #else
 123     gettimeofday(&m_startTime, 0);
 124 #endif
 125 }
 126
 127 void StopWatch::stop()
 128 {
 129 #if PLATFORM(QT)
 130     QDateTime t = QDateTime::currentDateTime();
 131     m_stopTime = t.toTime_t() * 1000 + t.time().msec();
 132 #elif PLATFORM(WIN_OS)
 133     m_stopTime = timeGetTime();
 134 #else
 135     gettimeofday(&m_stopTime, 0);
 136 #endif
 137 }
 138
 139 long StopWatch::getElapsedMS()
 140 {
 141 #if PLATFORM(WIN_OS) || PLATFORM(QT)
 142     return m_stopTime - m_startTime;
 143 #else
 144     timeval elapsedTime;
 145     timersub(&m_stopTime, &m_startTime, &elapsedTime);
 146
 147     return elapsedTime.tv_sec * 1000 + lroundf(elapsedTime.tv_usec / 1000.0f);
 148 #endif
 149 }
 150
 151 class GlobalObject : public JSGlobalObject {
 152 public:
 153     GlobalObject(const Vector<UString>& arguments);
 154     virtual UString className() const { return "global"; }
 155 };
 156 COMPILE_ASSERT(!IsInteger<GlobalObject>::value, WTF_IsInteger_GlobalObject_false);
 157 ASSERT_CLASS_FITS_IN_CELL(GlobalObject);
 158
 159 GlobalObject::GlobalObject(const Vector<UString>& arguments)
 160     : JSGlobalObject()
 161 {
 162     putDirectFunction(globalExec(), new (globalExec()) PrototypeFunction(globalExec(), prototypeFunctionStructure(), 1, Identifier(globalExec(), "debug"), functionDebug));
 163     putDirectFunction(globalExec(), new (globalExec()) PrototypeFunction(globalExec(), prototypeFunctionStructure(), 1, Identifier(globalExec(), "print"), functionPrint));
 164     putDirectFunction(globalExec(), new (globalExec()) PrototypeFunction(globalExec(), prototypeFunctionStructure(), 0, Identifier(globalExec(), "quit"), functionQuit));
 165     putDirectFunction(globalExec(), new (globalExec()) PrototypeFunction(globalExec(), prototypeFunctionStructure(), 0, Identifier(globalExec(), "gc"), functionGC));
 166     putDirectFunction(globalExec(), new (globalExec()) PrototypeFunction(globalExec(), prototypeFunctionStructure(), 1, Identifier(globalExec(), "version"), functionVersion));
 167     putDirectFunction(globalExec(), new (globalExec()) PrototypeFunction(globalExec(), prototypeFunctionStructure(), 1, Identifier(globalExec(), "run"), functionRun));
 168     putDirectFunction(globalExec(), new (globalExec()) PrototypeFunction(globalExec(), prototypeFunctionStructure(), 1, Identifier(globalExec(), "load"), functionLoad));
 169     putDirectFunction(globalExec(), new (globalExec()) PrototypeFunction(globalExec(), prototypeFunctionStructure(), 0, Identifier(globalExec(), "readline"), functionReadline));
 170
 171     JSObject* array = constructEmptyArray(globalExec());
 172     for (size_t i = 0; i < arguments.size(); ++i)
 173         array->put(globalExec(), i, jsString(globalExec(), arguments[i]));
 174     putDirect(Identifier(globalExec(), "arguments"), array);
 175 }
 176
 177 JSValuePtr functionPrint(ExecState* exec, JSObject*, JSValuePtr, const ArgList& args)
 178 {
 179     for (unsigned i = 0; i < args.size(); ++i) {
 180         if (i != 0)
 181             putchar(' ');
 182
 183         printf("%s", args.at(exec, i).toString(exec).UTF8String().c_str());
 184     }
 185
 186     putchar('\n');
 187     fflush(stdout);
 188     return jsUndefined();
 189 }
 190
 191 JSValuePtr functionDebug(ExecState* exec, JSObject*, JSValuePtr, const ArgList& args)
 192 {
 193     fprintf(stderr, "--> %s\n", args.at(exec, 0).toString(exec).UTF8String().c_str());
 194     return jsUndefined();
 195 }
 196
 197 JSValuePtr functionGC(ExecState* exec, JSObject*, JSValuePtr, const ArgList&)
 198 {
 199     JSLock lock(false);
 200     exec->heap()->collect();
 201     return jsUndefined();
 202 }
 203
 204 JSValuePtr functionVersion(ExecState*, JSObject*, JSValuePtr, const ArgList&)
 205 {
 206     // We need this function for compatibility with the Mozilla JS tests but for now
 207     // we don't actually do any version-specific handling
 208     return jsUndefined();
 209 }
 210
 211 JSValuePtr functionRun(ExecState* exec, JSObject*, JSValuePtr, const ArgList& args)
 212 {
 213     StopWatch stopWatch;
 214     UString fileName = args.at(exec, 0).toString(exec);
 215     Vector<char> script;
 216     if (!fillBufferWithContentsOfFile(fileName, script))
 217         return throwError(exec, GeneralError, "Could not open file.");
 218
 219     JSGlobalObject* globalObject = exec->lexicalGlobalObject();
 220
 221     stopWatch.start();
 222     evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName));
 223     stopWatch.stop();
 224
 225     return jsNumber(globalObject->globalExec(), stopWatch.getElapsedMS());
 226 }
 227
 228 JSValuePtr functionLoad(ExecState* exec, JSObject*, JSValuePtr, const ArgList& args)
 229 {
 230     UString fileName = args.at(exec, 0).toString(exec);
 231     Vector<char> script;
 232     if (!fillBufferWithContentsOfFile(fileName, script))
 233         return throwError(exec, GeneralError, "Could not open file.");
 234
 235     JSGlobalObject* globalObject = exec->lexicalGlobalObject();
 236     evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName));
 237
 238     return jsUndefined();
 239 }
 240
 241 JSValuePtr functionReadline(ExecState* exec, JSObject*, JSValuePtr, const ArgList&)
 242 {
 243     Vector<char, 256> line;
 244     int c;
 245     while ((c = getchar()) != EOF) {
 246         // FIXME: Should we also break on \r?
 247         if (c == '\n')
 248             break;
 249         line.append(c);
 250     }
 251     line.append('\0');
 252     return jsString(exec, line.data());
 253 }
 254
 255 JSValuePtr functionQuit(ExecState* exec, JSObject*, JSValuePtr, const ArgList&)
 256 {
 257     cleanupGlobalData(&exec->globalData());
 258     exit(EXIT_SUCCESS);
 259 }
 260
 261 // Use SEH for Release builds only to get rid of the crash report dialog
 262 // (luckily the same tests fail in Release and Debug builds so far). Need to
 263 // be in a separate main function because the jscmain function requires object
 264 // unwinding.
 265
 266 #if COMPILER(MSVC) && !defined(_DEBUG)
 267 #define TRY       __try {
 268 #define EXCEPT(x) } __except (EXCEPTION_EXECUTE_HANDLER) { x; }
 269 #else
 270 #define TRY
 271 #define EXCEPT(x)
 272 #endif
 273
 274 int jscmain(int argc, char** argv, JSGlobalData*);
 275
 276 int main(int argc, char** argv)
 277 {
 278 #if defined(_DEBUG) && PLATFORM(WIN_OS)
 279     _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
 280     _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
 281     _CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
 282     _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
 283     _CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
 284     _CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
 285 #endif
 286
 287 #if PLATFORM(QT)
 288     QCoreApplication app(argc, argv);
 289 #endif
 290
 291     // Initialize JSC before getting JSGlobalData.
 292     JSC::initializeThreading();
 293
 294     // We can't use destructors in the following code because it uses Windows
 295     // Structured Exception Handling
 296     int res = 0;
 297     JSGlobalData* globalData = JSGlobalData::create().releaseRef();
 298     TRY
 299         res = jscmain(argc, argv, globalData);
 300     EXCEPT(res = 3)
 301
 302     cleanupGlobalData(globalData);
 303     return res;
 304 }
 305
 306 static void cleanupGlobalData(JSGlobalData* globalData)
 307 {
 308     JSLock lock(false);
 309     globalData->heap.destroy();
 310     globalData->deref();
 311 }
 312
 313 static bool runWithScripts(GlobalObject* globalObject, const Vector<UString>& fileNames, bool dump)
 314 {
 315     Vector<char> script;
 316
 317     if (dump)
 318         BytecodeGenerator::setDumpsGeneratedCode(true);
 319
 320 #if ENABLE(OPCODE_SAMPLING)
 321     Interpreter* interpreter = globalObject->globalData()->interpreter;
 322     interpreter->setSampler(new SamplingTool(interpreter));
 323 #endif
 324
 325     bool success = true;
 326     for (size_t i = 0; i < fileNames.size(); i++) {
 327         UString fileName = fileNames[i];
 328
 329         if (!fillBufferWithContentsOfFile(fileName, script))
 330             return false; // fail early so we can catch missing files
 331
 332 #if ENABLE(OPCODE_SAMPLING)
 333         interpreter->sampler()->start();
 334 #endif
 335         Completion completion = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName));
 336         success = success && completion.complType() != Throw;
 337         if (dump) {
 338             if (completion.complType() == Throw)
 339                 printf("Exception: %s\n", completion.value().toString(globalObject->globalExec()).ascii());
 340             else
 341                 printf("End: %s\n", completion.value().toString(globalObject->globalExec()).ascii());
 342         }
 343
 344         globalObject->globalExec()->clearException();
 345
 346 #if ENABLE(OPCODE_SAMPLING)
 347         interpreter->sampler()->stop();
 348 #endif
 349     }
 350
 351 #if ENABLE(OPCODE_SAMPLING)
 352     interpreter->sampler()->dump(globalObject->globalExec());
 353     delete interpreter->sampler();
 354 #endif
 355     return success;
 356 }
 357
 358 static void runInteractive(GlobalObject* globalObject)
 359 {
 360     while (true) {
 361 #if HAVE(READLINE)
 362         char* line = readline(interactivePrompt);
 363         if (!line)
 364             break;
 365         if (line[0])
 366             add_history(line);
 367         Completion completion = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(line, interpreterName));
 368         free(line);
 369 #else
 370         puts(interactivePrompt);
 371         Vector<char, 256> line;
 372         int c;
 373         while ((c = getchar()) != EOF) {
 374             // FIXME: Should we also break on \r?
 375             if (c == '\n')
 376                 break;
 377             line.append(c);
 378         }
 379         line.append('\0');
 380         Completion completion = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(line.data(), interpreterName));
 381 #endif
 382         if (completion.complType() == Throw)
 383             printf("Exception: %s\n", completion.value().toString(globalObject->globalExec()).ascii());
 384         else
 385             printf("%s\n", completion.value().toString(globalObject->globalExec()).UTF8String().c_str());
 386
 387         globalObject->globalExec()->clearException();
 388     }
 389     printf("\n");
 390 }
 391
 392 static NO_RETURN void printUsageStatement()
 393 {
 394     fprintf(stderr, "Usage: jsc [options] [files] [-- arguments]\n");
 395     fprintf(stderr, "  -d         Dumps bytecode (debug builds only)\n");
 396     fprintf(stderr, "  -f         Specifies a source file (deprecated)\n");
 397     fprintf(stderr, "  -h|--help  Prints this help message\n");
 398     fprintf(stderr, "  -i         Enables interactive mode (default if no files are specified)\n");
 399     fprintf(stderr, "  -s         Installs signal handlers that exit on a crash (Unix platforms only)\n");
 400     exit(EXIT_FAILURE);
 401 }
 402
 403 static void parseArguments(int argc, char** argv, Options& options)
 404 {
 405     int i = 1;
 406     for (; i < argc; ++i) {
 407         const char* arg = argv[i];
 408         if (strcmp(arg, "-f") == 0) {
 409             if (++i == argc)
 410                 printUsageStatement();
 411             options.fileNames.append(argv[i]);
 412             continue;
 413         }
 414         if (strcmp(arg, "-h") == 0 || strcmp(arg, "--help") == 0) {
 415             printUsageStatement();
 416         }
 417         if (strcmp(arg, "-i") == 0) {
 418             options.interactive = true;
 419             continue;
 420         }
 421         if (strcmp(arg, "-d") == 0) {
 422             options.dump = true;
 423             continue;
 424         }
 425         if (strcmp(arg, "-s") == 0) {
 426 #if PLATFORM(UNIX)
 427             signal(SIGILL, _exit);
 428             signal(SIGFPE, _exit);
 429             signal(SIGBUS, _exit);
 430             signal(SIGSEGV, _exit);
 431 #endif
 432             continue;
 433         }
 434         if (strcmp(arg, "--") == 0) {
 435             ++i;
 436             break;
 437         }
 438         options.fileNames.append(argv[i]);
 439     }
 440
 441     if (options.fileNames.isEmpty())
 442         options.interactive = true;
 443
 444     for (; i < argc; ++i)
 445         options.arguments.append(argv[i]);
 446 }
 447
 448 int jscmain(int argc, char** argv, JSGlobalData* globalData)
 449 {
 450     JSLock lock(false);
 451
 452     Options options;
 453     parseArguments(argc, argv, options);
 454
 455     GlobalObject* globalObject = new (globalData) GlobalObject(options.arguments);
 456     bool success = runWithScripts(globalObject, options.fileNames, options.dump);
 457     if (options.interactive && success)
 458         runInteractive(globalObject);
 459
 460     return success ? 0 : 3;
 461 }
 462
 463 static bool fillBufferWithContentsOfFile(const UString& fileName, Vector<char>& buffer)
 464 {
 465     FILE* f = fopen(fileName.UTF8String().c_str(), "r");
 466     if (!f) {
 467         fprintf(stderr, "Could not open file: %s\n", fileName.UTF8String().c_str());
 468         return false;
 469     }
 470
 471     size_t buffer_size = 0;
 472     size_t buffer_capacity = 1024;
 473
 474     buffer.resize(buffer_capacity);
 475
 476     while (!feof(f) && !ferror(f)) {
 477         buffer_size += fread(buffer.data() + buffer_size, 1, buffer_capacity - buffer_size, f);
 478         if (buffer_size == buffer_capacity) { // guarantees space for trailing '\0'
 479             buffer_capacity *= 2;
 480             buffer.resize(buffer_capacity);
 481         }
 482     }
 483     fclose(f);
 484     buffer[buffer_size] = '\0';
 485
 486     return true;
 487 }