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