blob: 25c807e6658ecb691e7449b5e76b7dbd94e420bb [file] [log] [blame]
// -*- c-basic-offset: 2 -*-
/*
* Copyright (C) 1999-2000 Harri Porten (porten@kde.org)
* Copyright (C) 2004-2007 Apple Inc.
* Copyright (C) 2006 Bjoern Graf (bjoern.graf@gmail.com)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
#include "config.h"
#include "JSGlobalObject.h"
#include "JSLock.h"
#include "Parser.h"
#include "collector.h"
#include "interpreter.h"
#include "nodes.h"
#include "object.h"
#include "protect.h"
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <wtf/Assertions.h>
#include <wtf/HashTraits.h>
#if HAVE(SYS_TIME_H)
#include <sys/time.h>
#endif
#if PLATFORM(WIN_OS)
#include <crtdbg.h>
#include <windows.h>
#endif
#if PLATFORM(QT)
#include <QDateTime>
#endif
using namespace KJS;
using namespace WTF;
static bool fillBufferWithContentsOfFile(const UString& fileName, Vector<char>& buffer);
class StopWatch
{
public:
void start();
void stop();
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
};
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
}
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
}
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
}
class GlobalImp : public JSGlobalObject {
public:
virtual UString className() const { return "global"; }
};
COMPILE_ASSERT(!IsInteger<GlobalImp>::value, WTF_IsInteger_GlobalImp_false);
class TestFunctionImp : public JSObject {
public:
enum TestFunctionType { Print, Debug, Quit, GC, Version, Run, Load };
TestFunctionImp(TestFunctionType i, int length);
virtual bool implementsCall() const { return true; }
virtual JSValue* callAsFunction(ExecState* exec, JSObject* thisObj, const List &args);
private:
TestFunctionType m_type;
};
TestFunctionImp::TestFunctionImp(TestFunctionType i, int length)
: JSObject()
, m_type(i)
{
putDirect(Identifier("length"), length, DontDelete | ReadOnly | DontEnum);
}
JSValue* TestFunctionImp::callAsFunction(ExecState* exec, JSObject*, const List &args)
{
switch (m_type) {
case Print:
printf("%s\n", args[0]->toString(exec).UTF8String().c_str());
return jsUndefined();
case Debug:
fprintf(stderr, "--> %s\n", args[0]->toString(exec).UTF8String().c_str());
return jsUndefined();
case GC:
{
JSLock lock;
Collector::collect();
return jsUndefined();
}
case Version:
// 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();
case Run:
{
StopWatch stopWatch;
UString fileName = args[0]->toString(exec);
Vector<char> script;
if (!fillBufferWithContentsOfFile(fileName, script))
return throwError(exec, GeneralError, "Could not open file.");
stopWatch.start();
Interpreter::evaluate(exec->dynamicGlobalObject()->globalExec(), fileName, 0, script.data());
stopWatch.stop();
return jsNumber(stopWatch.getElapsedMS());
}
case Load:
{
UString fileName = args[0]->toString(exec);
Vector<char> script;
if (!fillBufferWithContentsOfFile(fileName, script))
return throwError(exec, GeneralError, "Could not open file.");
Interpreter::evaluate(exec->dynamicGlobalObject()->globalExec(), fileName, 0, script.data());
return jsUndefined();
}
case Quit:
exit(0);
default:
abort();
}
return 0;
}
// Use SEH for Release builds only to get rid of the crash report dialog
// (luckily the same tests fail in Release and Debug builds so far). Need to
// be in a separate main function because the kjsmain function requires object
// unwinding.
#if PLATFORM(WIN_OS) && !defined(_DEBUG)
#define TRY __try {
#define EXCEPT(x) } __except (EXCEPTION_EXECUTE_HANDLER) { x; }
#else
#define TRY
#define EXCEPT(x)
#endif
int kjsmain(int argc, char** argv);
int main(int argc, char** argv)
{
#if defined(_DEBUG) && PLATFORM(WIN_OS)
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ERROR, _CRTDBG_FILE_STDERR);
_CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_ASSERT, _CRTDBG_FILE_STDERR);
_CrtSetReportMode(_CRT_ASSERT, _CRTDBG_MODE_FILE);
#endif
int res = 0;
TRY
res = kjsmain(argc, argv);
EXCEPT(res = 3)
return res;
}
static GlobalImp* createGlobalObject()
{
GlobalImp* global = new GlobalImp;
// add debug() function
global->put(global->globalExec(), "debug", new TestFunctionImp(TestFunctionImp::Debug, 1));
// add "print" for compatibility with the mozilla js shell
global->put(global->globalExec(), "print", new TestFunctionImp(TestFunctionImp::Print, 1));
// add "quit" for compatibility with the mozilla js shell
global->put(global->globalExec(), "quit", new TestFunctionImp(TestFunctionImp::Quit, 0));
// add "gc" for compatibility with the mozilla js shell
global->put(global->globalExec(), "gc", new TestFunctionImp(TestFunctionImp::GC, 0));
// add "version" for compatibility with the mozilla js shell
global->put(global->globalExec(), "version", new TestFunctionImp(TestFunctionImp::Version, 1));
global->put(global->globalExec(), "run", new TestFunctionImp(TestFunctionImp::Run, 1));
global->put(global->globalExec(), "load", new TestFunctionImp(TestFunctionImp::Load, 1));
Interpreter::setShouldPrintExceptions(true);
return global;
}
static bool prettyPrintScript(const UString& fileName, const Vector<char>& script)
{
int errLine = 0;
UString errMsg;
UString scriptUString(script.data());
RefPtr<ProgramNode> programNode = parser().parse<ProgramNode>(fileName, 0, scriptUString.data(), scriptUString.size(), 0, &errLine, &errMsg);
if (!programNode) {
fprintf(stderr, "%s:%d: %s.\n", fileName.UTF8String().c_str(), errLine, errMsg.UTF8String().c_str());
return false;
}
printf("%s\n", programNode->toString().UTF8String().c_str());
return true;
}
static bool runWithScripts(const Vector<UString>& fileNames, bool prettyPrint)
{
GlobalImp* globalObject = createGlobalObject();
Vector<char> script;
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 (prettyPrint)
prettyPrintScript(fileName, script);
else {
Completion completion = Interpreter::evaluate(globalObject->globalExec(), fileName, 0, script.data());
success = success && completion.complType() != Throw;
}
}
return success;
}
static void parseArguments(int argc, char** argv, Vector<UString>& fileNames, bool& prettyPrint)
{
if (argc < 2) {
fprintf(stderr, "Usage: testkjs file1 [file2...]\n");
exit(-1);
}
for (int i = 1; i < argc; i++) {
const char* fileName = argv[i];
if (strcmp(fileName, "-f") == 0) // mozilla test driver script uses "-f" prefix for files
continue;
if (strcmp(fileName, "-p") == 0) {
prettyPrint = true;
continue;
}
fileNames.append(fileName);
}
}
int kjsmain(int argc, char** argv)
{
JSLock lock;
bool prettyPrint = false;
Vector<UString> fileNames;
parseArguments(argc, argv, fileNames, prettyPrint);
bool success = runWithScripts(fileNames, prettyPrint);
#ifndef NDEBUG
Collector::collect();
#endif
return success ? 0 : 3;
}
static bool fillBufferWithContentsOfFile(const UString& fileName, Vector<char>& buffer)
{
FILE* f = fopen(fileName.UTF8String().c_str(), "r");
if (!f) {
fprintf(stderr, "Could not open file: %s\n", fileName.UTF8String().c_str());
return false;
}
size_t buffer_size = 0;
size_t buffer_capacity = 1024;
buffer.resize(buffer_capacity);
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);
}
}
fclose(f);
buffer[buffer_size] = '\0';
return true;
}