public IRFactory(TokenStream ts, Scriptable scope) {

this.ts = ts;

this.scope = scope;

}

/**

public Object createScript(Object body, String sourceName,

int baseLineno, int endLineno, Object source)

{

Node result = new Node(TokenStream.SCRIPT, sourceName);

Node children = ((Node) body).getFirstChild();

if (children != null)

result.addChildrenToBack(children);

result.putProp(Node.SOURCENAME_PROP, sourceName);

result.putProp(Node.BASE_LINENO_PROP, new Integer(baseLineno));

result.putProp(Node.END_LINENO_PROP, new Integer(endLineno));

if (source != null)

result.putProp(Node.SOURCE_PROP, source);

return result;

}

/**

public Object createLeaf(int nodeType) {

return new Node(nodeType);

}

public Object createLeaf(int nodeType, String id) {

return new Node(nodeType, id);

}

public Object createLeaf(int nodeType, int nodeOp) {

return new Node(nodeType, new Integer(nodeOp));

}

/**

public Object createSwitch(int lineno) {

return new Node(TokenStream.SWITCH, new Integer(lineno));

}

public Object createVariables(int lineno) {

return new Node(TokenStream.VAR, new Integer(lineno));

}

public Object createExprStatement(Object expr, int lineno) {

return new Node(TokenStream.EXPRSTMT, (Node) expr, new Integer(lineno));

}

/**

public Object createName(String name) {

return new Node(TokenStream.NAME, name);

}

/**

public Object createString(String string) {

return new Node(TokenStream.STRING, string);

}

/**

public Object createNumber(Number number) {

return new Node(TokenStream.NUMBER, number);

}

/**

public Object createCatch(String varName, Object catchCond, Object stmts,

int lineno)

{

if (catchCond == null)

catchCond = new Node(TokenStream.PRIMARY,

new Integer(TokenStream.TRUE));

Node result = new Node(TokenStream.CATCH, (Node)createName(varName),

(Node)catchCond, (Node)stmts);

result.setDatum(new Integer(lineno));

return result;

}

/**

public Object createThrow(Object expr, int lineno) {

return new Node(TokenStream.THROW, (Node)expr, new Integer(lineno));

}

/**

public Object createReturn(Object expr, int lineno) {

return expr == null

? new Node(TokenStream.RETURN, new Integer(lineno))

: new Node(TokenStream.RETURN, (Node)expr, new Integer(lineno));

}

/**

public Object createLabel(String label, int lineno) {

Node result = new Node(TokenStream.LABEL, new Integer(lineno));

Node name = new Node(TokenStream.NAME, label);

result.addChildToBack(name);

return result;

}

/**

public Object createBreak(String label, int lineno) {

Node result = new Node(TokenStream.BREAK, new Integer(lineno));

if (label == null) {

return result;

} else {

Node name = new Node(TokenStream.NAME, label);

result.addChildToBack(name);

return result;

}

}

/**

public Object createContinue(String label, int lineno) {

Node result = new Node(TokenStream.CONTINUE, new Integer(lineno));

if (label == null) {

return result;

} else {

Node name = new Node(TokenStream.NAME, label);

result.addChildToBack(name);

return result;

}

}

/**

public Object createBlock(int lineno) {

return new Node(TokenStream.BLOCK, new Integer(lineno));

}

public Object createFunctionNode(String name, Object args,

Object statements)

{

if (name == null)

name = "";

return new FunctionNode(name, (Node) args, (Node) statements);

}

public Object createFunction(String name, Object args, Object statements,

String sourceName, int baseLineno,

int endLineno, Object source,

boolean isExpr)

{

FunctionNode f = (FunctionNode) createFunctionNode(name, args,

statements);

f.setFunctionType(isExpr ? FunctionNode.FUNCTION_EXPRESSION

: FunctionNode.FUNCTION_STATEMENT);

f.putProp(Node.SOURCENAME_PROP, sourceName);

f.putProp(Node.BASE_LINENO_PROP, new Integer(baseLineno));

f.putProp(Node.END_LINENO_PROP, new Integer(endLineno));

if (source != null)

f.putProp(Node.SOURCE_PROP, source);

Node result = new Node(TokenStream.FUNCTION, name);

result.putProp(Node.FUNCTION_PROP, f);

return result;

}

public void setFunctionExpressionStatement(Object o) {

Node n = (Node) o;

FunctionNode f = (FunctionNode) n.getProp(Node.FUNCTION_PROP);

f.setFunctionType(FunctionNode.FUNCTION_EXPRESSION_STATEMENT);

}

/**

public void addChildToBack(Object parent, Object child) {

((Node)parent).addChildToBack((Node)child);

}

/**

public Object createWhile(Object cond, Object body, int lineno) {

// Just add a GOTO to the condition in the do..while

Node result = (Node) createDoWhile(body, cond, lineno);

Node condTarget = (Node) result.getProp(Node.CONTINUE_PROP);

Node GOTO = new Node(TokenStream.GOTO);

GOTO.putProp(Node.TARGET_PROP, condTarget);

result.addChildToFront(GOTO);

return result;

}

/**

public Object createDoWhile(Object body, Object cond, int lineno) {

Node result = new Node(TokenStream.LOOP, new Integer(lineno));

Node bodyTarget = new Node(TokenStream.TARGET);

Node condTarget = new Node(TokenStream.TARGET);

Node IFEQ = new Node(TokenStream.IFEQ, (Node)cond);

IFEQ.putProp(Node.TARGET_PROP, bodyTarget);

Node breakTarget = new Node(TokenStream.TARGET);

result.addChildToBack(bodyTarget);

result.addChildrenToBack((Node)body);

result.addChildToBack(condTarget);

result.addChildToBack(IFEQ);

result.addChildToBack(breakTarget);

result.putProp(Node.BREAK_PROP, breakTarget);

result.putProp(Node.CONTINUE_PROP, condTarget);

return result;

}

/**

public Object createFor(Object init, Object test, Object incr,

Object body, int lineno)

{

if (((Node) test).getType() == TokenStream.VOID) {

test = new Node(TokenStream.PRIMARY,

new Integer(TokenStream.TRUE));

}

Node result = (Node)createWhile(test, body, lineno);

Node initNode = (Node) init;

if (initNode.getType() != TokenStream.VOID) {

if (initNode.getType() != TokenStream.VAR)

initNode = new Node(TokenStream.POP, initNode);

result.addChildToFront(initNode);

}

Node condTarget = (Node)result.getProp(Node.CONTINUE_PROP);

Node incrTarget = new Node(TokenStream.TARGET);

result.addChildBefore(incrTarget, condTarget);

if (((Node) incr).getType() != TokenStream.VOID) {

incr = createUnary(TokenStream.POP, incr);

result.addChildAfter((Node)incr, incrTarget);

}

result.putProp(Node.CONTINUE_PROP, incrTarget);

return result;

}

/**

public Object createForIn(Object lhs, Object obj, Object body, int lineno) {

String name;

Node lhsNode = (Node) lhs;

Node objNode = (Node) obj;

int type = lhsNode.getType();

Node lvalue = lhsNode;

switch (type) {

case TokenStream.NAME:

case TokenStream.GETPROP:

case TokenStream.GETELEM:

break;

case TokenStream.VAR:

/*

Node lastChild = lhsNode.getLastChild();

if (lhsNode.getFirstChild() != lastChild) {

reportError("msg.mult.index");

}

lvalue = new Node(TokenStream.NAME, lastChild.getString());

break;

default:

reportError("msg.bad.for.in.lhs");

return objNode;

}

Node init = new Node(TokenStream.ENUMINIT, objNode);

Node next = new Node(TokenStream.ENUMNEXT);

next.putProp(Node.ENUM_PROP, init);

Node temp = createNewTemp(next);

Node cond = new Node(TokenStream.EQOP, new Integer(TokenStream.NE));

cond.addChildToBack(temp);

cond.addChildToBack(new Node(TokenStream.PRIMARY,

new Integer(TokenStream.NULL)));

Node newBody = new Node(TokenStream.BLOCK);

Node assign = (Node) createAssignment(TokenStream.NOP, lvalue,

createUseTemp(temp), null,

false);

newBody.addChildToBack(new Node(TokenStream.POP, assign));

newBody.addChildToBack((Node) body);

Node result = (Node) createWhile(cond, newBody, lineno);

result.addChildToFront(init);

if (type == TokenStream.VAR)

result.addChildToFront(lhsNode);

Node done = new Node(TokenStream.ENUMDONE);

done.putProp(Node.ENUM_PROP, init);

result.addChildToBack(done);

return result;

}

/**

public Object createTryCatchFinally(Object tryblock, Object catchblocks,

Object finallyblock, int lineno)

{

Node trynode = (Node)tryblock;

// short circuit

if (trynode.getType() == TokenStream.BLOCK && !trynode.hasChildren())

return trynode;

Node pn = new Node(TokenStream.TRY, trynode, new Integer(lineno));

Node catchNodes = (Node)catchblocks;

boolean hasCatch = catchNodes.hasChildren();

boolean hasFinally = false;

Node finallyNode = null;

Node finallyTarget = null;

if (finallyblock != null) {

finallyNode = (Node)finallyblock;

hasFinally = (finallyNode.getType() != TokenStream.BLOCK

|| finallyNode.hasChildren());

if (hasFinally) {

// make a TARGET for the finally that the tcf node knows about

finallyTarget = new Node(TokenStream.TARGET);

pn.putProp(Node.FINALLY_PROP, finallyTarget);

// add jsr finally to the try block

Node jsrFinally = new Node(TokenStream.JSR);

jsrFinally.putProp(Node.TARGET_PROP, finallyTarget);

pn.addChildToBack(jsrFinally);

}

}

// short circuit

if (!hasFinally && !hasCatch) // bc finally might be an empty block...

return trynode;

Node endTarget = new Node(TokenStream.TARGET);

Node GOTOToEnd = new Node(TokenStream.GOTO);

GOTOToEnd.putProp(Node.TARGET_PROP, endTarget);

pn.addChildToBack(GOTOToEnd);

if (hasCatch) {

/*

// make a TARGET for the catch that the tcf node knows about

Node catchTarget = new Node(TokenStream.TARGET);

pn.putProp(Node.TARGET_PROP, catchTarget);

// mark it

pn.addChildToBack(catchTarget);

// get the exception object and store it in a temp

Node exn = createNewLocal(new Node(TokenStream.VOID));

pn.addChildToBack(new Node(TokenStream.POP, exn));

Node endCatch = new Node(TokenStream.TARGET);

// add [jsr finally?] goto end to each catch block

// expects catchNode children to be (cond block) pairs.

Node cb = catchNodes.getFirstChild();

while (cb != null) {

Node catchStmt = new Node(TokenStream.BLOCK);

int catchLineNo = ((Integer)cb.getDatum()).intValue();

Node name = cb.getFirstChild();

Node cond = name.getNextSibling();

Node catchBlock = cond.getNextSibling();

cb.removeChild(name);

cb.removeChild(cond);

cb.removeChild(catchBlock);

Node newScope = createNewLocal(new Node(TokenStream.NEWSCOPE));

Node initScope = new Node(TokenStream.SETPROP, newScope,

new Node(TokenStream.STRING,

name.getString()),

createUseLocal(exn));

catchStmt.addChildToBack(new Node(TokenStream.POP, initScope));

catchBlock.addChildToBack(new Node(TokenStream.LEAVEWITH));

Node GOTOToEndCatch = new Node(TokenStream.GOTO);

GOTOToEndCatch.putProp(Node.TARGET_PROP, endCatch);

catchBlock.addChildToBack(GOTOToEndCatch);

Node ifStmt = (Node) createIf(cond, catchBlock, null, catchLineNo);

// Try..catch produces "with" code in order to limit

// the scope of the exception object.

// OPT: We should be able to figure out the correct

// scoping at compile-time and avoid the

// runtime overhead.

Node withStmt = (Node) createWith(createUseLocal(newScope),

ifStmt, catchLineNo);

catchStmt.addChildToBack(withStmt);

pn.addChildToBack(catchStmt);

// move to next cb

cb = cb.getNextSibling();

}

// Generate code to rethrow if no catch clause was executed

Node rethrow = new Node(TokenStream.THROW, createUseLocal(exn));

pn.addChildToBack(rethrow);

pn.addChildToBack(endCatch);

// add a JSR finally if needed

if (hasFinally) {

Node jsrFinally = new Node(TokenStream.JSR);

jsrFinally.putProp(Node.TARGET_PROP, finallyTarget);

pn.addChildToBack(jsrFinally);

Node GOTO = new Node(TokenStream.GOTO);

GOTO.putProp(Node.TARGET_PROP, endTarget);

pn.addChildToBack(GOTO);

}

}

if (hasFinally) {

pn.addChildToBack(finallyTarget);

Node returnTemp = createNewLocal(new Node(TokenStream.VOID));

Node popAndMake = new Node(TokenStream.POP, returnTemp);

pn.addChildToBack(popAndMake);

pn.addChildToBack(finallyNode);

Node ret = createUseLocal(returnTemp);

// add the magic prop that makes it output a RET

ret.putProp(Node.TARGET_PROP, Boolean.TRUE);

pn.addChildToBack(ret);

}

pn.addChildToBack(endTarget);

return pn;

}

/**

/**

public Object createWith(Object obj, Object body, int lineno) {

Node result = new Node(TokenStream.BLOCK, new Integer(lineno));

result.addChildToBack(new Node(TokenStream.ENTERWITH, (Node)obj));

Node bodyNode = new Node(TokenStream.WITH, (Node) body,

new Integer(lineno));

result.addChildrenToBack(bodyNode);

result.addChildToBack(new Node(TokenStream.LEAVEWITH));

return result;

}

/**

public Object createArrayLiteral(Object obj) {

Node array;

Node result;

array = result = new Node(TokenStream.NEW,

new Node(TokenStream.NAME, "Array"));

Node temp = createNewTemp(result);

result = temp;

java.util.Enumeration children = ((Node) obj).getChildIterator();

Node elem = null;

int i = 0;

while (children.hasMoreElements()) {

elem = (Node) children.nextElement();

if (elem.getType() == TokenStream.PRIMARY &&

elem.getInt() == TokenStream.UNDEFINED)

{

i++;

continue;

}

Node addelem = new Node(TokenStream.SETELEM, createUseTemp(temp),

new Node(TokenStream.NUMBER,

new Integer(i)),

elem);

i++;

result = new Node(TokenStream.COMMA, result, addelem);

}

/*

if (Context.getContext().getLanguageVersion() == Context.VERSION_1_2) {

/* When last array element is empty, we need to set the

if (elem != null &&

elem.getType() == TokenStream.PRIMARY &&

elem.getInt() == TokenStream.UNDEFINED)

{

Node setlength = new Node(TokenStream.SETPROP,

createUseTemp(temp),

new Node(TokenStream.STRING,

"length"),

new Node(TokenStream.NUMBER,

new Integer(i)));

result = new Node(TokenStream.COMMA, result, setlength);

}

} else {

array.addChildToBack(new Node(TokenStream.NUMBER,

new Integer(i)));

}

return new Node(TokenStream.COMMA, result, createUseTemp(temp));

}

/**

public Object createObjectLiteral(Object obj) {

Node result = new Node(TokenStream.NEW, new Node(TokenStream.NAME,

"Object"));

Node temp = createNewTemp(result);

result = temp;

java.util.Enumeration children = ((Node) obj).getChildIterator();

while (children.hasMoreElements()) {

Node elem = (Node)children.nextElement();

int op = (elem.getType() == TokenStream.NAME)

? TokenStream.SETPROP

: TokenStream.SETELEM;

Node addelem = new Node(op, createUseTemp(temp),

elem, (Node)children.nextElement());

result = new Node(TokenStream.COMMA, result, addelem);

}

return new Node(TokenStream.COMMA, result, createUseTemp(temp));

}

/**

public Object createRegExp(String string, String flags) {

return flags.length() == 0

? new Node(TokenStream.OBJECT,

new Node(TokenStream.STRING, string))

: new Node(TokenStream.OBJECT,

new Node(TokenStream.STRING, string),

new Node(TokenStream.STRING, flags));

}

/**

public Object createIf(Object cond, Object ifTrue, Object ifFalse,

int lineno)

{

Node result = new Node(TokenStream.BLOCK, new Integer(lineno));

Node ifNotTarget = new Node(TokenStream.TARGET);

Node IFNE = new Node(TokenStream.IFNE, (Node) cond);

IFNE.putProp(Node.TARGET_PROP, ifNotTarget);

result.addChildToBack(IFNE);

result.addChildrenToBack((Node)ifTrue);

if (ifFalse != null) {

Node GOTOToEnd = new Node(TokenStream.GOTO);

Node endTarget = new Node(TokenStream.TARGET);

GOTOToEnd.putProp(Node.TARGET_PROP, endTarget);

result.addChildToBack(GOTOToEnd);

result.addChildToBack(ifNotTarget);

result.addChildrenToBack((Node)ifFalse);

result.addChildToBack(endTarget);

} else {

result.addChildToBack(ifNotTarget);

}

return result;

}

public Object createTernary(Object cond, Object ifTrue, Object ifFalse) {

return createIf(cond, ifTrue, ifFalse, -1);

}

/**

public Object createUnary(int nodeType, Object child) {

Node childNode = (Node) child;

if (nodeType == TokenStream.DELPROP) {

int childType = childNode.getType();

Node left;

Node right;

if (childType == TokenStream.NAME) {

// Transform Delete(Name "a")

// to Delete(Bind("a"), String("a"))

childNode.setType(TokenStream.BINDNAME);

left = childNode;

right = childNode.cloneNode();

right.setType(TokenStream.STRING);

} else if (childType == TokenStream.GETPROP ||

childType == TokenStream.GETELEM)

{

left = childNode.getFirstChild();

right = childNode.getLastChild();

childNode.removeChild(left);

childNode.removeChild(right);

} else {

return new Node(TokenStream.PRIMARY,

new Integer(TokenStream.TRUE));

}

return new Node(nodeType, left, right);

}

return new Node(nodeType, childNode);

}

public Object createUnary(int nodeType, int nodeOp, Object child) {

Node childNode = (Node) child;

int childType = childNode.getType();

if (nodeOp == TokenStream.TYPEOF &&

childType == TokenStream.NAME)

{

childNode.setType(TokenStream.TYPEOF);

return childNode;

}

if (nodeType == TokenStream.INC || nodeType == TokenStream.DEC) {

if (!hasSideEffects(childNode)

&& (nodeOp == TokenStream.POST)

&& (childType == TokenStream.NAME

|| childType == TokenStream.GETPROP

|| childType == TokenStream.GETELEM))

{

// if it's not a LHS type, createAssignment (below) will throw

// an exception.

return new Node(nodeType, childNode);

}

/*

// we have to use Double for now, because

// 0.0 and 1.0 are stored as dconst_[01],

// and using a Float creates a stack mismatch.

Node rhs = (Node) createNumber(new Double(1.0));

return createAssignment(nodeType == TokenStream.INC

? TokenStream.ADD

: TokenStream.SUB,

childNode,

rhs,

ScriptRuntime.NumberClass,

nodeOp == TokenStream.POST);

}

Node result = new Node(nodeType, new Integer(nodeOp));

result.addChildToBack((Node)child);

return result;

}

/**

public Object createBinary(int nodeType, Object left, Object right) {

Node temp;

switch (nodeType) {

case TokenStream.DOT:

nodeType = TokenStream.GETPROP;

Node idNode = (Node) right;

idNode.setType(TokenStream.STRING);

String id = idNode.getString();

if (id.equals("__proto__") || id.equals("__parent__")) {

Node result = new Node(nodeType, (Node) left);

result.putProp(Node.SPECIAL_PROP_PROP, id);

return result;

}

break;

case TokenStream.LB:

// OPT: could optimize to GETPROP iff string can't be a number

nodeType = TokenStream.GETELEM;

break;

*/

}

