/*
* Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
- * Copyright (C) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.
+ * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2012 Apple Inc. All rights reserved.
* Copyright (C) 2006 Bjoern Graf (bjoern.graf@gmail.com)
*
* This library is free software; you can redistribute it and/or
#include "config.h"
+#include "APIShims.h"
+#include "ButterflyInlines.h"
#include "BytecodeGenerator.h"
#include "Completion.h"
+#include "CopiedSpaceInlines.h"
+#include "ExceptionHelpers.h"
+#include "HeapStatistics.h"
#include "InitializeThreading.h"
+#include "Interpreter.h"
#include "JSArray.h"
+#include "JSCTypedArrayStubs.h"
+#include "JSFunction.h"
#include "JSLock.h"
-#include "PrototypeFunction.h"
+#include "JSProxy.h"
+#include "JSString.h"
+#include "Operations.h"
#include "SamplingTool.h"
+#include "StructureRareDataInlines.h"
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <wtf/CurrentTime.h>
+#include <wtf/MainThread.h>
+#include <wtf/StringPrintStream.h>
+#include <wtf/text/StringBuilder.h>
-#if !PLATFORM(WIN_OS)
+#if !OS(WINDOWS)
#include <unistd.h>
#endif
#if HAVE(READLINE)
+// readline/history.h has a Function typedef which conflicts with the WTF::Function template from WTF/Forward.h
+// We #define it to something else to avoid this conflict.
+#define Function ReadlineFunction
#include <readline/history.h>
#include <readline/readline.h>
+#undef Function
#endif
#if HAVE(SYS_TIME_H)
#include <sys/time.h>
#endif
-#if PLATFORM(UNIX)
+#if HAVE(SIGNAL_H)
#include <signal.h>
#endif
-#if COMPILER(MSVC) && !PLATFORM(WIN_CE)
+#if COMPILER(MSVC) && !OS(WINCE)
#include <crtdbg.h>
+#include <mmsystem.h>
#include <windows.h>
#endif
#include <QDateTime>
#endif
+#if PLATFORM(IOS) && CPU(ARM_THUMB2)
+#include <fenv.h>
+#include <arm/arch.h>
+#endif
+
+#if PLATFORM(BLACKBERRY)
+#include <BlackBerryPlatformLog.h>
+#endif
+
+#if PLATFORM(EFL)
+#include <Ecore.h>
+#endif
+
using namespace JSC;
using namespace WTF;
-static void cleanupGlobalData(JSGlobalData*);
-static bool fillBufferWithContentsOfFile(const UString& fileName, Vector<char>& buffer);
-
-static JSValuePtr functionPrint(ExecState*, JSObject*, JSValuePtr, const ArgList&);
-static JSValuePtr functionDebug(ExecState*, JSObject*, JSValuePtr, const ArgList&);
-static JSValuePtr functionGC(ExecState*, JSObject*, JSValuePtr, const ArgList&);
-static JSValuePtr functionVersion(ExecState*, JSObject*, JSValuePtr, const ArgList&);
-static JSValuePtr functionRun(ExecState*, JSObject*, JSValuePtr, const ArgList&);
-static JSValuePtr functionLoad(ExecState*, JSObject*, JSValuePtr, const ArgList&);
-static JSValuePtr functionReadline(ExecState*, JSObject*, JSValuePtr, const ArgList&);
-static NO_RETURN JSValuePtr functionQuit(ExecState*, JSObject*, JSValuePtr, const ArgList&);
-
-struct Options {
- Options()
- : interactive(false)
- , dump(false)
+static bool fillBufferWithContentsOfFile(const String& fileName, Vector<char>& buffer);
+
+static EncodedJSValue JSC_HOST_CALL functionPrint(ExecState*);
+static EncodedJSValue JSC_HOST_CALL functionDebug(ExecState*);
+static EncodedJSValue JSC_HOST_CALL functionDescribe(ExecState*);
+static EncodedJSValue JSC_HOST_CALL functionJSCStack(ExecState*);
+static EncodedJSValue JSC_HOST_CALL functionGC(ExecState*);
+#ifndef NDEBUG
+static EncodedJSValue JSC_HOST_CALL functionReleaseExecutableMemory(ExecState*);
+static EncodedJSValue JSC_HOST_CALL functionDumpCallFrame(ExecState*);
+#endif
+static EncodedJSValue JSC_HOST_CALL functionVersion(ExecState*);
+static EncodedJSValue JSC_HOST_CALL functionRun(ExecState*);
+static EncodedJSValue JSC_HOST_CALL functionLoad(ExecState*);
+static EncodedJSValue JSC_HOST_CALL functionCheckSyntax(ExecState*);
+static EncodedJSValue JSC_HOST_CALL functionReadline(ExecState*);
+static EncodedJSValue JSC_HOST_CALL functionPreciseTime(ExecState*);
+static NO_RETURN_WITH_VALUE EncodedJSValue JSC_HOST_CALL functionQuit(ExecState*);
+
+#if ENABLE(SAMPLING_FLAGS)
+static EncodedJSValue JSC_HOST_CALL functionSetSamplingFlags(ExecState*);
+static EncodedJSValue JSC_HOST_CALL functionClearSamplingFlags(ExecState*);
+#endif
+
+struct Script {
+ bool isFile;
+ char* argument;
+
+ Script(bool isFile, char *argument)
+ : isFile(isFile)
+ , argument(argument)
+ {
+ }
+};
+
+class CommandLine {
+public:
+ CommandLine(int argc, char** argv)
+ : m_interactive(false)
+ , m_dump(false)
+ , m_exitCode(false)
+ , m_profile(false)
{
+ parseArguments(argc, argv);
}
- bool interactive;
- bool dump;
- Vector<UString> fileNames;
- Vector<UString> arguments;
+ bool m_interactive;
+ bool m_dump;
+ bool m_exitCode;
+ Vector<Script> m_scripts;
+ Vector<String> m_arguments;
+ bool m_profile;
+ String m_profilerOutput;
+
+ void parseArguments(int, char**);
};
-static const char interactivePrompt[] = "> ";
-static const UString interpreterName("Interpreter");
+static const char interactivePrompt[] = ">>> ";
class StopWatch {
public:
long getElapsedMS(); // call stop() first
private:
-#if PLATFORM(QT)
- uint m_startTime;
- uint m_stopTime;
-#elif PLATFORM(WIN_OS)
- DWORD m_startTime;
- DWORD m_stopTime;
-#else
- // Windows does not have timeval, disabling this class for now (bug 7399)
- timeval m_startTime;
- timeval m_stopTime;
-#endif
+ double m_startTime;
+ double m_stopTime;
};
void StopWatch::start()
{
-#if PLATFORM(QT)
- QDateTime t = QDateTime::currentDateTime();
- m_startTime = t.toTime_t() * 1000 + t.time().msec();
-#elif PLATFORM(WIN_OS)
- m_startTime = timeGetTime();
-#else
- gettimeofday(&m_startTime, 0);
-#endif
+ m_startTime = currentTime();
}
void StopWatch::stop()
{
-#if PLATFORM(QT)
- QDateTime t = QDateTime::currentDateTime();
- m_stopTime = t.toTime_t() * 1000 + t.time().msec();
-#elif PLATFORM(WIN_OS)
- m_stopTime = timeGetTime();
-#else
- gettimeofday(&m_stopTime, 0);
-#endif
+ m_stopTime = currentTime();
}
long StopWatch::getElapsedMS()
{
-#if PLATFORM(WIN_OS) || PLATFORM(QT)
- return m_stopTime - m_startTime;
-#else
- timeval elapsedTime;
- timersub(&m_stopTime, &m_startTime, &elapsedTime);
-
- return elapsedTime.tv_sec * 1000 + lroundf(elapsedTime.tv_usec / 1000.0f);
-#endif
+ return static_cast<long>((m_stopTime - m_startTime) * 1000);
}
class GlobalObject : public JSGlobalObject {
+private:
+ GlobalObject(VM&, Structure*);
+
public:
- GlobalObject(const Vector<UString>& arguments);
- virtual UString className() const { return "global"; }
+ typedef JSGlobalObject Base;
+
+ static GlobalObject* create(VM& vm, Structure* structure, const Vector<String>& arguments)
+ {
+ GlobalObject* object = new (NotNull, allocateCell<GlobalObject>(vm.heap)) GlobalObject(vm, structure);
+ object->finishCreation(vm, arguments);
+ vm.heap.addFinalizer(object, destroy);
+ object->setGlobalThis(vm, JSProxy::create(vm, JSProxy::createStructure(vm, object, object->prototype()), object));
+ return object;
+ }
+
+ static const bool needsDestruction = false;
+
+ static const ClassInfo s_info;
+ static const GlobalObjectMethodTable s_globalObjectMethodTable;
+
+ static Structure* createStructure(VM& vm, JSValue prototype)
+ {
+ return Structure::create(vm, 0, prototype, TypeInfo(GlobalObjectType, StructureFlags), &s_info);
+ }
+
+ static bool javaScriptExperimentsEnabled(const JSGlobalObject*) { return true; }
+
+protected:
+ void finishCreation(VM& vm, const Vector<String>& arguments)
+ {
+ Base::finishCreation(vm);
+
+ addFunction(vm, "debug", functionDebug, 1);
+ addFunction(vm, "describe", functionDescribe, 1);
+ addFunction(vm, "print", functionPrint, 1);
+ addFunction(vm, "quit", functionQuit, 0);
+ addFunction(vm, "gc", functionGC, 0);
+#ifndef NDEBUG
+ addFunction(vm, "dumpCallFrame", functionDumpCallFrame, 0);
+ addFunction(vm, "releaseExecutableMemory", functionReleaseExecutableMemory, 0);
+#endif
+ addFunction(vm, "version", functionVersion, 1);
+ addFunction(vm, "run", functionRun, 1);
+ addFunction(vm, "load", functionLoad, 1);
+ addFunction(vm, "checkSyntax", functionCheckSyntax, 1);
+ addFunction(vm, "jscStack", functionJSCStack, 1);
+ addFunction(vm, "readline", functionReadline, 0);
+ addFunction(vm, "preciseTime", functionPreciseTime, 0);
+#if ENABLE(SAMPLING_FLAGS)
+ addFunction(vm, "setSamplingFlags", functionSetSamplingFlags, 1);
+ addFunction(vm, "clearSamplingFlags", functionClearSamplingFlags, 1);
+#endif
+
+ addConstructableFunction(vm, "Uint8Array", constructJSUint8Array, 1);
+ addConstructableFunction(vm, "Uint8ClampedArray", constructJSUint8ClampedArray, 1);
+ addConstructableFunction(vm, "Uint16Array", constructJSUint16Array, 1);
+ addConstructableFunction(vm, "Uint32Array", constructJSUint32Array, 1);
+ addConstructableFunction(vm, "Int8Array", constructJSInt8Array, 1);
+ addConstructableFunction(vm, "Int16Array", constructJSInt16Array, 1);
+ addConstructableFunction(vm, "Int32Array", constructJSInt32Array, 1);
+ addConstructableFunction(vm, "Float32Array", constructJSFloat32Array, 1);
+ addConstructableFunction(vm, "Float64Array", constructJSFloat64Array, 1);
+
+ JSArray* array = constructEmptyArray(globalExec(), 0);
+ for (size_t i = 0; i < arguments.size(); ++i)
+ array->putDirectIndex(globalExec(), i, jsString(globalExec(), arguments[i]));
+ putDirect(vm, Identifier(globalExec(), "arguments"), array);
+ }
+
+ void addFunction(VM& vm, const char* name, NativeFunction function, unsigned arguments)
+ {
+ Identifier identifier(globalExec(), name);
+ putDirect(vm, identifier, JSFunction::create(globalExec(), this, arguments, identifier.string(), function));
+ }
+
+ void addConstructableFunction(VM& vm, const char* name, NativeFunction function, unsigned arguments)
+ {
+ Identifier identifier(globalExec(), name);
+ putDirect(vm, identifier, JSFunction::create(globalExec(), this, arguments, identifier.string(), function, NoIntrinsic, function));
+ }
};
+
COMPILE_ASSERT(!IsInteger<GlobalObject>::value, WTF_IsInteger_GlobalObject_false);
-ASSERT_CLASS_FITS_IN_CELL(GlobalObject);
-GlobalObject::GlobalObject(const Vector<UString>& arguments)
- : JSGlobalObject()
+const ClassInfo GlobalObject::s_info = { "global", &JSGlobalObject::s_info, 0, ExecState::globalObjectTable, CREATE_METHOD_TABLE(GlobalObject) };
+const GlobalObjectMethodTable GlobalObject::s_globalObjectMethodTable = { &allowsAccessFrom, &supportsProfiling, &supportsRichSourceInfo, &shouldInterruptScript, &javaScriptExperimentsEnabled
+#if PLATFORM(IOS)
+ , &shouldInterruptScriptBeforeTimeout
+#endif
+};
+
+
+GlobalObject::GlobalObject(VM& vm, Structure* structure)
+ : JSGlobalObject(vm, structure, &s_globalObjectMethodTable)
+{
+}
+
+static inline String stringFromUTF(const char* utf8)
+{
+ // Find the the first non-ascii character, or nul.
+ const char* pos = utf8;
+ while (*pos > 0)
+ pos++;
+ size_t asciiLength = pos - utf8;
+
+ // Fast case - string is all ascii.
+ if (!*pos)
+ return String(utf8, asciiLength);
+
+ // Slow case - contains non-ascii characters, use fromUTF8WithLatin1Fallback.
+ ASSERT(*pos < 0);
+ ASSERT(strlen(utf8) == asciiLength + strlen(pos));
+ return String::fromUTF8WithLatin1Fallback(utf8, asciiLength + strlen(pos));
+}
+
+static inline SourceCode jscSource(const char* utf8, const String& filename)
{
- putDirectFunction(globalExec(), new (globalExec()) PrototypeFunction(globalExec(), prototypeFunctionStructure(), 1, Identifier(globalExec(), "debug"), functionDebug));
- putDirectFunction(globalExec(), new (globalExec()) PrototypeFunction(globalExec(), prototypeFunctionStructure(), 1, Identifier(globalExec(), "print"), functionPrint));
- putDirectFunction(globalExec(), new (globalExec()) PrototypeFunction(globalExec(), prototypeFunctionStructure(), 0, Identifier(globalExec(), "quit"), functionQuit));
- putDirectFunction(globalExec(), new (globalExec()) PrototypeFunction(globalExec(), prototypeFunctionStructure(), 0, Identifier(globalExec(), "gc"), functionGC));
- putDirectFunction(globalExec(), new (globalExec()) PrototypeFunction(globalExec(), prototypeFunctionStructure(), 1, Identifier(globalExec(), "version"), functionVersion));
- putDirectFunction(globalExec(), new (globalExec()) PrototypeFunction(globalExec(), prototypeFunctionStructure(), 1, Identifier(globalExec(), "run"), functionRun));
- putDirectFunction(globalExec(), new (globalExec()) PrototypeFunction(globalExec(), prototypeFunctionStructure(), 1, Identifier(globalExec(), "load"), functionLoad));
- putDirectFunction(globalExec(), new (globalExec()) PrototypeFunction(globalExec(), prototypeFunctionStructure(), 0, Identifier(globalExec(), "readline"), functionReadline));
-
- JSObject* array = constructEmptyArray(globalExec());
- for (size_t i = 0; i < arguments.size(); ++i)
- array->put(globalExec(), i, jsString(globalExec(), arguments[i]));
- putDirect(Identifier(globalExec(), "arguments"), array);
+ String str = stringFromUTF(utf8);
+ return makeSource(str, filename);
}
-JSValuePtr functionPrint(ExecState* exec, JSObject*, JSValuePtr, const ArgList& args)
+EncodedJSValue JSC_HOST_CALL functionPrint(ExecState* exec)
{
- for (unsigned i = 0; i < args.size(); ++i) {
- if (i != 0)
+ for (unsigned i = 0; i < exec->argumentCount(); ++i) {
+ if (i)
putchar(' ');
-
- printf("%s", args.at(exec, i).toString(exec).UTF8String().c_str());
+
+ printf("%s", exec->argument(i).toString(exec)->value(exec).utf8().data());
}
-
+
putchar('\n');
fflush(stdout);
- return jsUndefined();
+ return JSValue::encode(jsUndefined());
}
-JSValuePtr functionDebug(ExecState* exec, JSObject*, JSValuePtr, const ArgList& args)
+#ifndef NDEBUG
+EncodedJSValue JSC_HOST_CALL functionDumpCallFrame(ExecState* exec)
{
- fprintf(stderr, "--> %s\n", args.at(exec, 0).toString(exec).UTF8String().c_str());
- return jsUndefined();
+ if (!exec->callerFrame()->hasHostCallFrameFlag())
+ exec->vm().interpreter->dumpCallFrame(exec->callerFrame());
+ return JSValue::encode(jsUndefined());
}
+#endif
-JSValuePtr functionGC(ExecState* exec, JSObject*, JSValuePtr, const ArgList&)
+EncodedJSValue JSC_HOST_CALL functionDebug(ExecState* exec)
{
- JSLock lock(false);
- exec->heap()->collect();
- return jsUndefined();
+ fprintf(stderr, "--> %s\n", exec->argument(0).toString(exec)->value(exec).utf8().data());
+ return JSValue::encode(jsUndefined());
}
-JSValuePtr functionVersion(ExecState*, JSObject*, JSValuePtr, const ArgList&)
+EncodedJSValue JSC_HOST_CALL functionDescribe(ExecState* exec)
+{
+ fprintf(stderr, "--> %s\n", toCString(exec->argument(0)).data());
+ return JSValue::encode(jsUndefined());
+}
+
+EncodedJSValue JSC_HOST_CALL functionJSCStack(ExecState* exec)
+{
+ StringBuilder trace;
+ trace.appendLiteral("--> Stack trace:\n");
+
+ Vector<StackFrame> stackTrace;
+ Interpreter::getStackTrace(&exec->vm(), stackTrace);
+ int i = 0;
+
+ for (Vector<StackFrame>::iterator iter = stackTrace.begin(); iter < stackTrace.end(); iter++) {
+ StackFrame level = *iter;
+ trace.append(String::format(" %i %s\n", i, level.toString(exec).utf8().data()));
+ i++;
+ }
+ fprintf(stderr, "%s", trace.toString().utf8().data());
+ return JSValue::encode(jsUndefined());
+}
+
+EncodedJSValue JSC_HOST_CALL functionGC(ExecState* exec)
+{
+ JSLockHolder lock(exec);
+ exec->heap()->collectAllGarbage();
+ return JSValue::encode(jsUndefined());
+}
+
+#ifndef NDEBUG
+EncodedJSValue JSC_HOST_CALL functionReleaseExecutableMemory(ExecState* exec)
+{
+ JSLockHolder lock(exec);
+ exec->vm().releaseExecutableMemory();
+ return JSValue::encode(jsUndefined());
+}
+#endif
+
+EncodedJSValue JSC_HOST_CALL functionVersion(ExecState*)
{
// We need this function for compatibility with the Mozilla JS tests but for now
// we don't actually do any version-specific handling
- return jsUndefined();
+ return JSValue::encode(jsUndefined());
}
-JSValuePtr functionRun(ExecState* exec, JSObject*, JSValuePtr, const ArgList& args)
+EncodedJSValue JSC_HOST_CALL functionRun(ExecState* exec)
{
- StopWatch stopWatch;
- UString fileName = args.at(exec, 0).toString(exec);
+ String fileName = exec->argument(0).toString(exec)->value(exec);
Vector<char> script;
if (!fillBufferWithContentsOfFile(fileName, script))
- return throwError(exec, GeneralError, "Could not open file.");
+ return JSValue::encode(throwError(exec, createError(exec, "Could not open file.")));
- JSGlobalObject* globalObject = exec->lexicalGlobalObject();
+ GlobalObject* globalObject = GlobalObject::create(exec->vm(), GlobalObject::createStructure(exec->vm(), jsNull()), Vector<String>());
+ JSValue exception;
+ StopWatch stopWatch;
stopWatch.start();
- evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName));
+ evaluate(globalObject->globalExec(), jscSource(script.data(), fileName), JSValue(), &exception);
stopWatch.stop();
- return jsNumber(globalObject->globalExec(), stopWatch.getElapsedMS());
+ if (!!exception) {
+ throwError(globalObject->globalExec(), exception);
+ return JSValue::encode(jsUndefined());
+ }
+
+ return JSValue::encode(jsNumber(stopWatch.getElapsedMS()));
+}
+
+EncodedJSValue JSC_HOST_CALL functionLoad(ExecState* exec)
+{
+ String fileName = exec->argument(0).toString(exec)->value(exec);
+ Vector<char> script;
+ if (!fillBufferWithContentsOfFile(fileName, script))
+ return JSValue::encode(throwError(exec, createError(exec, "Could not open file.")));
+
+ JSGlobalObject* globalObject = exec->lexicalGlobalObject();
+
+ JSValue evaluationException;
+ JSValue result = evaluate(globalObject->globalExec(), jscSource(script.data(), fileName), JSValue(), &evaluationException);
+ if (evaluationException)
+ throwError(exec, evaluationException);
+ return JSValue::encode(result);
}
-JSValuePtr functionLoad(ExecState* exec, JSObject*, JSValuePtr, const ArgList& args)
+EncodedJSValue JSC_HOST_CALL functionCheckSyntax(ExecState* exec)
{
- UString fileName = args.at(exec, 0).toString(exec);
+ String fileName = exec->argument(0).toString(exec)->value(exec);
Vector<char> script;
if (!fillBufferWithContentsOfFile(fileName, script))
- return throwError(exec, GeneralError, "Could not open file.");
+ return JSValue::encode(throwError(exec, createError(exec, "Could not open file.")));
JSGlobalObject* globalObject = exec->lexicalGlobalObject();
- evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName));
- return jsUndefined();
+ StopWatch stopWatch;
+ stopWatch.start();
+
+ JSValue syntaxException;
+ bool validSyntax = checkSyntax(globalObject->globalExec(), jscSource(script.data(), fileName), &syntaxException);
+ stopWatch.stop();
+
+ if (!validSyntax)
+ throwError(exec, syntaxException);
+ return JSValue::encode(jsNumber(stopWatch.getElapsedMS()));
+}
+
+#if ENABLE(SAMPLING_FLAGS)
+EncodedJSValue JSC_HOST_CALL functionSetSamplingFlags(ExecState* exec)
+{
+ for (unsigned i = 0; i < exec->argumentCount(); ++i) {
+ unsigned flag = static_cast<unsigned>(exec->argument(i).toNumber(exec));
+ if ((flag >= 1) && (flag <= 32))
+ SamplingFlags::setFlag(flag);
+ }
+ return JSValue::encode(jsNull());
+}
+
+EncodedJSValue JSC_HOST_CALL functionClearSamplingFlags(ExecState* exec)
+{
+ for (unsigned i = 0; i < exec->argumentCount(); ++i) {
+ unsigned flag = static_cast<unsigned>(exec->argument(i).toNumber(exec));
+ if ((flag >= 1) && (flag <= 32))
+ SamplingFlags::clearFlag(flag);
+ }
+ return JSValue::encode(jsNull());
}
+#endif
-JSValuePtr functionReadline(ExecState* exec, JSObject*, JSValuePtr, const ArgList&)
+EncodedJSValue JSC_HOST_CALL functionReadline(ExecState* exec)
{
Vector<char, 256> line;
int c;
line.append(c);
}
line.append('\0');
- return jsString(exec, line.data());
+ return JSValue::encode(jsString(exec, line.data()));
+}
+
+EncodedJSValue JSC_HOST_CALL functionPreciseTime(ExecState*)
+{
+ return JSValue::encode(jsNumber(currentTime()));
}
-JSValuePtr functionQuit(ExecState* exec, JSObject*, JSValuePtr, const ArgList&)
+EncodedJSValue JSC_HOST_CALL functionQuit(ExecState*)
{
- cleanupGlobalData(&exec->globalData());
exit(EXIT_SUCCESS);
+
+#if COMPILER(MSVC) && OS(WINCE)
+ // Without this, Visual Studio will complain that this method does not return a value.
+ return JSValue::encode(jsUndefined());
+#endif
}
// Use SEH for Release builds only to get rid of the crash report dialog
// be in a separate main function because the jscmain function requires object
// unwinding.
-#if COMPILER(MSVC) && !defined(_DEBUG)
+#if COMPILER(MSVC) && !COMPILER(INTEL) && !defined(_DEBUG) && !OS(WINCE)
#define TRY __try {
#define EXCEPT(x) } __except (EXCEPTION_EXECUTE_HANDLER) { x; }
#else
#define EXCEPT(x)
#endif
-int jscmain(int argc, char** argv, JSGlobalData*);
+int jscmain(int argc, char** argv);
int main(int argc, char** argv)
{
-#if defined(_DEBUG) && PLATFORM(WIN_OS)
+#if PLATFORM(IOS) && CPU(ARM_THUMB2)
+ // Enabled IEEE754 denormal support.
+ fenv_t env;
+ fegetenv( &env );
+ env.__fpscr &= ~0x01000000u;
+ fesetenv( &env );
+#endif
+
+#if OS(WINDOWS)
+#if !OS(WINCE)
+ // Cygwin calls ::SetErrorMode(SEM_FAILCRITICALERRORS), which we will inherit. This is bad for
+ // testing/debugging, as it causes the post-mortem debugger not to be invoked. We reset the
+ // error mode here to work around Cygwin's behavior. See <http://webkit.org/b/55222>.
+ ::SetErrorMode(0);
+#endif
+
+#if defined(_DEBUG)
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
#endif
+ timeBeginPeriod(1);
+#endif
+
+#if PLATFORM(BLACKBERRY)
+ // Write all WTF logs to the system log
+ BlackBerry::Platform::setupApplicationLogging("jsc");
+#endif
+
#if PLATFORM(QT)
QCoreApplication app(argc, argv);
#endif
- // Initialize JSC before getting JSGlobalData.
+#if PLATFORM(EFL)
+ ecore_init();
+#endif
+
+ // Initialize JSC before getting VM.
+ WTF::initializeMainThread();
JSC::initializeThreading();
+#if PLATFORM(IOS)
+ Options::crashIfCantAllocateJITMemory() = true;
+#endif
+
// We can't use destructors in the following code because it uses Windows
// Structured Exception Handling
int res = 0;
- JSGlobalData* globalData = JSGlobalData::create().releaseRef();
TRY
- res = jscmain(argc, argv, globalData);
+ res = jscmain(argc, argv);
EXCEPT(res = 3)
+ if (Options::logHeapStatisticsAtExit())
+ HeapStatistics::reportSuccess();
+
+#if PLATFORM(EFL)
+ ecore_shutdown();
+#endif
- cleanupGlobalData(globalData);
return res;
}
-static void cleanupGlobalData(JSGlobalData* globalData)
+static bool runWithScripts(GlobalObject* globalObject, const Vector<Script>& scripts, bool dump)
{
- JSLock lock(false);
- globalData->heap.destroy();
- globalData->deref();
-}
-
-static bool runWithScripts(GlobalObject* globalObject, const Vector<UString>& fileNames, bool dump)
-{
- Vector<char> script;
+ const char* script;
+ String fileName;
+ Vector<char> scriptBuffer;
if (dump)
- BytecodeGenerator::setDumpsGeneratedCode(true);
+ JSC::Options::dumpGeneratedBytecodes() = true;
+
+ VM& vm = globalObject->vm();
-#if ENABLE(OPCODE_SAMPLING)
- Interpreter* interpreter = globalObject->globalData()->interpreter;
- interpreter->setSampler(new SamplingTool(interpreter));
+#if ENABLE(SAMPLING_FLAGS)
+ SamplingFlags::start();
#endif
bool success = true;
- for (size_t i = 0; i < fileNames.size(); i++) {
- UString fileName = fileNames[i];
-
- if (!fillBufferWithContentsOfFile(fileName, script))
- return false; // fail early so we can catch missing files
-
-#if ENABLE(OPCODE_SAMPLING)
- interpreter->sampler()->start();
-#endif
- Completion completion = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName));
- success = success && completion.complType() != Throw;
- if (dump) {
- if (completion.complType() == Throw)
- printf("Exception: %s\n", completion.value().toString(globalObject->globalExec()).ascii());
- else
- printf("End: %s\n", completion.value().toString(globalObject->globalExec()).ascii());
+ for (size_t i = 0; i < scripts.size(); i++) {
+ if (scripts[i].isFile) {
+ fileName = scripts[i].argument;
+ if (!fillBufferWithContentsOfFile(fileName, scriptBuffer))
+ return false; // fail early so we can catch missing files
+ script = scriptBuffer.data();
+ } else {
+ script = scripts[i].argument;
+ fileName = "[Command Line]";
}
- globalObject->globalExec()->clearException();
+ vm.startSampling();
+
+ JSValue evaluationException;
+ JSValue returnValue = evaluate(globalObject->globalExec(), jscSource(script, fileName), JSValue(), &evaluationException);
+ success = success && !evaluationException;
+ if (dump && !evaluationException)
+ printf("End: %s\n", returnValue.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
+ if (evaluationException) {
+ printf("Exception: %s\n", evaluationException.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
+ Identifier stackID(globalObject->globalExec(), "stack");
+ JSValue stackValue = evaluationException.get(globalObject->globalExec(), stackID);
+ if (!stackValue.isUndefinedOrNull())
+ printf("%s\n", stackValue.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
+ }
-#if ENABLE(OPCODE_SAMPLING)
- interpreter->sampler()->stop();
-#endif
+ vm.stopSampling();
+ globalObject->globalExec()->clearException();
}
-#if ENABLE(OPCODE_SAMPLING)
- interpreter->sampler()->dump(globalObject->globalExec());
- delete interpreter->sampler();
+#if ENABLE(SAMPLING_FLAGS)
+ SamplingFlags::stop();
+#endif
+#if ENABLE(SAMPLING_REGIONS)
+ SamplingRegion::dump();
+#endif
+ vm.dumpSampleData(globalObject->globalExec());
+#if ENABLE(SAMPLING_COUNTERS)
+ AbstractSamplingCounter::dump();
+#endif
+#if ENABLE(REGEXP_TRACING)
+ vm.dumpRegExpTrace();
#endif
return success;
}
+#define RUNNING_FROM_XCODE 0
+
static void runInteractive(GlobalObject* globalObject)
{
- while (true) {
-#if HAVE(READLINE)
- char* line = readline(interactivePrompt);
- if (!line)
- break;
- if (line[0])
+ String interpreterName("Interpreter");
+
+ bool shouldQuit = false;
+ while (!shouldQuit) {
+#if HAVE(READLINE) && !RUNNING_FROM_XCODE
+ ParserError error;
+ String source;
+ do {
+ error = ParserError();
+ char* line = readline(source.isEmpty() ? interactivePrompt : "... ");
+ shouldQuit = !line;
+ if (!line)
+ break;
+ source = source + line;
+ source = source + '\n';
+ checkSyntax(globalObject->vm(), makeSource(source, interpreterName), error);
+ if (!line[0])
+ break;
add_history(line);
- Completion completion = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(line, interpreterName));
- free(line);
+ } while (error.m_syntaxErrorType == ParserError::SyntaxErrorRecoverable);
+
+ if (error.m_type != ParserError::ErrorNone) {
+ printf("%s:%d\n", error.m_message.utf8().data(), error.m_line);
+ continue;
+ }
+
+
+ JSValue evaluationException;
+ JSValue returnValue = evaluate(globalObject->globalExec(), makeSource(source, interpreterName), JSValue(), &evaluationException);
#else
- puts(interactivePrompt);
+ printf("%s", interactivePrompt);
Vector<char, 256> line;
int c;
while ((c = getchar()) != EOF) {
break;
line.append(c);
}
+ if (line.isEmpty())
+ break;
line.append('\0');
- Completion completion = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(line.data(), interpreterName));
+
+ JSValue evaluationException;
+ JSValue returnValue = evaluate(globalObject->globalExec(), jscSource(line.data(), interpreterName), JSValue(), &evaluationException);
#endif
- if (completion.complType() == Throw)
- printf("Exception: %s\n", completion.value().toString(globalObject->globalExec()).ascii());
+ if (evaluationException)
+ printf("Exception: %s\n", evaluationException.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
else
- printf("%s\n", completion.value().toString(globalObject->globalExec()).UTF8String().c_str());
+ printf("%s\n", returnValue.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
globalObject->globalExec()->clearException();
}
printf("\n");
}
-static NO_RETURN void printUsageStatement()
+static NO_RETURN void printUsageStatement(bool help = false)
{
fprintf(stderr, "Usage: jsc [options] [files] [-- arguments]\n");
fprintf(stderr, " -d Dumps bytecode (debug builds only)\n");
+ fprintf(stderr, " -e Evaluate argument as script code\n");
fprintf(stderr, " -f Specifies a source file (deprecated)\n");
fprintf(stderr, " -h|--help Prints this help message\n");
fprintf(stderr, " -i Enables interactive mode (default if no files are specified)\n");
+#if HAVE(SIGNAL_H)
fprintf(stderr, " -s Installs signal handlers that exit on a crash (Unix platforms only)\n");
- exit(EXIT_FAILURE);
+#endif
+ fprintf(stderr, " -p <file> Outputs profiling data to a file\n");
+ fprintf(stderr, " -x Output exit code before terminating\n");
+ fprintf(stderr, "\n");
+ fprintf(stderr, " --options Dumps all JSC VM options and exits\n");
+ fprintf(stderr, " --dumpOptions Dumps all JSC VM options before continuing\n");
+ fprintf(stderr, " --<jsc VM option>=<value> Sets the specified JSC VM option\n");
+ fprintf(stderr, "\n");
+
+ exit(help ? EXIT_SUCCESS : EXIT_FAILURE);
}
-static void parseArguments(int argc, char** argv, Options& options)
+void CommandLine::parseArguments(int argc, char** argv)
{
int i = 1;
+ bool needToDumpOptions = false;
+ bool needToExit = false;
+
for (; i < argc; ++i) {
const char* arg = argv[i];
- if (strcmp(arg, "-f") == 0) {
+ if (!strcmp(arg, "-f")) {
if (++i == argc)
printUsageStatement();
- options.fileNames.append(argv[i]);
+ m_scripts.append(Script(true, argv[i]));
continue;
}
- if (strcmp(arg, "-h") == 0 || strcmp(arg, "--help") == 0) {
- printUsageStatement();
+ if (!strcmp(arg, "-e")) {
+ if (++i == argc)
+ printUsageStatement();
+ m_scripts.append(Script(false, argv[i]));
+ continue;
}
- if (strcmp(arg, "-i") == 0) {
- options.interactive = true;
+ if (!strcmp(arg, "-i")) {
+ m_interactive = true;
continue;
}
- if (strcmp(arg, "-d") == 0) {
- options.dump = true;
+ if (!strcmp(arg, "-d")) {
+ m_dump = true;
continue;
}
- if (strcmp(arg, "-s") == 0) {
-#if PLATFORM(UNIX)
+ if (!strcmp(arg, "-p")) {
+ if (++i == argc)
+ printUsageStatement();
+ m_profile = true;
+ m_profilerOutput = argv[i];
+ continue;
+ }
+ if (!strcmp(arg, "-s")) {
+#if HAVE(SIGNAL_H)
signal(SIGILL, _exit);
signal(SIGFPE, _exit);
signal(SIGBUS, _exit);
#endif
continue;
}
- if (strcmp(arg, "--") == 0) {
+ if (!strcmp(arg, "-x")) {
+ m_exitCode = true;
+ continue;
+ }
+ if (!strcmp(arg, "--")) {
++i;
break;
}
- options.fileNames.append(argv[i]);
+ if (!strcmp(arg, "-h") || !strcmp(arg, "--help"))
+ printUsageStatement(true);
+
+ if (!strcmp(arg, "--options")) {
+ needToDumpOptions = true;
+ needToExit = true;
+ continue;
+ }
+ if (!strcmp(arg, "--dumpOptions")) {
+ needToDumpOptions = true;
+ continue;
+ }
+
+ // See if the -- option is a JSC VM option.
+ // NOTE: At this point, we know that the arg starts with "--". Skip it.
+ if (JSC::Options::setOption(&arg[2])) {
+ // The arg was recognized as a VM option and has been parsed.
+ continue; // Just continue with the next arg.
+ }
+
+ // This arg is not recognized by the VM nor by jsc. Pass it on to the
+ // script.
+ m_scripts.append(Script(true, argv[i]));
}
-
- if (options.fileNames.isEmpty())
- options.interactive = true;
-
+
+ if (m_scripts.isEmpty())
+ m_interactive = true;
+
for (; i < argc; ++i)
- options.arguments.append(argv[i]);
+ m_arguments.append(argv[i]);
+
+ if (needToDumpOptions)
+ JSC::Options::dumpAllOptions(stderr);
+ if (needToExit)
+ exit(EXIT_SUCCESS);
}
-int jscmain(int argc, char** argv, JSGlobalData* globalData)
+int jscmain(int argc, char** argv)
{
- JSLock lock(false);
+ // Note that the options parsing can affect VM creation, and thus
+ // comes first.
+ CommandLine options(argc, argv);
+ VM* vm = VM::create(LargeHeap).leakRef();
+ APIEntryShim shim(vm);
+ int result;
+
+ if (options.m_profile && !vm->m_perBytecodeProfiler)
+ vm->m_perBytecodeProfiler = adoptPtr(new Profiler::Database(*vm));
+
+ GlobalObject* globalObject = GlobalObject::create(*vm, GlobalObject::createStructure(*vm, jsNull()), options.m_arguments);
+ bool success = runWithScripts(globalObject, options.m_scripts, options.m_dump);
+ if (options.m_interactive && success)
+ runInteractive(globalObject);
- Options options;
- parseArguments(argc, argv, options);
+ result = success ? 0 : 3;
- GlobalObject* globalObject = new (globalData) GlobalObject(options.arguments);
- bool success = runWithScripts(globalObject, options.fileNames, options.dump);
- if (options.interactive && success)
- runInteractive(globalObject);
+ if (options.m_exitCode)
+ printf("jsc exiting %d\n", result);
+
+ if (options.m_profile) {
+ if (!vm->m_perBytecodeProfiler->save(options.m_profilerOutput.utf8().data()))
+ fprintf(stderr, "could not save profiler output.\n");
+ }
- return success ? 0 : 3;
+ return result;
}
-static bool fillBufferWithContentsOfFile(const UString& fileName, Vector<char>& buffer)
+static bool fillBufferWithContentsOfFile(const String& fileName, Vector<char>& buffer)
{
- FILE* f = fopen(fileName.UTF8String().c_str(), "r");
+ FILE* f = fopen(fileName.utf8().data(), "r");
if (!f) {
- fprintf(stderr, "Could not open file: %s\n", fileName.UTF8String().c_str());
+ fprintf(stderr, "Could not open file: %s\n", fileName.utf8().data());
return false;
}
- size_t buffer_size = 0;
- size_t buffer_capacity = 1024;
+ size_t bufferSize = 0;
+ size_t bufferCapacity = 1024;
- buffer.resize(buffer_capacity);
+ buffer.resize(bufferCapacity);
while (!feof(f) && !ferror(f)) {
- buffer_size += fread(buffer.data() + buffer_size, 1, buffer_capacity - buffer_size, f);
- if (buffer_size == buffer_capacity) { // guarantees space for trailing '\0'
- buffer_capacity *= 2;
- buffer.resize(buffer_capacity);
+ bufferSize += fread(buffer.data() + bufferSize, 1, bufferCapacity - bufferSize, f);
+ if (bufferSize == bufferCapacity) { // guarantees space for trailing '\0'
+ bufferCapacity *= 2;
+ buffer.resize(bufferCapacity);
}
}
fclose(f);
- buffer[buffer_size] = '\0';
+ buffer[bufferSize] = '\0';
+
+ if (buffer[0] == '#' && buffer[1] == '!')
+ buffer[0] = buffer[1] = '/';
return true;
}
projects / apple / javascriptcore.git / blobdiff