#define __STDC_LIMIT_MACROS

#include <errno.h>

#include <math.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <signal.h>

#include <locale.h>

#include "jstypes.h"

#include "jsstdint.h"

#include "jsarena.h"

#include "jsutil.h"

#include "jsprf.h"

#include "jswrapper.h"

#include "jsapi.h"

#include "jsarray.h"

#include "jsatom.h"

#include "jsbuiltins.h"

#include "jscntxt.h"

#include "jsdate.h"

#include "jsdbgapi.h"

#include "jsemit.h"

#include "jsfun.h"

#include "jsgc.h"

#include "jsiter.h"

#include "jslock.h"

#include "jsnum.h"

#include "jsobj.h"

#include "jsparse.h"

#include "jsreflect.h"

#include "jsscope.h"

#include "jsscript.h"

#include "jstracer.h"

#include "jstypedarray.h"

#include "jsxml.h"

#include "jsperf.h"

#include "prmjtime.h"

#ifdef JSDEBUGGER

#include "jsdebug.h"

#ifdef JSDEBUGGER_JAVA_UI

#include "jsdjava.h"

#endif /* JSDEBUGGER_JAVA_UI */

#ifdef JSDEBUGGER_C_UI

#include "jsdb.h"

#endif /* JSDEBUGGER_C_UI */

#endif /* JSDEBUGGER */

#include "jsworkers.h"

#include "jsinterpinlines.h"

#include "jsobjinlines.h"

#include "jsscriptinlines.h"

#ifdef XP_UNIX

#include <unistd.h>

#include <sys/types.h>

#include <sys/wait.h>

#endif

#if defined(XP_WIN) || defined(XP_OS2)

#include <io.h> /* for isatty() */

#endif

#ifdef XP_WIN

#include "jswin.h"

#endif

using namespace js;

typedef enum JSShellExitCode {

} JSShellExitCode;

size_t gStackChunkSize = 8192;

#if (defined(DEBUG) && defined(__SUNPRO_CC)) || defined(JS_CPU_SPARC)

#define DEFAULT_MAX_STACK_SIZE 5000000

#else

#define DEFAULT_MAX_STACK_SIZE 500000

#endif

size_t gMaxStackSize = DEFAULT_MAX_STACK_SIZE;

#ifdef JS_THREADSAFE

static PRUintn gStackBaseThreadIndex;

#else

static jsuword gStackBase;

#endif

static size_t gScriptStackQuota = JS_DEFAULT_SCRIPT_STACK_QUOTA;

static jsdouble MAX_TIMEOUT_INTERVAL = 1800.0;

static jsdouble gTimeoutInterval = -1.0;

static volatile bool gCanceled = false;

static bool enableTraceJit = false;

static bool enableMethodJit = false;

static bool enableProfiling = false;

static bool printTiming = false;

static JSBool

SetTimeoutValue(JSContext *cx, jsdouble t);

static bool

InitWatchdog(JSRuntime *rt);

static void

KillWatchdog();

static bool

ScheduleWatchdog(JSRuntime *rt, jsdouble t);

static void

CancelExecution(JSRuntime *rt);

#ifdef JS_THREADSAFE

static PRLock *gWatchdogLock = NULL;

static PRCondVar *gWatchdogWakeup = NULL;

static PRThread *gWatchdogThread = NULL;

static bool gWatchdogHasTimeout = false;

static PRIntervalTime gWatchdogTimeout = 0;

static PRCondVar *gSleepWakeup = NULL;

#else

static JSRuntime *gRuntime = NULL;

#endif

int gExitCode = 0;

JSBool gQuitting = JS_FALSE;

FILE *gErrFile = NULL;

FILE *gOutFile = NULL;

#ifdef JS_THREADSAFE

JSObject *gWorkers = NULL;

js::workers::ThreadPool *gWorkerThreadPool = NULL;

#endif

static JSBool reportWarnings = JS_TRUE;

static JSBool compileOnly = JS_FALSE;

typedef enum JSShellErrNum {

#define MSG_DEF(name, number, count, exception, format) \

name = number,

#include "jsshell.msg"

#undef MSG_DEF

JSShellErr_Limit

#undef MSGDEF

} JSShellErrNum;