return new Node(nodeType, (Node)left, (Node)right);

}

public Object createBinary(int nodeType, int nodeOp, Object left,

Object right)

{

if (nodeType == TokenStream.ASSIGN) {

return createAssignment(nodeOp, (Node) left, (Node) right,

null, false);

}

return new Node(nodeType, (Node) left, (Node) right,

new Integer(nodeOp));

}

public Object createAssignment(int nodeOp, Node left, Node right,

Class convert, boolean postfix)

{

int nodeType = left.getType();

String idString;

Node id = null;

switch (nodeType) {

case TokenStream.NAME:

return createSetName(nodeOp, left, right, convert, postfix);

case TokenStream.GETPROP:

idString = (String) left.getProp(Node.SPECIAL_PROP_PROP);

if (idString != null)

id = new Node(TokenStream.STRING, idString);

/* fall through */

case TokenStream.GETELEM:

if (id == null)

id = left.getLastChild();

return createSetProp(nodeType, nodeOp, left.getFirstChild(),

id, right, convert, postfix);

default:

// TODO: This should be a ReferenceError--but that's a runtime

// exception. Should we compile an exception into the code?

reportError("msg.bad.lhs.assign");

return left;

}

}

private Node createConvert(Class toType, Node expr) {

if (toType == null)

return expr;

Node result = new Node(TokenStream.CONVERT, expr);

result.putProp(Node.TYPE_PROP, ScriptRuntime.NumberClass);

return result;

}

