#include "BytecodeGenerator.h"
#include "Completion.h"
-#include "CurrentTime.h"
+#include <wtf/CurrentTime.h>
#include "ExceptionHelpers.h"
#include "InitializeThreading.h"
+#include "Interpreter.h"
#include "JSArray.h"
+#include "JSCTypedArrayStubs.h"
#include "JSFunction.h"
#include "JSLock.h"
#include "JSString.h"
+#include <wtf/MainThread.h>
#include "SamplingTool.h"
#include <math.h>
#include <stdio.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 <QDateTime>
#endif
+#if CPU(ARM_THUMB2)
+#include <fenv.h>
+#include <arm/arch.h>
+#endif
+
using namespace JSC;
using namespace WTF;
-static void cleanupGlobalData(JSGlobalData*);
static bool fillBufferWithContentsOfFile(const UString& fileName, Vector<char>& buffer);
static EncodedJSValue JSC_HOST_CALL functionPrint(ExecState*);
static EncodedJSValue JSC_HOST_CALL functionDebug(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 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)
}
};
-struct Options {
- Options()
+struct CommandLine {
+ CommandLine()
: interactive(false)
, dump(false)
{
};
static const char interactivePrompt[] = "> ";
-static const UString interpreterName("Interpreter");
class StopWatch {
public:
}
class GlobalObject : public JSGlobalObject {
+private:
+ GlobalObject(JSGlobalData&, Structure*);
+
public:
- GlobalObject(JSGlobalData&, Structure*, const Vector<UString>& arguments);
- virtual UString className() const { return "global"; }
+ typedef JSGlobalObject Base;
+
+ static GlobalObject* create(JSGlobalData& globalData, Structure* structure, const Vector<UString>& arguments)
+ {
+ GlobalObject* object = new (NotNull, allocateCell<GlobalObject>(globalData.heap)) GlobalObject(globalData, structure);
+ object->finishCreation(globalData, arguments);
+ return object;
+ }
+
+ static const ClassInfo s_info;
+
+ static Structure* createStructure(JSGlobalData& globalData, JSValue prototype)
+ {
+ return Structure::create(globalData, 0, prototype, TypeInfo(GlobalObjectType, StructureFlags), &s_info);
+ }
+
+protected:
+ void finishCreation(JSGlobalData& globalData, const Vector<UString>& arguments)
+ {
+ Base::finishCreation(globalData);
+
+ addFunction(globalData, "debug", functionDebug, 1);
+ addFunction(globalData, "print", functionPrint, 1);
+ addFunction(globalData, "quit", functionQuit, 0);
+ addFunction(globalData, "gc", functionGC, 0);
+#ifndef NDEBUG
+ addFunction(globalData, "releaseExecutableMemory", functionReleaseExecutableMemory, 0);
+#endif
+ addFunction(globalData, "version", functionVersion, 1);
+ addFunction(globalData, "run", functionRun, 1);
+ addFunction(globalData, "load", functionLoad, 1);
+ addFunction(globalData, "checkSyntax", functionCheckSyntax, 1);
+ addFunction(globalData, "jscStack", functionJSCStack, 1);
+ addFunction(globalData, "readline", functionReadline, 0);
+ addFunction(globalData, "preciseTime", functionPreciseTime, 0);
+#if ENABLE(SAMPLING_FLAGS)
+ addFunction(globalData, "setSamplingFlags", functionSetSamplingFlags, 1);
+ addFunction(globalData, "clearSamplingFlags", functionClearSamplingFlags, 1);
+#endif
+
+ addConstructableFunction(globalData, "Uint8Array", constructJSUint8Array, 1);
+ addConstructableFunction(globalData, "Uint8ClampedArray", constructJSUint8ClampedArray, 1);
+ addConstructableFunction(globalData, "Uint16Array", constructJSUint16Array, 1);
+ addConstructableFunction(globalData, "Uint32Array", constructJSUint32Array, 1);
+ addConstructableFunction(globalData, "Int8Array", constructJSInt8Array, 1);
+ addConstructableFunction(globalData, "Int16Array", constructJSInt16Array, 1);
+ addConstructableFunction(globalData, "Int32Array", constructJSInt32Array, 1);
+ addConstructableFunction(globalData, "Float32Array", constructJSFloat32Array, 1);
+ addConstructableFunction(globalData, "Float64Array", constructJSFloat64Array, 1);
+
+ JSArray* array = constructEmptyArray(globalExec());
+ for (size_t i = 0; i < arguments.size(); ++i)
+ array->putDirectIndex(globalExec(), i, jsString(globalExec(), arguments[i]), false);
+ putDirect(globalData, Identifier(globalExec(), "arguments"), array);
+ }
+
+ void addFunction(JSGlobalData& globalData, const char* name, NativeFunction function, unsigned arguments)
+ {
+ Identifier identifier(globalExec(), name);
+ putDirect(globalData, identifier, JSFunction::create(globalExec(), this, arguments, identifier, function));
+ }
+
+ void addConstructableFunction(JSGlobalData& globalData, const char* name, NativeFunction function, unsigned arguments)
+ {
+ Identifier identifier(globalExec(), name);
+ putDirect(globalData, identifier, JSFunction::create(globalExec(), this, arguments, identifier, function, NoIntrinsic, function));
+ }
};
COMPILE_ASSERT(!IsInteger<GlobalObject>::value, WTF_IsInteger_GlobalObject_false);
ASSERT_CLASS_FITS_IN_CELL(GlobalObject);
-GlobalObject::GlobalObject(JSGlobalData& globalData, Structure* structure, const Vector<UString>& arguments)
+const ClassInfo GlobalObject::s_info = { "global", &JSGlobalObject::s_info, 0, ExecState::globalObjectTable, CREATE_METHOD_TABLE(GlobalObject) };
+
+GlobalObject::GlobalObject(JSGlobalData& globalData, Structure* structure)
: JSGlobalObject(globalData, structure)
{
- putDirectFunction(globalExec(), new (globalExec()) JSFunction(globalExec(), this, functionStructure(), 1, Identifier(globalExec(), "debug"), functionDebug));
- putDirectFunction(globalExec(), new (globalExec()) JSFunction(globalExec(), this, functionStructure(), 1, Identifier(globalExec(), "print"), functionPrint));
- putDirectFunction(globalExec(), new (globalExec()) JSFunction(globalExec(), this, functionStructure(), 0, Identifier(globalExec(), "quit"), functionQuit));
- putDirectFunction(globalExec(), new (globalExec()) JSFunction(globalExec(), this, functionStructure(), 0, Identifier(globalExec(), "gc"), functionGC));
-#ifndef NDEBUG
- putDirectFunction(globalExec(), new (globalExec()) JSFunction(globalExec(), this, functionStructure(), 0, Identifier(globalExec(), "releaseExecutableMemory"), functionReleaseExecutableMemory));
-#endif
- putDirectFunction(globalExec(), new (globalExec()) JSFunction(globalExec(), this, functionStructure(), 1, Identifier(globalExec(), "version"), functionVersion));
- putDirectFunction(globalExec(), new (globalExec()) JSFunction(globalExec(), this, functionStructure(), 1, Identifier(globalExec(), "run"), functionRun));
- putDirectFunction(globalExec(), new (globalExec()) JSFunction(globalExec(), this, functionStructure(), 1, Identifier(globalExec(), "load"), functionLoad));
- putDirectFunction(globalExec(), new (globalExec()) JSFunction(globalExec(), this, functionStructure(), 1, Identifier(globalExec(), "checkSyntax"), functionCheckSyntax));
- putDirectFunction(globalExec(), new (globalExec()) JSFunction(globalExec(), this, functionStructure(), 0, Identifier(globalExec(), "readline"), functionReadline));
-
-#if ENABLE(SAMPLING_FLAGS)
- putDirectFunction(globalExec(), new (globalExec()) JSFunction(globalExec(), this, functionStructure(), 1, Identifier(globalExec(), "setSamplingFlags"), functionSetSamplingFlags));
- putDirectFunction(globalExec(), new (globalExec()) JSFunction(globalExec(), this, functionStructure(), 1, Identifier(globalExec(), "clearSamplingFlags"), functionClearSamplingFlags));
-#endif
+}
- JSObject* array = constructEmptyArray(globalExec());
- for (size_t i = 0; i < arguments.size(); ++i)
- array->put(globalExec(), i, jsString(globalExec(), arguments[i]));
- putDirect(globalExec()->globalData(), Identifier(globalExec(), "arguments"), array);
+static inline SourceCode jscSource(const char* utf8, const UString& filename)
+{
+ // 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 makeSource(UString(utf8, asciiLength), filename);
+
+ // Slow case - contains non-ascii characters, use fromUTF8WithLatin1Fallback.
+ ASSERT(*pos < 0);
+ ASSERT(strlen(utf8) == asciiLength + strlen(pos));
+ String source = String::fromUTF8WithLatin1Fallback(utf8, asciiLength + strlen(pos));
+ return makeSource(source.impl(), filename);
}
EncodedJSValue JSC_HOST_CALL functionPrint(ExecState* exec)
if (i)
putchar(' ');
- printf("%s", exec->argument(i).toString(exec).utf8().data());
+ printf("%s", exec->argument(i).toString(exec)->value(exec).utf8().data());
}
putchar('\n');
EncodedJSValue JSC_HOST_CALL functionDebug(ExecState* exec)
{
- fprintf(stderr, "--> %s\n", exec->argument(0).toString(exec).utf8().data());
+ fprintf(stderr, "--> %s\n", exec->argument(0).toString(exec)->value(exec).utf8().data());
+ return JSValue::encode(jsUndefined());
+}
+
+EncodedJSValue JSC_HOST_CALL functionJSCStack(ExecState* exec)
+{
+ String trace = "--> Stack trace:\n";
+ Vector<StackFrame> stackTrace;
+ Interpreter::getStackTrace(&exec->globalData(), stackTrace);
+ int i = 0;
+
+ for (Vector<StackFrame>::iterator iter = stackTrace.begin(); iter < stackTrace.end(); iter++) {
+ StackFrame level = *iter;
+ trace += String::format(" %i %s\n", i, level.toString(exec).utf8().data());
+ i++;
+ }
+ fprintf(stderr, "%s", trace.utf8().data());
return JSValue::encode(jsUndefined());
}
EncodedJSValue JSC_HOST_CALL functionGC(ExecState* exec)
{
- JSLock lock(SilenceAssertionsOnly);
+ JSLockHolder lock(exec);
exec->heap()->collectAllGarbage();
return JSValue::encode(jsUndefined());
}
#ifndef NDEBUG
EncodedJSValue JSC_HOST_CALL functionReleaseExecutableMemory(ExecState* exec)
{
- JSLock lock(SilenceAssertionsOnly);
+ JSLockHolder lock(exec);
exec->globalData().releaseExecutableMemory();
return JSValue::encode(jsUndefined());
}
EncodedJSValue JSC_HOST_CALL functionRun(ExecState* exec)
{
- UString fileName = exec->argument(0).toString(exec);
+ UString 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.")));
- GlobalObject* globalObject = new (&exec->globalData()) GlobalObject(exec->globalData(), GlobalObject::createStructure(exec->globalData(), jsNull()), Vector<UString>());
+ GlobalObject* globalObject = GlobalObject::create(exec->globalData(), GlobalObject::createStructure(exec->globalData(), jsNull()), Vector<UString>());
+ JSValue exception;
StopWatch stopWatch;
stopWatch.start();
- evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName));
+ evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), jscSource(script.data(), fileName), JSValue(), &exception);
stopWatch.stop();
+ if (!!exception) {
+ throwError(globalObject->globalExec(), exception);
+ return JSValue::encode(jsUndefined());
+ }
+
return JSValue::encode(jsNumber(stopWatch.getElapsedMS()));
}
EncodedJSValue JSC_HOST_CALL functionLoad(ExecState* exec)
{
- UString fileName = exec->argument(0).toString(exec);
+ UString 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();
- Completion result = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script.data(), fileName));
- if (result.complType() == Throw)
- throwError(exec, result.value());
- return JSValue::encode(result.value());
+
+ JSValue evaluationException;
+ JSValue result = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), jscSource(script.data(), fileName), JSValue(), &evaluationException);
+ if (evaluationException)
+ throwError(exec, evaluationException);
+ return JSValue::encode(result);
}
EncodedJSValue JSC_HOST_CALL functionCheckSyntax(ExecState* exec)
{
- UString fileName = exec->argument(0).toString(exec);
+ UString 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.")));
StopWatch stopWatch;
stopWatch.start();
- Completion result = checkSyntax(globalObject->globalExec(), makeSource(script.data(), fileName));
+
+ JSValue syntaxException;
+ bool validSyntax = checkSyntax(globalObject->globalExec(), jscSource(script.data(), fileName), &syntaxException);
stopWatch.stop();
- if (result.complType() == Throw)
- throwError(exec, result.value());
+ if (!validSyntax)
+ throwError(exec, syntaxException);
return JSValue::encode(jsNumber(stopWatch.getElapsedMS()));
}
return JSValue::encode(jsString(exec, line.data()));
}
-EncodedJSValue JSC_HOST_CALL functionQuit(ExecState* exec)
+EncodedJSValue JSC_HOST_CALL functionPreciseTime(ExecState*)
{
- // Technically, destroying the heap in the middle of JS execution is a no-no,
- // but we want to maintain compatibility with the Mozilla test suite, so
- // we pretend that execution has terminated to avoid ASSERTs, then tear down the heap.
- exec->globalData().dynamicGlobalObject = 0;
+ return JSValue::encode(jsNumber(currentTime()));
+}
- cleanupGlobalData(&exec->globalData());
+EncodedJSValue JSC_HOST_CALL functionQuit(ExecState*)
+{
exit(EXIT_SUCCESS);
#if COMPILER(MSVC) && OS(WINCE)
// be in a separate main function because the jscmain function requires object
// unwinding.
-#if COMPILER(MSVC) && !defined(_DEBUG) && !OS(WINCE)
+#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 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
#endif
// Initialize JSC before getting JSGlobalData.
+ WTF::initializeMainThread();
JSC::initializeThreading();
// We can't use destructors in the following code because it uses Windows
// Structured Exception Handling
int res = 0;
- JSGlobalData* globalData = JSGlobalData::create(ThreadStackTypeLarge).leakRef();
TRY
- res = jscmain(argc, argv, globalData);
+ res = jscmain(argc, argv);
EXCEPT(res = 3)
-
- cleanupGlobalData(globalData);
return res;
}
-static void cleanupGlobalData(JSGlobalData* globalData)
-{
- JSLock lock(SilenceAssertionsOnly);
- globalData->clearBuiltinStructures();
- globalData->heap.destroy();
- globalData->deref();
-}
-
static bool runWithScripts(GlobalObject* globalObject, const Vector<Script>& scripts, bool dump)
{
- UString script;
+ const char* script;
UString fileName;
Vector<char> scriptBuffer;
globalData.startSampling();
- Completion completion = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(script, fileName));
- success = success && completion.complType() != Throw;
- if (dump) {
- if (completion.complType() == Throw)
- printf("Exception: %s\n", completion.value().toString(globalObject->globalExec()).utf8().data());
- else
- printf("End: %s\n", completion.value().toString(globalObject->globalExec()).utf8().data());
+ JSValue evaluationException;
+ JSValue returnValue = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), 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());
}
globalData.stopSampling();
#if ENABLE(SAMPLING_FLAGS)
SamplingFlags::stop();
+#endif
+#if ENABLE(SAMPLING_REGIONS)
+ SamplingRegion::dump();
#endif
globalData.dumpSampleData(globalObject->globalExec());
#if ENABLE(SAMPLING_COUNTERS)
static void runInteractive(GlobalObject* globalObject)
{
+ UString interpreterName("Interpreter");
+
while (true) {
#if HAVE(READLINE) && !RUNNING_FROM_XCODE
char* line = readline(interactivePrompt);
break;
if (line[0])
add_history(line);
- Completion completion = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), makeSource(line, interpreterName));
+ JSValue evaluationException;
+ JSValue returnValue = evaluate(globalObject->globalExec(), globalObject->globalScopeChain(), jscSource(line, interpreterName), JSValue(), &evaluationException);
free(line);
#else
printf("%s", interactivePrompt);
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(), globalObject->globalScopeChain(), jscSource(line.data(), interpreterName), JSValue(), &evaluationException);
#endif
- if (completion.complType() == Throw)
- printf("Exception: %s\n", completion.value().toString(globalObject->globalExec()).utf8().data());
+ if (evaluationException)
+ printf("Exception: %s\n", evaluationException.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
else
- printf("%s\n", completion.value().toString(globalObject->globalExec()).utf8().data());
+ printf("%s\n", returnValue.toString(globalObject->globalExec())->value(globalObject->globalExec()).utf8().data());
globalObject->globalExec()->clearException();
}
printf("\n");
}
-static NO_RETURN void printUsageStatement(JSGlobalData* globalData, bool help = false)
+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, " -s Installs signal handlers that exit on a crash (Unix platforms only)\n");
#endif
- cleanupGlobalData(globalData);
exit(help ? EXIT_SUCCESS : EXIT_FAILURE);
}
-static void parseArguments(int argc, char** argv, Options& options, JSGlobalData* globalData)
+static void parseArguments(int argc, char** argv, CommandLine& options)
{
int i = 1;
for (; i < argc; ++i) {
const char* arg = argv[i];
if (!strcmp(arg, "-f")) {
if (++i == argc)
- printUsageStatement(globalData);
+ printUsageStatement();
options.scripts.append(Script(true, argv[i]));
continue;
}
if (!strcmp(arg, "-e")) {
if (++i == argc)
- printUsageStatement(globalData);
+ printUsageStatement();
options.scripts.append(Script(false, argv[i]));
continue;
}
break;
}
if (!strcmp(arg, "-h") || !strcmp(arg, "--help"))
- printUsageStatement(globalData, true);
+ printUsageStatement(true);
options.scripts.append(Script(true, argv[i]));
}
options.arguments.append(argv[i]);
}
-int jscmain(int argc, char** argv, JSGlobalData* globalData)
+int jscmain(int argc, char** argv)
{
- JSLock lock(SilenceAssertionsOnly);
+
+ RefPtr<JSGlobalData> globalData = JSGlobalData::create(ThreadStackTypeLarge, LargeHeap);
+ JSLockHolder lock(globalData.get());
- Options options;
- parseArguments(argc, argv, options, globalData);
+ CommandLine options;
+ parseArguments(argc, argv, options);
- GlobalObject* globalObject = new (globalData) GlobalObject(*globalData, GlobalObject::createStructure(*globalData, jsNull()), options.arguments);
+ GlobalObject* globalObject = GlobalObject::create(*globalData, GlobalObject::createStructure(*globalData, jsNull()), options.arguments);
bool success = runWithScripts(globalObject, options.scripts, options.dump);
if (options.interactive && success)
runInteractive(globalObject);
projects / apple / javascriptcore.git / blobdiff