public static String languageVersionProperty = "language version";

public static String errorReporterProperty = "error reporter";

/**

public Context() {

setLanguageVersion(VERSION_DEFAULT);

optimizationLevel = codegenClass != null ? 0 : -1;

}

/**

public Context(SecuritySupport securitySupport) {

this();

this.securitySupport = securitySupport;

}

/**

public static Context enter() {

return enter(null);

}

/**

public static Context enter(Context cx) {

// There's some duplication of code in this method to avoid

// unnecessary synchronizations.

Thread t = Thread.currentThread();

Context current = (Context) threadContexts.get(t);

if (current != null) {

synchronized (current) {

current.enterCount++;

}

return current;

}

if (cx != null) {

synchronized (cx) {

if (cx.currentThread == null) {

cx.currentThread = t;

threadContexts.put(t, cx);

cx.enterCount++;

return cx;

}

}

}

current = new Context();

current.currentThread = t;

threadContexts.put(t, current);

current.enterCount = 1;

return current;

}

/**

public static void exit() {

Context cx = getCurrentContext();

if (cx != null) {

synchronized (cx) {

if (--cx.enterCount == 0) {

threadContexts.remove(cx.currentThread);

cx.currentThread = null;

}

}

}

}

/**

public static Context getCurrentContext() {

Thread t = Thread.currentThread();

return (Context) threadContexts.get(t);

}

/**

/**

public static final int VERSION_UNKNOWN = -1;

/**

public static final int VERSION_DEFAULT = 0;

/**

public static final int VERSION_1_0 = 100;

/**

public static final int VERSION_1_1 = 110;

/**

public static final int VERSION_1_2 = 120;

/**

public static final int VERSION_1_3 = 130;

/**

public static final int VERSION_1_4 = 140;

/**

public static final int VERSION_1_5 = 150;

/**

public int getLanguageVersion() {

return version;

}

/**

public void setLanguageVersion(int version) {

if (listeners != null && version != this.version) {

firePropertyChange(languageVersionProperty,

new Integer(this.version),

new Integer(version));

}

this.version = version;

}

/**

public String getImplementationVersion() {

return "JavaScript-Java 1.5 release 1 2000 03 15";

}

/**

public ErrorReporter getErrorReporter() {

if (errorReporter == null) {

errorReporter = new DefaultErrorReporter();

}

return errorReporter;

}

/**

public ErrorReporter setErrorReporter(ErrorReporter reporter) {

ErrorReporter result = errorReporter;

if (listeners != null && errorReporter != reporter) {

firePropertyChange(errorReporterProperty, errorReporter,

reporter);

}

errorReporter = reporter;

return result;

}

/**

public Locale getLocale() {

if (locale == null)

locale = Locale.getDefault();

return locale;

}

/**

public Locale setLocale(Locale loc) {

Locale result = locale;

locale = loc;

return result;

}

/**

public void addPropertyChangeListener(PropertyChangeListener listener) {

if (listeners == null) {

listeners = new ListenerCollection();

}

listeners.addListener(listener);

}

/**

public void removePropertyChangeListener(PropertyChangeListener listener) {

listeners.removeListener(listener);

}

/**

protected void firePropertyChange(String property, Object oldValue,

Object newValue) {

Class listenerClass = java.beans.PropertyChangeListener.class;

Object[] listenerList = listeners.getListeners(listenerClass);

for(int i = 0; i < listenerList.length; i++) {

PropertyChangeListener l =

(PropertyChangeListener)listenerList[i];

l.propertyChange(new PropertyChangeEvent(

this, property, oldValue, newValue));

}

}

/**

public static void reportWarning(String message, String sourceName,

int lineno, String lineSource,

int lineOffset)

{

Context cx = Context.getContext();

cx.getErrorReporter().warning(message, sourceName, lineno,

lineSource, lineOffset);

}

/**

public static void reportWarning(String message) {

int[] linep = { 0 };

String filename = getSourcePositionFromStack(linep);

Context.reportWarning(message, filename, linep[0], null, 0);

}

/**

public static void reportError(String message, String sourceName,

int lineno, String lineSource,

int lineOffset)

{

Context cx = getCurrentContext();

if (cx != null) {

cx.errorCount++;

cx.getErrorReporter().error(message, sourceName, lineno,

lineSource, lineOffset);

} else {

throw new EvaluatorException(message);

}

}

/**

public static void reportError(String message) {

int[] linep = { 0 };

String filename = getSourcePositionFromStack(linep);

Context.reportError(message, filename, linep[0], null, 0);

}

/**

public static EvaluatorException reportRuntimeError(String message,

String sourceName,

int lineno,

String lineSource,

int lineOffset)

{

Context cx = getCurrentContext();

if (cx != null) {

cx.errorCount++;

return cx.getErrorReporter().

runtimeError(message, sourceName, lineno,

lineSource, lineOffset);

} else {

throw new EvaluatorException(message);

}

}

/**

public static EvaluatorException reportRuntimeError(String message) {

int[] linep = { 0 };

String filename = getSourcePositionFromStack(linep);

return Context.reportRuntimeError(message, filename, linep[0], null, 0);

}

/**

public Scriptable initStandardObjects(ScriptableObject scope) {

return initStandardObjects(scope, false);

}

/**

public ScriptableObject initStandardObjects(ScriptableObject scope,

boolean sealed)

{

final String omj = "org.mozilla.javascript.";

try {

if (scope == null)

scope = new NativeObject();

ScriptableObject.defineClass(scope, NativeFunction.class, sealed);

ScriptableObject.defineClass(scope, NativeObject.class, sealed);

Scriptable objectProto = ScriptableObject.

getObjectPrototype(scope);

// Function.prototype.__proto__ should be Object.prototype

Scriptable functionProto = ScriptableObject.

getFunctionPrototype(scope);

functionProto.setPrototype(objectProto);

// Set the prototype of the object passed in if need be

if (scope.getPrototype() == null)

scope.setPrototype(objectProto);

// must precede NativeGlobal since it's needed therein

ScriptableObject.defineClass(scope, NativeError.class, sealed);

ScriptableObject.defineClass(scope, NativeGlobal.class, sealed);

String[] classes = { "NativeArray", "Array",

"NativeString", "String",

"NativeBoolean", "Boolean",

"NativeNumber", "Number",

"NativeDate", "Date",

"NativeMath", "Math",

"NativeCall", "Call",

"NativeWith", "With",

"regexp.NativeRegExp", "RegExp",

"NativeScript", "Script",

};

for (int i=0; i < classes.length; i+=2) {

try {

if (sealed) {

Class c = Class.forName(omj + classes[i]);

ScriptableObject.defineClass(scope, c, sealed);

} else {

String s = omj + classes[i];

new LazilyLoadedCtor(scope, classes[i+1], s,

ScriptableObject.DONTENUM);

}

} catch (ClassNotFoundException e) {

continue;

}

}

// Define the JavaAdapter class, allowing it to be overridden.

String adapterName = "org.mozilla.javascript.JavaAdapter";

try {

adapterName = System.getProperty(adapterName, adapterName);

} catch (SecurityException e) {

// We may not be allowed to get system properties. Just

// use the default adapter in that case.

}

try {

Class adapterClass = Class.forName(adapterName);

ScriptableObject.defineClass(scope, adapterClass, sealed);

// This creates the Packages and java package roots.

Class c = Class.forName(omj + "NativeJavaPackage");

ScriptableObject.defineClass(scope, c, sealed);

} catch (ClassNotFoundException e) {

// If the class is not found, proceed without it.

} catch (SecurityException e) {

// Ignore AccessControlExceptions that may occur if a

// SecurityManager is installed:

// java.lang.RuntimePermission createClassLoader

// java.util.PropertyPermission

// org.mozilla.javascript.JavaAdapter read

}

}

// All of these exceptions should not occur since we are initializing

// from known classes

catch (IllegalAccessException e) {

throw WrappedException.wrapException(e);

}

catch (InstantiationException e) {

throw WrappedException.wrapException(e);

}

catch (InvocationTargetException e) {

throw WrappedException.wrapException(e);

}

catch (ClassDefinitionException e) {

throw WrappedException.wrapException(e);

}

catch (PropertyException e) {

throw WrappedException.wrapException(e);

}

return scope;

}

/**

public static Object getUndefinedValue() {

return Undefined.instance;

}

/**

public Object evaluateString(Scriptable scope, String source,

String sourceName, int lineno,

Object securityDomain)

throws JavaScriptException

{

try {

Reader in = new StringReader(source);

return evaluateReader(scope, in, sourceName, lineno,

securityDomain);

}

catch (IOException ioe) {

// Should never occur because we just made the reader from a String

throw new RuntimeException();

}

}

/**

public Object evaluateReader(Scriptable scope, Reader in,

String sourceName, int lineno,

Object securityDomain)

throws IOException, JavaScriptException

{

Script script = compileReader(scope, in, sourceName, lineno,

securityDomain);

if (script != null)

return script.exec(this, scope);

else

return null;

}

/**

synchronized public boolean stringIsCompilableUnit(String source)

{

Reader in = new StringReader(source);

// no source name or source text manager, because we're just

// going to throw away the result.

TokenStream ts = new TokenStream(in, null, null, 1);

// Temporarily set error reporter to always be the exception-throwing

// DefaultErrorReporter. (This is why the method is synchronized...)

ErrorReporter currentReporter =

setErrorReporter(new DefaultErrorReporter());

boolean errorseen = false;

try {

IRFactory irf = new IRFactory(ts, null);

Parser p = new Parser(irf);

p.parse(ts);

} catch (IOException ioe) {

errorseen = true;

} catch (EvaluatorException ee) {

errorseen = true;

} finally {

// Restore the old error reporter.

setErrorReporter(currentReporter);

}

// Return false only if an error occurred as a result of reading past

// the end of the file, i.e. if the source could be fixed by

// appending more source.

if (errorseen && ts.eof())

return false;

else

return true;

}

/**

public Script compileReader(Scriptable scope, Reader in, String sourceName,

int lineno, Object securityDomain)

throws IOException

{

return (Script) compile(scope, in, sourceName, lineno, securityDomain,

false);

}

/**

public Function compileFunction(Scriptable scope, String source,

String sourceName, int lineno,

Object securityDomain)

{

Reader in = new StringReader(source);

try {

return (Function) compile(scope, in, sourceName, lineno,

securityDomain, true);

}

catch (IOException ioe) {

// Should never happen because we just made the reader

// from a String

throw new RuntimeException();

}

}

/**

public String decompileScript(Script script, Scriptable scope,

int indent)

{

NativeScript ns = (NativeScript) script;

ns.initScript(scope);

return ns.decompile(indent, true, false);

}

/**

public String decompileFunction(Function fun, int indent) {

if (fun instanceof NativeFunction)

return ((NativeFunction)fun).decompile(indent, true, false);

else

return "function " + fun.getClassName() +

"() {\n\t[native code]\n}\n";

}

/**

public String decompileFunctionBody(Function fun, int indent) {

if (fun instanceof NativeFunction)

return ((NativeFunction)fun).decompile(indent, true, true);

else

// not sure what the right response here is. JSRef currently

// dumps core.

return "[native code]\n";

}

/**

public Scriptable newObject(Scriptable scope)

throws PropertyException,

NotAFunctionException,

JavaScriptException

{

return newObject(scope, "Object", null);

}

/**

public Scriptable newObject(Scriptable scope, String constructorName)

throws PropertyException,

NotAFunctionException,

JavaScriptException

{

return newObject(scope, constructorName, null);

}

/**

public Scriptable newObject(Scriptable scope, String constructorName,

Object[] args)

throws PropertyException,

NotAFunctionException,

JavaScriptException

{

Object ctorVal = ScriptRuntime.getTopLevelProp(scope, constructorName);

if (ctorVal == Scriptable.NOT_FOUND) {

Object[] errArgs = { constructorName };

String message = getMessage("msg.ctor.not.found", errArgs);

throw new PropertyException(message);

}

if (!(ctorVal instanceof Function)) {

Object[] errArgs = { constructorName };

String message = getMessage("msg.not.ctor", errArgs);