private Object createSetName(int nodeOp, Node left, Node right,

Class convert, boolean postfix)

{

if (nodeOp == TokenStream.NOP) {

left.setType(TokenStream.BINDNAME);

return new Node(TokenStream.SETNAME, left, right);

}

String s = left.getString();

if (s.equals("__proto__") || s.equals("__parent__")) {

Node result = new Node(TokenStream.SETPROP, left, right);

result.putProp(Node.SPECIAL_PROP_PROP, s);

return result;

}

Node opLeft = new Node(TokenStream.NAME, s);

if (convert != null)

opLeft = createConvert(convert, opLeft);

if (postfix)

opLeft = createNewTemp(opLeft);

Node op = new Node(nodeOp, opLeft, right);

Node lvalueLeft = new Node(TokenStream.BINDNAME, s);

Node result = new Node(TokenStream.SETNAME, lvalueLeft, op);

if (postfix) {

result = new Node(TokenStream.COMMA, result,

createUseTemp(opLeft));

}

return result;

}

public Node createNewTemp(Node n) {

int type = n.getType();

if (type == TokenStream.STRING || type == TokenStream.NUMBER) {

// Optimization: clone these values rather than storing

// and loading from a temp

return n;

}

Node result = new Node(TokenStream.NEWTEMP, n);

return result;

}