static JSContext *

NewContext(JSRuntime *rt);

static void

DestroyContext(JSContext *cx, bool withGC);

static const JSErrorFormatString *

my_GetErrorMessage(void *userRef, const char *locale, const uintN errorNumber);

static JSObject *

split_setup(JSContext *cx, JSBool evalcx);

#ifdef EDITLINE

JS_BEGIN_EXTERN_C

JS_EXTERN_API(char) *readline(const char *prompt);

JS_EXTERN_API(void) add_history(char *line);

JS_END_EXTERN_C

#endif

static void

ReportException(JSContext *cx)

}

class ToString {

};

class IdToString : public ToString {

};

static char *

GetLine(FILE *file, const char * prompt)

{

size_t size;

char *buffer;

#ifdef EDITLINE

/*

if (file == stdin) {

char *linep = readline(prompt);

/*

if (errno == 251 || errno == 25 || errno == EINVAL)

errno = 0;

if (!linep)

return NULL;

if (linep[0] != '\0')

add_history(linep);

return linep;

}

#endif

size_t len = 0;

if (*prompt != '\0') {

fprintf(gOutFile, "%s", prompt);

fflush(gOutFile);

}

size = 80;

buffer = (char *) malloc(size);

if (!buffer)

return NULL;

char *current = buffer;

while (fgets(current, size - len, file)) {

len += strlen(current);

char *t = buffer + len - 1;

if (*t == '\n') {

/* Line was read. We remove '\n' and exit. */

*t = '\0';

return buffer;

}

if (len + 1 == size) {

size = size * 2;

char *tmp = (char *) realloc(buffer, size);

if (!tmp) {

free(buffer);

return NULL;

}

buffer = tmp;

}

current = buffer + len;

}

if (len && !ferror(file))

return buffer;

free(buffer);

return NULL;

}

struct JSShellContextData {

volatile JSIntervalTime startTime;

};

static JSShellContextData *

NewContextData()

{

/* Prevent creation of new contexts after we have been canceled. */

if (gCanceled)

return NULL;

JSShellContextData *data = (JSShellContextData *)

calloc(sizeof(JSShellContextData), 1);

if (!data)

return NULL;

data->startTime = js_IntervalNow();

return data;

}

static inline JSShellContextData *

GetContextData(JSContext *cx)

{

JSShellContextData *data = (JSShellContextData *) JS_GetContextPrivate(cx);

JS_ASSERT(data);

return data;

}

static JSBool

ShellOperationCallback(JSContext *cx)

}

static void

SetContextOptions(JSContext *cx)

}

#ifdef WINCE

int errno;

#endif

static void

Process(JSContext *cx, JSObject *obj, char *filename, JSBool forceTTY)

