X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=src%2Forg%2Fxwt%2Fjs%2FJS.java;h=b89b61ca01d2025c525d8475606580b391dec791;hb=1a8dcf7794ae435c5c2811b8d7c2b75832047595;hp=0a949e38c0d097e569aaa66c7b09c1a8d1e5b9be;hpb=395d61dea4f5f7b22120e8b0b3fd9b75351c0a98;p=org.ibex.core.git diff --git a/src/org/xwt/js/JS.java b/src/org/xwt/js/JS.java index 0a949e3..b89b61c 100644 --- a/src/org/xwt/js/JS.java +++ b/src/org/xwt/js/JS.java @@ -1,93 +1,163 @@ -// Copyright 2002 Adam Megacz, see the COPYING file for licensing [GPL] - +// Copyright 2003 Adam Megacz, see the COPYING file for licensing [GPL] + package org.xwt.js; import org.xwt.util.*; +import java.io.*; +import java.util.*; -/** The public API for the JS engine */ -// FEATURE: try using mutable, recycled 'Num' objects -public interface JS { - - public abstract Object get(Object key) throws JS.Exn; - public abstract void put(Object key, Object val) throws JS.Exn; - public abstract Object[] enumerateProperties(); - - public abstract Number coerceToNumber() throws JS.Exn; - public abstract boolean coerceToBoolean() throws JS.Exn; - public abstract String coerceToString() throws JS.Exn; - - public static class Obj implements JS { - private Hash entries; - public Obj() { } - public Object get(Object key) { return entries.get(key); } - public void put(Object key, Object val) { entries.put(key, val); } - public Object[] enumerateProperties() { return(entries.keys()); } - public Number coerceToNumber() { throw new Error("tried to turn a Object into a Number"); } - public String coerceToString() { throw new Error("tried to turn a Object into a String"); } - public boolean coerceToBoolean() { throw new Error("tried to turn a Object into a Boolean"); } +/** + * The public API for the JS engine. JS itself is actually a class + * implementing the absolute minimal amount of functionality for an + * Object which can be manipulated by JavaScript code. The static + * methods, fields, and inner classes of JS define the publicly + * visible API for the XWT JavaScript engine; code outside this + * package should never depend on anything not defined in this file. + */ +public abstract class JS { + + + // Public Helper Methods ////////////////////////////////////////////////////////////////////// + + /** parse and compile a function */ + public static CompiledFunction parse(String sourceName, int firstLine, Reader sourceCode) throws IOException { + return new CompiledFunction(sourceName, firstLine, sourceCode, null); } - public static class Array extends Obj { - private Vec vec = new Vec(); - private static int intVal(Object o) { - if (o instanceof Number) { - int intVal = ((Number)o).intValue(); - if (intVal == ((Number)o).doubleValue()) return intVal; - return Integer.MIN_VALUE; - } - if (!(o instanceof String)) return Integer.MIN_VALUE; - String s = (String)o; - for(int i=0; i '9') return Integer.MIN_VALUE; - return Integer.parseInt(s); - } - public Object get(Object key) { - if (key.equals("length")) return new Long(vec.size()); - int i = intVal(key); - if (i == Integer.MIN_VALUE) return super.get(key); - return vec.elementAt(i); - } - public void put(Object key, Object val) { - if (key.equals("length")) vec.setSize(Expr.toNumber(val).intValue()); - int i = intVal(key); - if (i == Integer.MIN_VALUE) super.put(key, val); - else vec.setElementAt(val, i); - } - public Object[] enumerateProperties() { return null; } // FIXME - void addElement(Object o) { vec.addElement(o); } + /** coerce an object to a Boolean */ + public static boolean toBoolean(Object o) { + if (o == null) return false; + if (o instanceof Boolean) return ((Boolean)o).booleanValue(); + if (o instanceof Number) return o.equals(new Integer(0)); + return true; } - public static interface Function extends JS { - public abstract Object call(JS.Array args) throws JS.Exn; // FEATURE: try to recycle these arrays? - public abstract Scope getParentScopeOfDeclaration(); + /** coerce an object to a Long */ + public static long toLong(Object o) { return toNumber(o).longValue(); } + + /** coerce an object to a Double */ + public static double toDouble(Object o) { return toNumber(o).doubleValue(); } + + /** coerce an object to a Number */ + public static Number toNumber(Object o) { + if (o == null) return new Long(0); + if (o instanceof Number) return ((Number)o); + if (o instanceof String) try { return new Double((String)o); } catch (NumberFormatException e) { return new Double(0); } + if (o instanceof Boolean) return ((Boolean)o).booleanValue() ? new Long(1) : new Long(0); + if (o instanceof JS) return ((JS)o).coerceToNumber(); + throw new Error("toNumber() got object of type " + o.getClass().getName() + " which we don't know how to handle"); } - public static abstract class ObjFunction extends Obj implements Function { } - /** if JS calls a Java method, and the Java method throws an exception, it can only be caught by JS if it is a subclass of Exn. */ + // Instance Methods //////////////////////////////////////////////////////////////////// + + public abstract Object get(Object key) throws JS.Exn; + public abstract void put(Object key, Object val) throws JS.Exn; + public abstract Object[] keys(); + + public Number coerceToNumber() { throw new Error("you cannot coerce a " + this.getClass().getName() + " into a Number"); } + public String coerceToString() { throw new Error("you cannot coerce a " + this.getClass().getName() + " into a String"); } + public boolean coerceToBoolean() { throw new Error("you cannot coerce a " + this.getClass().getName() + " into a Boolean"); } + + + // Inner Classes ///////////////////////////////////////////////////////////////////////// + + /** A sensible implementation of the abstract methods in the JS class */ + public static class Obj extends JS { + private Hash entries = new Hash(); + private boolean sealed = false; + public Obj() { this(false); } + public Obj(boolean sealed) { this.sealed = sealed; } + /** a sealed object cannot have its properties modified */ + public void setSeal(boolean sealed) { this.sealed = sealed; } + public Object get(Object key) { return entries.get(key); } + public void put(Object key, Object val) { if (!sealed) entries.put(key, val); } + public Object[] keys() { return(entries.keys()); } + } + + /** An exception which can be thrown and caught by JavaScript code */ public static class Exn extends RuntimeException { - private Object js = null; - public Exn(Object js) { this.js = js; } - public Object getObject() { return js; } + private Object js = null; + public Exn(Object js) { this.js = js; } + public String toString() { return "JS.Exn: " + js; } + public String getMessage() { return toString(); } + public Object getObject() { return js; } } + /** The publicly-visible face of JavaScript Array objects */ + public static class Array extends ArrayImpl { + public Array() { } + public Array(int size) { super(size); } + public void setSize(int i) { super.setSize(i); } + public int length() { return super.length(); } + public Object elementAt(int i) { return super.elementAt(i); } + public void addElement(Object o) { super.addElement(o); } + public void setElementAt(Object o, int i) { super.setElementAt(o, i); } + public Object get(Object key) { return super.get(key); } + public void put(Object key, Object val) { super.put(key, val); } + } + /** Any object which becomes part of the scope chain must support this interface */ - public static class Scope extends Obj { - private Scope parentScope; - private static Object NULL = new Object(); - public Scope(Scope parentScope) { this.parentScope = parentScope; } - public JS getParentScope() { return parentScope; } - public boolean has(Object key) { return super.get(key) != null; } - public Object get(Object key) { - if (!has(key)) return getParentScope().get(key); - Object ret = super.get(key); return ret == NULL ? null : ret; - } - public void put(Object key, Object val) { - if (!has(key)) getParentScope().put(key, val); - else super.put(key, val == null ? NULL : val); - } - public Object[] enumerateProperties() { throw new Error("you can't enumerate the properties of a Scope"); } - public void declare(String s) { super.put(s, NULL); } + public static class Scope extends ScopeImpl { + public Scope(Scope parentScope) { this(parentScope, false); } + public Scope(Scope parentScope, boolean sealed) { super(parentScope, sealed); } + /** transparent scopes are not returned by THIS */ + public boolean isTransparent() { return super.isTransparent(); } + public boolean has(Object key) { return super.has(key); } + public Object get(Object key) { return super.get(key); } + public void put(Object key, Object val) { super.put(key, val); } + public void declare(String s) { super.declare(s); } } + + /** anything that is callable with the () operator */ + public static abstract class Callable extends JS.Obj { + public abstract Object call(JS.Array args) throws JS.Exn; + } + + /** a Callable which was compiled from JavaScript code */ + public static class CompiledFunction extends CompiledFunctionImpl { + public Object call(JS.Array args, JS.Scope scope) throws JS.Exn { return super.call(args, scope); } + CompiledFunction(String sourceName, int firstLine, Reader sourceCode, Scope scope) throws IOException { + super(sourceName, firstLine, sourceCode, scope); + } + } + + public static final JS Math = new org.xwt.js.Math(); + /** encapsulates a single JavaScript thread; the JS.Thread->java.lang.Thread mapping is 1:1 */ + public static class Thread { + + CompiledFunction currentCompiledFunction = null; + Vec stack = new Vec(); + int line = -1; + + /** binds this thread to the current Java Thread */ + public void bindToCurrentJavaThread() { javaThreadToJSThread.put(java.lang.Thread.currentThread(), this); } + + /** returns the line of code that is currently executing */ + public int getLine() { return line; } + + /** returns the name of the source code file which declared the currently executing function */ + public String getSourceName() { return currentCompiledFunction == null ? null : currentCompiledFunction.getSourceName(); } + + /** fetches the currently-executing javascript function */ + public JS.CompiledFunction getCurrentCompiledFunction() { return currentCompiledFunction; } + + + // Statics /////////////////////////////////////////////////////////////////////// + + private static Hashtable javaThreadToJSThread = new Hashtable(); + + /** returns the JS thread for a given Java thread, creating one if necessary */ + public static JS.Thread fromJavaThread(java.lang.Thread t) { + JS.Thread ret = (JS.Thread)javaThreadToJSThread.get(t); + if (ret == null) { + ret = new JS.Thread(); + ret.bindToCurrentJavaThread(); + } + return ret; + } + + } }