| /* --COPYRIGHT--,EPL |
| * Copyright (c) 2008 Texas Instruments and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * Texas Instruments - initial implementation |
| * |
| * --/COPYRIGHT--*/ |
| package xdc.services.intern.xsr; |
| |
| import java.util.Vector; |
| import java.util.LinkedHashMap; |
| import java.util.Iterator; |
| import java.util.HashMap; |
| import java.util.Collection; |
| |
| import org.mozilla.javascript.Context; |
| import org.mozilla.javascript.Function; |
| import org.mozilla.javascript.NativeJavaObject; |
| import org.mozilla.javascript.Scriptable; |
| import org.mozilla.javascript.Undefined; |
| |
| /* |
| * ======== Proto ======== |
| */ |
| public abstract class Proto extends XScriptO |
| implements Function |
| { |
| interface ObjRef {}; |
| public interface Pred{}; |
| interface Sealable {}; |
| |
| interface Aggregate { |
| Object create(Value prnt, String name, boolean ronly, Object initval, |
| boolean check); |
| } |
| |
| interface Embedded extends Aggregate {} |
| |
| public interface Typedef { |
| Proto getBase(); |
| Function getEncFxn(); |
| void init( String name, Object base, Object encFxn ); |
| } |
| |
| abstract Object assign( Object oldval, Object newval ); |
| abstract boolean assignable( Proto proto ); |
| |
| String toText( Object val ) |
| { |
| if (val == null) { |
| return "null"; |
| } |
| else if (val instanceof Undefined) { |
| return "undefined"; |
| } |
| else { |
| return val.toString(); |
| } |
| } |
| |
| static Object unwrap( Object o ) |
| { |
| return (o instanceof NativeJavaObject ? ((NativeJavaObject)o).unwrap() : o); |
| } |
| |
| int depth() { return 0; } |
| |
| // interface Function |
| |
| public Object call( Context cx, Scriptable scope, Scriptable thisObj, Object[] args ) |
| { |
| Err.exit("unsupported operation"); |
| return Context.getUndefinedValue(); |
| } |
| |
| public Scriptable construct( Context cx, Scriptable scope, Object[] args ) |
| { |
| Err.exit("unsupported operation"); |
| return null; |
| } |
| |
| // Proto.Adr |
| /* This type represents configuration parameters of pointer types */ |
| static public class Adr extends Proto |
| implements ObjRef, Pred |
| { |
| String sig; |
| boolean anyT; |
| boolean fxnT; |
| |
| public Adr( String sig, String code ) |
| { |
| this.sig = sig; |
| this.anyT = code.equals("Pv"); |
| this.fxnT = code.startsWith("PF"); |
| } |
| |
| Object assign( Object oldval, Object newval ) |
| { |
| newval = Proto.unwrap(newval); |
| if (newval == null || newval instanceof Undefined |
| || newval == Value.DEFAULT || newval == Value.NOGEN) { |
| return newval; |
| } |
| |
| // System.out.println("Proto.Adr.assign: (" + this.sig + ")" |
| // + this |
| // + " = (" + newval.getClass().getName() + ")" |
| // + newval); |
| if (this.anyT) { |
| |
| if (newval instanceof AnyType) { |
| return newval; |
| } |
| if (newval instanceof CharSequence || newval instanceof Number |
| || newval instanceof Boolean ) { |
| return newval; |
| } |
| } |
| |
| if (newval instanceof Value.Obj && this.sig.equals( |
| ((Value.Obj) newval).proto.name.replace('.', '_') + "*")) { |
| return newval; |
| } |
| |
| if (newval instanceof Extern) { |
| /* An Extern of the correct type can be assigned to a pointer |
| * config parameter. |
| */ |
| Extern ext = (Extern)newval; |
| if (ext.sig == null) { |
| /* This Extern is created by calling the operator $externPtr |
| * and the signature was set to 'null'. Now we know the |
| * signature of the pointer we are assigning too, so we |
| * should adjust the type. We use the pointer's type when |
| * 'newval' is a string starting with '&'. |
| */ |
| Extern typed = new Extern(ext.getName(), this.sig, |
| ext.isFxnT(), ext.isRaw()); |
| return ext.isFxnT() == this.isFxnT() ? typed : Value.ERROR; |
| } |
| else { |
| return this.sig.equals(ext.sig) ? newval : Value.ERROR; |
| } |
| } |
| |
| if (newval instanceof Ptr) { |
| return newval; |
| } |
| |
| /* This is the case where the assigned value is a string with the |
| * name of a global variable preceeded by '&'. That syntax works |
| * only for types that do not accept values of multiple types |
| * (this.anyT flags such types). If a config parameter of type Ptr |
| * is assigned "&label", it cannot mean a symbol 'label', because |
| * then we wouldn't be able to assign the string "&label" to that |
| * parameter, which is a valid value for Ptr. We have to use |
| * $externPtr when we mean "the symbol 'label'". Therefore, the |
| * IF statement that checks if anyT is true comes first, and it |
| * will catch any string, and treat it as a string. If anyT is |
| * false, the IF block below will convert a string that starts |
| * with '&' to an Extern. |
| * The type Fxn cannot accept strings, and anyT is always false |
| * for that type, so both syntaxes above can only mean "the symbol |
| * 'label'", and we accept them both in the following IF block. |
| * |
| * The implementation of the logic described here is based on the |
| * type we return from this function. In case of Ptr, we return a |
| * string and for Fxn, we return an Extern instance. Then, in |
| * gen/Config.java, in ptrToStr(), an Extern is always treated as |
| * a symbol, while a string is just copied and quoted. |
| */ |
| if (newval instanceof CharSequence) { |
| String s = newval.toString(); |
| if (s.startsWith("&") && s.length() > 1) { |
| if (s.matches(".*\\s.*")) { |
| return (Value.ERROR); |
| } |
| return new Extern(s.substring(1), this.sig, this.fxnT, |
| true); |
| } |
| } |
| |
| if (newval instanceof Addr) { |
| return ((Addr)newval).val == 0 ? null : newval; |
| } |
| /* |
| if (!this.anyT) { |
| return Value.ERROR; |
| } |
| |
| if (newval instanceof String || newval instanceof Number || newval instanceof Boolean ) { |
| return newval; |
| } |
| |
| if (newval instanceof Value || newval instanceof Enum || newval instanceof Extern) { |
| return newval; |
| } |
| */ |
| /* allow "config Bits8 *FOO = 0x32;" */ |
| if (newval instanceof Number) { |
| return newval; |
| } |
| |
| return Value.ERROR; |
| } |
| |
| boolean assignable( Proto proto ) |
| { |
| // TODO: fix this |
| return true; |
| } |
| |
| public final String getSig() { return this.sig; } |
| |
| public final boolean isAnyT() { return this.anyT; } |
| public final boolean isFxnT() { return this.fxnT; } |
| |
| String toText( Object val ) |
| { |
| if (val instanceof Value.Obj) { |
| return (String) ((Value.Obj) val).getDefaultValue(null); |
| } |
| else if (val instanceof Extern) { |
| Extern e = (Extern) val; |
| return e.name.startsWith("0x") ? e.name : "&" + e.name; |
| } |
| else if (val instanceof Number) { |
| return Proto.Elm.numval((Number) val); |
| } |
| else { |
| return super.toText(val); |
| } |
| } |
| } |
| |
| // Proto.Arr |
| |
| static public class Arr extends Proto |
| implements Aggregate, Embedded, Pred, Sealable |
| { |
| Proto base; |
| boolean lflag; |
| int dim; |
| int curid = 0; |
| |
| public Arr( Object base ) |
| { |
| this(base, true, -1); |
| } |
| |
| public Arr( Object base, boolean lflag ) |
| { |
| this(base, lflag, -1); |
| } |
| |
| public Arr( Object base, boolean lflag, Number dim ) |
| { |
| this(base, lflag, dim.intValue()); |
| } |
| |
| public Arr( Object base, boolean lflag, long dim ) |
| { |
| this(base, lflag, (int)dim); |
| } |
| |
| public Arr( Object base, boolean lflag, int dim ) |
| { |
| this.base = (Proto)base; |
| this.lflag = lflag; |
| this.dim = dim; |
| } |
| |
| Object assign( Object oldval, Object newval ) |
| { |
| newval = Proto.unwrap(newval); |
| |
| if (newval instanceof Undefined) { |
| newval = Value.DEFAULT; |
| } |
| |
| Value.Arr varr = (Value.Arr)oldval; |
| Object res; |
| |
| if (varr != null && varr.sealed(null)) { |
| varr.error("sealed array"); |
| } |
| |
| if (newval instanceof Value.Arr) { |
| if (!(this.assignable(((Value.Arr)newval).proto))) { |
| res = Value.ERROR; |
| } |
| else if (varr != null) { |
| varr.assignV(newval); |
| res = varr; |
| } |
| else { |
| res = newval; |
| } |
| } |
| |
| else if (newval instanceof Addr) { |
| varr.bind("$addr", new Long(((Addr)newval).val)); |
| res = varr; |
| } |
| |
| else if (newval instanceof Scriptable) { |
| if (varr == null) { |
| res = this.create(null, null, false, newval, true); |
| } |
| else { |
| varr.assignS((Scriptable)newval); |
| res = varr; |
| } |
| } |
| |
| else { |
| res = Value.ERROR; |
| } |
| |
| return res; |
| } |
| |
| boolean assignable( Proto proto ) |
| { |
| if (!(proto instanceof Proto.Arr)) { |
| return false; |
| } |
| |
| Proto.Arr parr = (Proto.Arr)proto; |
| return (this.base.assignable(parr.base)); |
| } |
| |
| public int depth() { return this.base.depth() + 1; } |
| |
| public final Proto getBase() { return this.base; } |
| public final int getDim() { return this.dim; } |
| public final boolean getLflag() { return this.lflag; } |
| |
| // interface Aggregate |
| |
| public Object create( Value prnt, String name, boolean ronly, Object initval, boolean check ) |
| { |
| Value.Arr varr = new Value.Arr(); |
| varr.init(this, prnt, name == null ? "[]#" + curid++ : name, ronly, initval, check); |
| return varr; |
| } |
| |
| // OVERRIDE Function |
| |
| public Scriptable construct( Context cx, Scriptable scope, Object[] args ) |
| { |
| return (Scriptable)this.create(null, null, false, args.length == 1 ? args[0] : Value.DEFAULT, true); |
| } |
| } |
| |
| // Proto.Elm |
| |
| static public class Elm extends Proto |
| { |
| Class cls; |
| String cast = null; |
| |
| static public Elm newBool() |
| { |
| Elm e = new Elm(); |
| e.cls = Boolean.class; |
| return e; |
| } |
| |
| static public Elm newCNum( String cast ) |
| { |
| Elm e = new Elm(); |
| e.cls = Number.class; |
| e.cast = cast; |
| return e; |
| } |
| |
| static public Elm newNum() |
| { |
| Elm e = new Elm(); |
| e.cls = Number.class; |
| return e; |
| } |
| |
| static public Elm newObj() |
| { |
| Elm e = new Elm(); |
| e.cls = Object.class; |
| return e; |
| } |
| |
| static public Elm newStr() |
| { |
| Elm e = new Elm(); |
| e.cls = String.class; |
| return e; |
| } |
| |
| static public String numval( Number num ) |
| { |
| long lg = num.longValue(); |
| double d = num.doubleValue(); |
| if (d != lg) { |
| return num.toString(); |
| } |
| else if (lg < 0) { |
| return "(-0x" + Long.toHexString(-(lg+1)) + " - 1)"; |
| } |
| else { |
| return "0x" + Long.toHexString(lg); |
| } |
| } |
| |
| Object assign( Object oldval, Object newval ) |
| { |
| newval = Proto.unwrap(newval); |
| |
| if (newval instanceof Enum) { |
| newval = ((Enum)newval).ival; |
| } |
| |
| if (this.cls.isInstance(newval) || newval instanceof Undefined) { |
| // fall through |
| } |
| else if (newval == null || newval == Value.DEFAULT) { |
| newval = |
| (cls == Number.class) ? (Object)(new Integer(0)) : |
| (cls == Boolean.class) ? (Object)(Boolean.FALSE) : |
| null; |
| } |
| else if (cls == Number.class && newval instanceof Boolean) { |
| boolean b = ((Boolean)newval).booleanValue(); |
| newval = b ? new Integer(1) : new Integer(0); |
| } |
| else if (cls == Boolean.class && newval instanceof Number) { |
| int i = ((Number)newval).intValue(); |
| newval = i != 0 ? Boolean.TRUE : Boolean.FALSE; |
| } |
| else if (cls == String.class && newval instanceof CharSequence) { |
| newval = newval.toString(); |
| } |
| else if (cls == String.class && newval instanceof Addr) { |
| newval = ((Addr)newval).val == 0 ? null : newval; |
| } |
| else { |
| return Value.ERROR; |
| } |
| |
| return newval; |
| } |
| |
| boolean assignable( Proto proto ) |
| { |
| return (proto instanceof Proto.Elm |
| && ((Proto.Elm)proto).cls == this.cls); |
| } |
| |
| public final String getCast() { return this.cast; } |
| |
| String toText( Object val ) |
| { |
| if (val instanceof Number) { |
| return Proto.Elm.numval((Number) val); |
| } |
| else { |
| return super.toText(val); |
| } |
| } |
| } |
| |
| // Proto.Enm |
| |
| static public class Enm extends Proto |
| { |
| String name; |
| HashMap valmap = new HashMap(); |
| |
| public Enm( String name ) |
| { |
| this.name = name; |
| } |
| |
| Object assign( Object oldval, Object newval ) |
| { |
| newval = Proto.unwrap(newval); |
| |
| if (newval instanceof Undefined) { |
| return newval; |
| } |
| else if (newval instanceof Enum && ((Enum)newval).proto == this) { |
| return newval; |
| } |
| else { |
| return Value.ERROR; |
| } |
| } |
| |
| boolean assignable( Proto proto ) |
| { |
| return this == proto; |
| } |
| } |
| |
| /** |
| * This is a prototype object for JavaScript functions. |
| */ |
| // Proto.Fxn |
| static public class Fxn extends Proto |
| { |
| Proto.Obj owner; |
| Proto ret; |
| int minargc; |
| boolean vflag; |
| Member[] args; |
| |
| static OpTab optab = new OpTab(Proto.Fxn.class, new String[] { |
| "addArg:$$arg" |
| }); |
| |
| public Fxn(Object owner, Object ret, int argc, int minargc, |
| boolean vflag) |
| { |
| this.owner = (Proto.Obj)owner; |
| this.ret = (Proto)ret; |
| this.minargc = minargc; |
| this.vflag = vflag; |
| this.args = new Member[argc]; |
| this.bindtab.putAll(Proto.Fxn.optab); |
| } |
| |
| Object assign( Object oldval, Object newval ) |
| { |
| return Value.ERROR; |
| } |
| |
| boolean assignable( Proto proto ) |
| { |
| return false; |
| } |
| |
| public void addArg( int idx, String name, Proto proto, Object defval ) |
| { |
| Member mbr = this.args[idx] = new Member(); |
| |
| mbr.name = name; |
| mbr.proto = proto; |
| mbr.defval = defval; |
| } |
| } |
| |
| // Proto.Map |
| |
| static public class Map extends Proto |
| implements Aggregate, Embedded, Sealable |
| { |
| Proto base; |
| int curid = 0; |
| |
| public Map( Object base ) |
| { |
| this.base = (Proto)base; |
| } |
| |
| Object assign( Object oldval, Object newval ) |
| { |
| newval = Proto.unwrap(newval); |
| |
| if (newval instanceof Undefined) { |
| newval = Value.DEFAULT; |
| } |
| |
| Value.Map vmap = (Value.Map)oldval; |
| Object res; |
| |
| if (vmap != null && vmap.sealed(null)) { |
| vmap.error("sealed map"); |
| } |
| |
| if (newval instanceof Value.Map) { |
| if (!(this.assignable(((Value.Map)newval).proto))) { |
| res = Value.ERROR; |
| } |
| else if (vmap != null) { |
| vmap.assignV(newval); |
| res = vmap; |
| } |
| else { |
| res = newval; |
| } |
| } |
| |
| else if (newval instanceof Scriptable) { |
| if (vmap == null) { |
| res = this.create(null, null, false, newval, true); |
| } |
| else { |
| vmap.assignS((Scriptable)newval); |
| res = vmap; |
| } |
| } |
| |
| else { |
| res = Value.ERROR; |
| } |
| |
| return res; |
| } |
| |
| boolean assignable( Proto proto ) |
| { |
| if (!(proto instanceof Proto.Map)) { |
| return false; |
| } |
| |
| Proto.Map pmap = (Proto.Map)proto; |
| return (this.base.assignable(pmap.base)); |
| } |
| |
| // interface Aggregate |
| |
| // interface Aggregate |
| |
| public Object create( Value prnt, String name, boolean ronly, Object initval, boolean check ) |
| { |
| Value.Map map = new Value.Map(); |
| map.init(this, prnt, name == null ? "{}#" + curid++ : name, ronly, initval, check); |
| return map; |
| } |
| |
| // OVERRIDE Function |
| |
| public Scriptable construct( Context cx, Scriptable scope, Object[] args ) |
| { |
| return (Scriptable)this.create(null, null, false, args.length == 1 ? args[0] : Value.DEFAULT, true); |
| } |
| } |
| |
| // Proto.Obj |
| |
| static public class Obj extends Proto |
| implements Aggregate, Function, ObjRef |
| { |
| static OpTab optab = new OpTab(Proto.Obj.class, new String[] { |
| "addFld:$$fld", |
| "addFldV:$$fldv", |
| "addFxn:$$fxn", |
| "init:$$init", |
| "make:$$make", |
| "patchFxn:$patch" |
| }); |
| |
| static int curkey = 0; |
| |
| String name; |
| Proto.Obj sup; |
| int key; |
| int curid = 0; |
| int fldcnt = 0; |
| |
| /* mbrlist holds a list of all properties, while fldlist does |
| * not contain functions |
| */ |
| LinkedHashMap<String,Member> mbrlist = new LinkedHashMap(); |
| LinkedHashMap<String,Member> fldlist = new LinkedHashMap(); |
| |
| public Obj() |
| { |
| this.bindtab.putAll(Proto.Obj.optab); |
| } |
| |
| public void addFld( String name, Proto proto, Object defval, String flags ) |
| { |
| addFldV(name, proto, defval, flags, null, null); |
| } |
| |
| public void addFldV( String name, Proto proto, Object defval, String flags, Object getter, Object setter ) |
| { |
| Member mbr = (Member)this.mbrlist.get(name); |
| |
| if (mbr == null) { |
| mbr = new Member(); |
| mbr.name = name; |
| mbr.idx = this.fldcnt++; |
| mbr.owner = this; |
| } |
| else { |
| try { |
| mbr = (Member)mbr.clone(); |
| } |
| catch (Exception e) { Err.exit(e); } |
| } |
| |
| mbr.proto = proto; |
| mbr.defval = defval; |
| mbr.getter = (Function)getter; |
| mbr.setter = (Function)setter; |
| mbr.hflag = flags.indexOf('h') != -1; |
| mbr.rflag = flags.indexOf('r') != -1; |
| |
| this.mbrlist.put(name, mbr); |
| this.fldlist.put(name, mbr); |
| } |
| |
| public void addFxn( String name, Proto.Fxn proto, Object ofxn ) |
| { |
| if (!(ofxn instanceof Function)) { |
| return; |
| } |
| |
| Member mbr = new Member(); |
| |
| mbr.name = name; |
| mbr.proto = proto; |
| mbr.owner = proto.owner == null ? this : proto.owner; |
| mbr.defval = new Invoke(name, (Function)ofxn, this, proto); |
| |
| this.mbrlist.put(name, mbr); |
| } |
| |
| public Collection<Member> allFlds() |
| { |
| return this.fldlist.values(); |
| } |
| |
| Object assign( Object oldval, Object newval ) |
| { |
| newval = Proto.unwrap(newval); |
| |
| if (newval == null || newval instanceof Undefined) { |
| return newval; |
| } |
| else if (newval instanceof Value.Obj) { |
| return this.cast((Value.Obj)newval); |
| } |
| else if (newval == Value.DEFAULT) { /// necessary??? |
| return Context.getUndefinedValue(); |
| } |
| else if (newval instanceof Addr) { |
| return ((Addr)newval).val == 0 ? null : newval; |
| } |
| else if (newval instanceof XScriptO || !(newval instanceof Scriptable)) { |
| return Value.ERROR; |
| } |
| else { |
| return this.create(null, null, false, (Scriptable)newval, true); |
| } |
| } |
| |
| boolean assignable( Proto proto ) |
| { |
| if (!(proto instanceof Proto.Obj)) { |
| return false; |
| } |
| |
| for (Proto.Obj pobj = (Proto.Obj)proto; pobj != null; pobj = pobj.sup) { |
| if (pobj == this) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| Object cast( Value.Obj vobj ) |
| { |
| for (Proto.Obj pobj = (Proto.Obj)vobj.orig.proto; pobj != null; pobj = pobj.sup) { |
| if (pobj == this) { |
| return vobj.castTo(pobj); |
| } |
| } |
| |
| return Value.ERROR; |
| } |
| |
| String compat( Scriptable sobj ) /// FIX: pre-filter for arrays, etc. |
| { |
| Object[] ids = sobj.getIds(); |
| for (int i = 0; i < ids.length; i++) { |
| if (!this.fldlist.containsKey(ids[i])) { |
| return ids[i].toString(); |
| } |
| } |
| return null; |
| } |
| |
| Object[] getMbrIds( String pre ) |
| { |
| Vector idvec = new Vector(); |
| |
| for (Iterator it = this.fldlist.keySet().iterator(); it.hasNext(); ) { |
| String key = (String)it.next(); |
| if (pre == null || !key.startsWith(pre)) { |
| idvec.add(key); |
| } |
| } |
| |
| return idvec.toArray(); |
| } |
| |
| public final String getName() { return this.name; } |
| public final Proto.Obj getSuper() { return this.sup; } |
| |
| public Proto.Obj init( String name, Object sup ) { return this.init(name, sup, false); } |
| public Proto.Obj init( String name, Object sup, boolean newflg ) |
| { |
| this.name = name; |
| this.sup = (Proto.Obj)sup; |
| this.key = Proto.Obj.curkey++; |
| |
| this.setName(name); |
| |
| if (sup != null) { |
| this.mbrlist.putAll(this.sup.mbrlist); |
| this.fldlist.putAll(this.sup.fldlist); |
| this.fldcnt = this.sup.fldcnt; |
| } |
| |
| return this; |
| } |
| |
| Object lookupBind( String name ) |
| { |
| this.errflg = false; |
| |
| Object res = this.get(name, this); |
| if (res == NOT_FOUND && this.sup != null) { |
| res = this.sup.lookupBind(name); |
| } |
| |
| this.errflg = true; |
| return res; |
| } |
| |
| public Member lookupFld( String name ) |
| { |
| return (Member)this.fldlist.get(name); |
| } |
| |
| public Member lookupMbr( String name, Proto.Obj proto ) |
| { |
| Member mbr = (Member)this.mbrlist.get(name); |
| return (mbr != null && mbr.owner.key <= proto.key) ? mbr : null; |
| } |
| |
| public Object make() |
| { |
| return this.create(null, null, false, Value.DEFAULT, false); |
| } |
| |
| public void patchFxn( String name, Function newFxn ) |
| { |
| Member mbr = (Member)this.mbrlist.get(name); |
| if (mbr == null || !(mbr.defval instanceof Invoke)) { |
| return; |
| } |
| |
| Invoke inv = (Invoke)mbr.defval; |
| this.addFxn(name, (Proto.Fxn)mbr.proto, new Patch(inv.fxn, newFxn)); |
| } |
| |
| public String tname() |
| { |
| return this.name; |
| } |
| |
| // OVERRIDE Scriptable |
| |
| /* |
| * ======== Proto.Obj.get ======== |
| */ |
| public Object get( String name, Scriptable start ) |
| { |
| Member mbr = (Member)this.mbrlist.get(name); |
| return (mbr != null) ? mbr.defval : super.get(name, start); |
| } |
| |
| public Object getDefaultValue( java.lang.Class hint ) |
| { |
| return this.name; |
| } |
| |
| /* |
| * ======== Proto.Obj.has ======== |
| */ |
| public boolean has( String name, Scriptable start ) |
| { |
| Member mbr = (Member)this.mbrlist.get(name); |
| if (mbr != null) { |
| return (true); |
| } |
| else { |
| return (super.has(name, start)); |
| } |
| } |
| |
| public boolean hasInstance( Scriptable value ) |
| { |
| return value instanceof Value.Obj ? this.assignable(((Value.Obj)value).orig.proto) : false; |
| } |
| |
| // OVERRIDE Function |
| |
| public Object call( Context cx, Scriptable scope, Scriptable thisObj, Object[] args ) |
| { |
| if (args.length == 0) { |
| Err.exit("an object argument is required"); |
| return Context.getUndefinedValue(); |
| } |
| |
| Value.Obj vobj; |
| |
| if (args[0] instanceof Value.Obj) { |
| vobj = (Value.Obj)args[0]; |
| } |
| else { |
| Err.exit("an object argument is required"); |
| return Context.getUndefinedValue(); |
| } |
| |
| if (vobj == null) { |
| return null; |
| } |
| for (Proto.Obj pobj = (Proto.Obj)vobj.orig.proto; pobj != null; pobj = pobj.sup) { |
| if (pobj == this) { |
| return vobj.castTo(pobj); |
| } |
| } |
| |
| return Context.getUndefinedValue(); |
| } |
| |
| // interface Aggregate |
| |
| public Object create( Value prnt, String name, boolean ronly, |
| Object initval, boolean check ) |
| { |
| if (initval == null || initval instanceof Undefined) { |
| return initval; |
| } |
| else { |
| String ns = (name == null) ? (this.name + '#' + this.curid++) |
| : name; |
| Value.Obj vobj = new Value.Obj(ns, this); |
| vobj.init(this, prnt, ns, ronly, initval, check); |
| return vobj; |
| } |
| } |
| } |
| |
| // Proto.Str |
| |
| static public class Str extends Proto |
| implements Aggregate, Embedded, ObjRef, Pred, Sealable |
| { |
| static OpTab optab = new OpTab(Proto.Str.class, new String[] { |
| "make:$$make", |
| }); |
| |
| Proto.Obj base; |
| boolean metaonly; |
| Vector newvec; |
| |
| public Str( Proto.Obj base ) |
| { |
| this(base, true); |
| this.setName(base.name); |
| } |
| |
| public Str( Proto.Obj base, boolean metaonly ) |
| { |
| this.base = base; |
| this.metaonly = metaonly; |
| this.newvec = new Vector(); |
| this.bindtab.putAll(Proto.Str.optab); |
| } |
| |
| public final Proto getBase() { |
| return this.base; |
| } |
| |
| /* This function is invoked when a function is called and one of the |
| * function's typed parameters is a structure type, or in case of a |
| * typed assignment to a variable of a structure type. |
| * In the first case, oldval is 'null'. |
| */ |
| Object assign( Object oldval, Object newval ) |
| { |
| newval = Proto.unwrap(newval); |
| |
| if (newval instanceof Undefined) { |
| newval = Value.DEFAULT; |
| } |
| |
| if (oldval == null) { |
| /* primitive types are not allowed */ |
| if (!(newval instanceof Scriptable)) { |
| return (Value.ERROR); |
| } |
| return this.create(null, null, false, newval, true); |
| } |
| |
| Value.Obj vobj = (Value.Obj)oldval; |
| Object res = vobj; |
| |
| if (vobj.sealed(null)) { |
| vobj.error("sealed object"); |
| } |
| |
| if (newval == null) { |
| vobj.error("illegal assignment of 'null'"); |
| res = Value.ERROR; |
| } |
| else if (newval instanceof Value.Obj) { |
| Object oval = this.base.cast((Value.Obj)newval); |
| if (oval == Value.ERROR) { |
| vobj.error("incompatible assignment"); |
| res = Value.ERROR; |
| } |
| else { |
| vobj.assignV((Value.Obj)oval); |
| } |
| } |
| else if (newval instanceof XScriptO && newval != Value.DEFAULT || !(newval instanceof Scriptable)) { |
| vobj.error("incompatible assignment: " + newval); |
| res = Value.ERROR; |
| } |
| else { |
| vobj.assignS((Scriptable)newval); |
| } |
| |
| return res; |
| } |
| |
| boolean assignable( Proto proto ) |
| { |
| return proto instanceof Proto.Str ? this.base.assignable(((Proto.Str)proto).base) : false; |
| } |
| |
| public Object make( Object prnt, String name ) |
| { |
| return this.create((Value)prnt, name, false, Value.DEFAULT, false); |
| } |
| |
| public Object newInstance() |
| { |
| Value.Obj vobj = (Value.Obj)this.create(null, null, false, Value.DEFAULT, true); |
| vobj.bind("$category", "Struct"); |
| |
| return vobj; |
| } |
| |
| // OVERRIDE scriptable |
| |
| public boolean hasInstance( Scriptable value ) |
| { |
| return this.base.hasInstance(value); |
| } |
| |
| // OVERRIDE function |
| |
| public Scriptable construct( Context cx, Scriptable scope, Object[] args ) |
| { |
| Value.Obj vobj = (Value.Obj)this.create(null, null, false, args.length == 1 ? args[0] : Value.DEFAULT, true); |
| vobj.bind("$category", "Struct"); |
| |
| return vobj; |
| } |
| |
| // interface Aggregate |
| |
| public Object create( Value prnt, String name, boolean ronly, Object initval, boolean check ) |
| { |
| if (initval == null) { |
| Err.exit("illegal assignment of 'null'"); |
| return Value.ERROR; |
| } |
| |
| if (initval instanceof Undefined) { |
| initval = Value.DEFAULT; |
| } |
| |
| Value.Obj vobj = (Value.Obj)this.base.create(prnt, name, ronly, initval, check); |
| |
| if (!this.metaonly && name == null) { |
| this.newvec.add(vobj); |
| } |
| |
| return vobj; |
| } |
| } |
| |
| // Proto.Tag |
| |
| static public class Tag extends Proto |
| implements Aggregate, Embedded, Pred, Sealable, Typedef |
| { |
| static OpTab optab = new OpTab(Proto.Tag.class, new String[] { |
| "init:$$init", |
| }); |
| |
| String name; |
| Proto base; |
| Function encFxn; |
| |
| public Tag() |
| { |
| this.bindtab.putAll(Proto.Tag.optab); |
| } |
| |
| Object assign( Object oldval, Object newval ) |
| { |
| return this.base.assign(oldval, newval); |
| } |
| |
| boolean assignable( Proto proto ) |
| { |
| return this.base.assignable(proto); |
| } |
| |
| public Object create( Value prnt, String name, boolean ronly, Object initval, boolean check ) |
| { |
| return ((Aggregate)this.base).create(prnt, name, ronly, initval, check); |
| } |
| |
| int depth() { return this.base.depth(); } |
| |
| public Proto getBase() { return this.base; } |
| public Function getEncFxn() { return this.encFxn; } |
| |
| public void init( String name, Object base, Object encFxn ) |
| { |
| this.name = name; |
| this.base = (Proto)base; |
| this.encFxn = encFxn == null || encFxn instanceof Undefined ? null : (Function)encFxn; |
| } |
| } |
| |
| // Proto.Tel |
| |
| static public class Tel extends Proto |
| implements Pred, Typedef |
| { |
| static OpTab optab = new OpTab(Proto.Tel.class, new String[] { |
| "init:$$init", |
| }); |
| |
| String name; |
| Proto base; |
| Function encFxn; |
| |
| public Tel() |
| { |
| this.bindtab.putAll(Proto.Tel.optab); |
| } |
| |
| Object assign( Object oldval, Object newval ) |
| { |
| return this.base.assign(oldval, newval); |
| } |
| |
| boolean assignable( Proto proto ) |
| { |
| return this.base.assignable(proto); |
| } |
| |
| public Proto getBase() { return this.base; } |
| public Function getEncFxn() { return this.encFxn; } |
| |
| public void init( String name, Object base, Object encFxn ) |
| { |
| this.name = name; |
| this.base = (Proto)base; |
| this.encFxn = encFxn == null || encFxn instanceof Undefined ? null : (Function)encFxn; |
| } |
| |
| // OVERRIDE scriptable |
| |
| public boolean hasInstance( Scriptable value ) |
| { |
| return this.base.hasInstance(value); |
| } |
| } |
| } |