public Node createUseTemp(Node newTemp) {

int type = newTemp.getType();

if (type == TokenStream.NEWTEMP) {

Node result = new Node(TokenStream.USETEMP);

result.putProp(Node.TEMP_PROP, newTemp);

Integer n = (Integer) newTemp.getProp(Node.USES_PROP);

if (n == null) {

n = new Integer(1);

} else {

if (n.intValue() < Integer.MAX_VALUE)

n = new Integer(n.intValue() + 1);

}

newTemp.putProp(Node.USES_PROP, n);

return result;

}

return newTemp.cloneNode();

}

public Node createNewLocal(Node n) {

Node result = new Node(TokenStream.NEWLOCAL, n);

return result;

}

public Node createUseLocal(Node newLocal) {

int type = newLocal.getType();

if (type == TokenStream.NEWLOCAL) {

Node result = new Node(TokenStream.USELOCAL);

result.putProp(Node.LOCAL_PROP, newLocal);

return result;

}

return newLocal.cloneNode(); // what's this path for ?

}

public static boolean hasSideEffects(Node exprTree) {

switch (exprTree.getType()) {

case TokenStream.INC:

case TokenStream.DEC:

case TokenStream.SETPROP:

case TokenStream.SETELEM:

case TokenStream.SETNAME:

case TokenStream.CALL:

case TokenStream.NEW:

return true;

default:

Node child = exprTree.getFirstChild();

while (child != null) {

if (hasSideEffects(child))

return true;

else

child = child.getNextSibling();

}

break;

}

return false;

}

private Node createSetProp(int nodeType, int nodeOp, Node obj, Node id,

Node expr, Class convert, boolean postfix)

{

int type = nodeType == TokenStream.GETPROP

? TokenStream.SETPROP

: TokenStream.SETELEM;

Object datum = id.getDatum();

if (type == TokenStream.SETPROP && datum != null &&

datum instanceof String)

{

String s = (String) datum;

if (s.equals("__proto__") || s.equals("__parent__")) {

Node result = new Node(type, obj, expr);

result.putProp(Node.SPECIAL_PROP_PROP, s);

return result;

}

}

if (nodeOp == TokenStream.NOP)

return new Node(type, obj, id, expr);