{

JSBool ok, hitEOF;

JSObject *scriptObj;

jsval result;

JSString *str;

char *buffer;

size_t size;

int lineno;

int startline;

FILE *file;

uint32 oldopts;

if (forceTTY || !filename || strcmp(filename, "-") == 0) {

file = stdin;

} else {

file = fopen(filename, "r");

if (!file) {

JS_ReportErrorNumber(cx, my_GetErrorMessage, NULL,

JSSMSG_CANT_OPEN, filename, strerror(errno));

gExitCode = EXITCODE_FILE_NOT_FOUND;

return;

}

}

SetContextOptions(cx);

#ifndef WINCE

/* windows mobile (and possibly other os's) does not have a TTY */

if (!forceTTY && !isatty(fileno(file)))

#endif

{

/*

int ch = fgetc(file);

if (ch == '#') {

while((ch = fgetc(file)) != EOF) {

if (ch == '\n' || ch == '\r')

break;

}

}

ungetc(ch, file);

int64 t1 = PRMJ_Now();

oldopts = JS_GetOptions(cx);

JS_SetOptions(cx, oldopts | JSOPTION_COMPILE_N_GO | JSOPTION_NO_SCRIPT_RVAL);

scriptObj = JS_CompileFileHandle(cx, obj, filename, file);

JS_SetOptions(cx, oldopts);

if (scriptObj && !compileOnly) {

(void) JS_ExecuteScript(cx, obj, scriptObj, NULL);

int64 t2 = PRMJ_Now() - t1;

if (printTiming)

printf("runtime = %.3f ms\n", double(t2) / PRMJ_USEC_PER_MSEC);

}

goto cleanup;

}

/* It's an interactive filehandle; drop into read-eval-print loop. */

lineno = 1;

hitEOF = JS_FALSE;

buffer = NULL;

size = 0; /* assign here to avoid warnings */

do {

/*

startline = lineno;

size_t len = 0; /* initialize to avoid warnings */

do {

ScheduleWatchdog(cx->runtime, -1);

gCanceled = false;

errno = 0;

char *line;

{

JSAutoSuspendRequest suspended(cx);

line = GetLine(file, startline == lineno ? "js> " : "");

}

if (!line) {

if (errno) {

JS_ReportError(cx, strerror(errno));

free(buffer);

goto cleanup;

}

hitEOF = JS_TRUE;

break;

}

if (!buffer) {

buffer = line;

len = strlen(buffer);

size = len + 1;

} else {

/*

size_t newlen = strlen(line) + (len ? len + 1 : 0);

if (newlen + 1 > size) {

size = newlen + 1 > size * 2 ? newlen + 1 : size * 2;

char *newBuf = (char *) realloc(buffer, size);

if (!newBuf) {

free(buffer);

free(line);

JS_ReportOutOfMemory(cx);

goto cleanup;

}

buffer = newBuf;

}

char *current = buffer + len;

if (startline != lineno)

*current++ = '\n';

strcpy(current, line);

len = newlen;

free(line);

}

lineno++;

if (!ScheduleWatchdog(cx->runtime, gTimeoutInterval)) {

hitEOF = JS_TRUE;

break;

}

} while (!JS_BufferIsCompilableUnit(cx, obj, buffer, len));

if (hitEOF && !buffer)

break;

/* Clear any pending exception from previous failed compiles. */

JS_ClearPendingException(cx);

/* Even though we're interactive, we have a compile-n-go opportunity. */

oldopts = JS_GetOptions(cx);

if (!compileOnly)

JS_SetOptions(cx, oldopts | JSOPTION_COMPILE_N_GO);

scriptObj = JS_CompileScript(cx, obj, buffer, len, "typein",

startline);

if (!compileOnly)

JS_SetOptions(cx, oldopts);

if (scriptObj && !compileOnly) {

ok = JS_ExecuteScript(cx, obj, scriptObj, &result);

if (ok && !JSVAL_IS_VOID(result)) {

str = JS_ValueToSource(cx, result);

ok = !!str;

if (ok) {

JSAutoByteString bytes(cx, str);

ok = !!bytes;

if (ok)

fprintf(gOutFile, "%s\n", bytes.ptr());

}

}

}

*buffer = '\0';

} while (!hitEOF && !gQuitting);

free(buffer);

fprintf(gOutFile, "\n");

cleanup:

if (file != stdin)

fclose(file);

return;

}

static int

usage(void)

}

static const struct {

const char *name;

uint32 flag;

} js_options[] = {

{"anonfunfix", JSOPTION_ANONFUNFIX},

{"atline", JSOPTION_ATLINE},

{"jitprofiling", JSOPTION_PROFILING},

{"tracejit", JSOPTION_JIT},

{"methodjit", JSOPTION_METHODJIT},

{"methodjit_always",JSOPTION_METHODJIT_ALWAYS},

{"relimit", JSOPTION_RELIMIT},

{"strict", JSOPTION_STRICT},

{"werror", JSOPTION_WERROR},

{"xml", JSOPTION_XML},

};

static uint32

MapContextOptionNameToFlag(JSContext* cx, const char* name)

}

extern JSClass global_class;

#if defined(JS_TRACER) && defined(DEBUG)

namespace js {

extern struct JSClass jitstats_class;

void InitJITStatsClass(JSContext *cx, JSObject *glob);

}

#endif

static int

ProcessArgs(JSContext *cx, JSObject *obj, char **argv, int argc)

}

static JSBool

Version(JSContext *cx, uintN argc, jsval *vp)

}

static JSBool

RevertVersion(JSContext *cx, uintN argc, jsval *vp)

}

static JSBool

Options(JSContext *cx, uintN argc, jsval *vp)