+++ /dev/null
-/* -*- Mode: java; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-\r
- *\r
- * The contents of this file are subject to the Netscape Public\r
- * License Version 1.1 (the "License"); you may not use this file\r
- * except in compliance with the License. You may obtain a copy of\r
- * the License at http://www.mozilla.org/NPL/\r
- *\r
- * Software distributed under the License is distributed on an "AS\r
- * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express oqr\r
- * implied. See the License for the specific language governing\r
- * rights and limitations under the License.\r
- *\r
- * The Original Code is Rhino code, released\r
- * May 6, 1999.\r
- *\r
- * The Initial Developer of the Original Code is Netscape\r
- * Communications Corporation. Portions created by Netscape are\r
- * Copyright (C) 1997-1999 Netscape Communications Corporation. All\r
- * Rights Reserved.\r
- *\r
- * Contributor(s): \r
- * Norris Boyd\r
- * Roger Lawrence\r
- * Mike McCabe\r
- *\r
- * Alternatively, the contents of this file may be used under the\r
- * terms of the GNU Public License (the "GPL"), in which case the\r
- * provisions of the GPL are applicable instead of those above.\r
- * If you wish to allow use of your version of this file only\r
- * under the terms of the GPL and not to allow others to use your\r
- * version of this file under the NPL, indicate your decision by\r
- * deleting the provisions above and replace them with the notice\r
- * and other provisions required by the GPL. If you do not delete\r
- * the provisions above, a recipient may use your version of this\r
- * file under either the NPL or the GPL.\r
- */\r
-\r
-package org.mozilla.javascript;\r
-\r
-import java.util.Hashtable;\r
-import java.util.Stack;\r
-import java.util.Vector;\r
-\r
-/**\r
- * This class transforms a tree to a lower-level representation for codegen.\r
- *\r
- * @see Node\r
- * @author Norris Boyd\r
- */\r
-\r
-public class NodeTransformer {\r
- \r
- /**\r
- * Return new instance of this class. So that derived classes\r
- * can override methods of the transformer.\r
- */\r
- public NodeTransformer newInstance() {\r
- return new NodeTransformer();\r
- }\r
- \r
- public IRFactory createIRFactory(TokenStream ts, Scriptable scope) {\r
- return new IRFactory(ts, scope);\r
- }\r
-\r
- public Node transform(Node tree, Node enclosing, TokenStream ts,\r
- Scriptable scope) \r
- {\r
- loops = new Stack();\r
- loopEnds = new Stack();\r
- inFunction = tree.getType() == TokenStream.FUNCTION;\r
- if (!inFunction) {\r
- addVariables(tree, getVariableTable(tree));\r
- }\r
- irFactory = createIRFactory(ts, scope);\r
-\r
- // to save against upchecks if no finally blocks are used.\r
- boolean hasFinally = false;\r
-\r
- PreorderNodeIterator iterator = tree.getPreorderIterator();\r
- Node node;\r
- while ((node = iterator.nextNode()) != null) {\r
- int type = node.getType();\r
-\r
- typeswitch:\r
- switch (type) {\r
-\r
- case TokenStream.FUNCTION:\r
- if (node == tree) {\r
- // Add the variables to variable table, the\r
- // parameters were added earlier.\r
- VariableTable vars = getVariableTable(tree);\r
- addVariables(tree, vars);\r
-\r
- // Add return to end if needed.\r
- Node stmts = node.getLastChild();\r
- Node lastStmt = stmts.getLastChild();\r
- if (lastStmt == null ||\r
- lastStmt.getType() != TokenStream.RETURN)\r
- {\r
- stmts.addChildToBack(new Node(TokenStream.RETURN));\r
- }\r
-\r
- } else {\r
- FunctionNode fnNode = (FunctionNode)\r
- node.getProp(Node.FUNCTION_PROP);\r
- if (inFunction) {\r
- // Functions containing other functions require \r
- // activation objects \r
- ((FunctionNode) tree).setRequiresActivation(true);\r
-\r
- // Nested functions must check their 'this' value to\r
- // insure it is not an activation object:\r
- // see 10.1.6 Activation Object\r
- fnNode.setCheckThis(true);\r
- }\r
- addParameters(fnNode);\r
- NodeTransformer inner = newInstance();\r
- fnNode = (FunctionNode) \r
- inner.transform(fnNode, tree, ts, scope);\r
- node.putProp(Node.FUNCTION_PROP, fnNode);\r
- Vector fns = (Vector) tree.getProp(Node.FUNCTION_PROP);\r
- if (fns == null) {\r
- fns = new Vector(7);\r
- tree.putProp(Node.FUNCTION_PROP, fns);\r
- }\r
- fns.addElement(fnNode);\r
- }\r
- break;\r
-\r
- case TokenStream.LABEL:\r
- {\r
- Node child = node.getFirstChild();\r
- node.removeChild(child);\r
- String id = child.getString();\r
-\r
- // check against duplicate labels...\r
- for (int i=loops.size()-1; i >= 0; i--) {\r
- Node n = (Node) loops.elementAt(i);\r
- if (n.getType() == TokenStream.LABEL) {\r
- String otherId = (String)n.getProp(Node.LABEL_PROP);\r
- if (id.equals(otherId)) {\r
- String message = Context.getMessage1(\r
- "msg.dup.label", id);\r
- reportMessage(Context.getContext(), message, node, \r
- tree, true, scope);\r
- break typeswitch;\r
- }\r
- }\r
- }\r
-\r
- node.putProp(Node.LABEL_PROP, id);\r
-\r
- /* Make a target and put it _after_ the following\r
- * node. And in the LABEL node, so breaks get the\r
- * right target.\r
- */\r
- Node breakTarget = new Node(TokenStream.TARGET);\r
- Node parent = iterator.getCurrentParent();\r
- Node next = node.getNextSibling();\r
- while (next != null &&\r
- (next.getType() == TokenStream.LABEL ||\r
- next.getType() == TokenStream.TARGET))\r
- next = next.getNextSibling();\r
- if (next == null)\r
- break;\r
- parent.addChildAfter(breakTarget, next);\r
- node.putProp(Node.BREAK_PROP, breakTarget);\r
- \r
- if (next.getType() == TokenStream.LOOP) {\r
- node.putProp(Node.CONTINUE_PROP, \r
- next.getProp(Node.CONTINUE_PROP));\r
- } \r
-\r
- loops.push(node);\r
- loopEnds.push(breakTarget);\r
-\r
- break;\r
- }\r
-\r
- case TokenStream.SWITCH:\r
- {\r
- Node breakTarget = new Node(TokenStream.TARGET);\r
- Node parent = iterator.getCurrentParent();\r
- parent.addChildAfter(breakTarget, node);\r
-\r
- // make all children siblings except for selector\r
- Node sib = node;\r
- Node child = node.getFirstChild().next;\r
- while (child != null) {\r
- Node next = child.next;\r
- node.removeChild(child);\r
- parent.addChildAfter(child, sib);\r
- sib = child;\r
- child = next;\r
- }\r
-\r
- node.putProp(Node.BREAK_PROP, breakTarget);\r
- loops.push(node);\r
- loopEnds.push(breakTarget);\r
- node.putProp(Node.CASES_PROP, new Vector(13));\r
- break;\r
- }\r
-\r
- case TokenStream.DEFAULT:\r
- case TokenStream.CASE:\r
- {\r
- Node sw = (Node) loops.peek();\r
- if (type == TokenStream.CASE) {\r
- Vector cases = (Vector) sw.getProp(Node.CASES_PROP);\r
- cases.addElement(node);\r
- } else {\r
- sw.putProp(Node.DEFAULT_PROP, node);\r
- }\r
- break;\r
- }\r
-\r
- case TokenStream.NEWLOCAL : {\r
- Integer localCount\r
- = (Integer)(tree.getProp(Node.LOCALCOUNT_PROP));\r
- if (localCount == null) {\r
- tree.putProp(Node.LOCALCOUNT_PROP, new Integer(1));\r
- }\r
- else {\r
- tree.putProp(Node.LOCALCOUNT_PROP,\r
- new Integer(localCount.intValue() + 1));\r
- }\r
- }\r
- break;\r
-\r
- case TokenStream.LOOP:\r
- loops.push(node);\r
- loopEnds.push(node.getProp(Node.BREAK_PROP));\r
- break;\r
-\r
- case TokenStream.WITH:\r
- {\r
- if (inFunction) {\r
- // With statements require an activation object.\r
- ((FunctionNode) tree).setRequiresActivation(true);\r
- }\r
- loops.push(node);\r
- Node leave = node.getNextSibling();\r
- if (leave.getType() != TokenStream.LEAVEWITH) {\r
- throw new RuntimeException("Unexpected tree");\r
- }\r
- loopEnds.push(leave);\r
- break;\r
- }\r
-\r
- case TokenStream.TRY:\r
- {\r
- Node finallytarget = (Node)node.getProp(Node.FINALLY_PROP);\r
- if (finallytarget != null) {\r
- hasFinally = true;\r
- loops.push(node);\r
- loopEnds.push(finallytarget);\r
- }\r
- Integer localCount\r
- = (Integer)(tree.getProp(Node.LOCALCOUNT_PROP));\r
- if (localCount == null) {\r
- tree.putProp(Node.LOCALCOUNT_PROP, new Integer(1));\r
- }\r
- else {\r
- tree.putProp(Node.LOCALCOUNT_PROP,\r
- new Integer(localCount.intValue() + 1));\r
- }\r
- break;\r
- }\r
-\r
- case TokenStream.TARGET:\r
- case TokenStream.LEAVEWITH:\r
- if (!loopEnds.empty() && loopEnds.peek() == node) {\r
- loopEnds.pop();\r
- loops.pop();\r
- }\r
- break;\r
-\r
- case TokenStream.RETURN:\r
- {\r
- /* If we didn't support try/finally, it wouldn't be\r
- * necessary to put LEAVEWITH nodes here... but as\r
- * we do need a series of JSR FINALLY nodes before\r
- * each RETURN, we need to ensure that each finally\r
- * block gets the correct scope... which could mean\r
- * that some LEAVEWITH nodes are necessary.\r
- */\r
- if (!hasFinally)\r
- break; // skip the whole mess.\r
-\r
- Node parent = iterator.getCurrentParent();\r
- for (int i=loops.size()-1; i >= 0; i--) {\r
- Node n = (Node) loops.elementAt(i);\r
- int elemtype = n.getType();\r
- if (elemtype == TokenStream.TRY) {\r
- Node jsrnode = new Node(TokenStream.JSR);\r
- Object jsrtarget = n.getProp(Node.FINALLY_PROP);\r
- jsrnode.putProp(Node.TARGET_PROP, jsrtarget);\r
- parent.addChildBefore(jsrnode, node);\r
- } else if (elemtype == TokenStream.WITH) {\r
- parent.addChildBefore(new Node(TokenStream.LEAVEWITH),\r
- node);\r
- }\r
- }\r
- break;\r
- }\r
-\r
- case TokenStream.BREAK:\r
- case TokenStream.CONTINUE:\r
- {\r
- Node loop = null;\r
- boolean labelled = node.hasChildren();\r
- String id = null;\r
- if (labelled) {\r
- /* get the label */\r
- Node child = node.getFirstChild();\r
- id = child.getString();\r
- node.removeChild(child);\r
- }\r
-\r
- int i;\r
- Node parent = iterator.getCurrentParent();\r
- for (i=loops.size()-1; i >= 0; i--) {\r
- Node n = (Node) loops.elementAt(i);\r
- int elemtype = n.getType();\r
- if (elemtype == TokenStream.WITH) {\r
- parent.addChildBefore(new Node(TokenStream.LEAVEWITH),\r
- node);\r
- } else if (elemtype == TokenStream.TRY) {\r
- Node jsrFinally = new Node(TokenStream.JSR);\r
- Object jsrTarget = n.getProp(Node.FINALLY_PROP);\r
- jsrFinally.putProp(Node.TARGET_PROP, jsrTarget);\r
- parent.addChildBefore(jsrFinally, node);\r
- } else if (!labelled &&\r
- (elemtype == TokenStream.LOOP ||\r
- (elemtype == TokenStream.SWITCH &&\r
- type == TokenStream.BREAK)))\r
- {\r
- /* if it's a simple break/continue, break from the\r
- * nearest enclosing loop or switch\r
- */\r
- loop = n;\r
- break;\r
- } else if (labelled &&\r
- elemtype == TokenStream.LABEL &&\r
- id.equals((String)n.getProp(Node.LABEL_PROP)))\r
- {\r
- loop = n;\r
- break;\r
- }\r
- }\r
- int propType = type == TokenStream.BREAK\r
- ? Node.BREAK_PROP\r
- : Node.CONTINUE_PROP;\r
- Node target = loop == null \r
- ? null\r
- : (Node) loop.getProp(propType);\r
- if (loop == null || target == null) {\r
- String message;\r
- if (!labelled) {\r
- // didn't find an appropriate target\r
- if (type == TokenStream.CONTINUE) {\r
- message = Context.getMessage\r
- ("msg.continue.outside", null);\r
- } else {\r
- message = Context.getMessage\r
- ("msg.bad.break", null);\r
- }\r
- } else if (loop != null) {\r
- message = Context.getMessage0("msg.continue.nonloop");\r
- } else {\r
- Object[] errArgs = { id };\r
- message = Context.getMessage\r
- ("msg.undef.label", errArgs);\r
- }\r
- reportMessage(Context.getContext(), message, node, \r
- tree, true, scope);\r
- node.setType(TokenStream.NOP);\r
- break;\r
- }\r
- node.setType(TokenStream.GOTO);\r
- node.putProp(Node.TARGET_PROP, target);\r
- break;\r
- }\r
-\r
- case TokenStream.CALL:\r
- if (isSpecialCallName(tree, node))\r
- node.putProp(Node.SPECIALCALL_PROP, Boolean.TRUE);\r
- visitCall(node, tree);\r
- break;\r
-\r
- case TokenStream.NEW:\r
- if (isSpecialCallName(tree, node))\r
- node.putProp(Node.SPECIALCALL_PROP, Boolean.TRUE);\r
- visitNew(node, tree);\r
- break;\r
-\r
- case TokenStream.DOT:\r
- {\r
- Node right = node.getLastChild();\r
- right.setType(TokenStream.STRING);\r
- break;\r
- }\r
-\r
- case TokenStream.EXPRSTMT:\r
- node.setType(inFunction ? TokenStream.POP : TokenStream.POPV);\r
- break;\r
-\r
- case TokenStream.OBJECT:\r
- {\r
- Vector regexps = (Vector) tree.getProp(Node.REGEXP_PROP);\r
- if (regexps == null) {\r
- regexps = new Vector(3);\r
- tree.putProp(Node.REGEXP_PROP, regexps);\r
- }\r
- regexps.addElement(node);\r
- Node n = new Node(TokenStream.OBJECT);\r
- iterator.replaceCurrent(n);\r
- n.putProp(Node.REGEXP_PROP, node);\r
- break;\r
- }\r
-\r
- case TokenStream.VAR:\r
- {\r
- ShallowNodeIterator i = node.getChildIterator();\r
- Node result = new Node(TokenStream.BLOCK);\r
- while (i.hasMoreElements()) {\r
- Node n = i.nextNode();\r
- if (!n.hasChildren())\r
- continue;\r
- Node init = n.getFirstChild();\r
- n.removeChild(init);\r
- Node asn = (Node) irFactory.createAssignment(\r
- TokenStream.NOP, n, init, null,\r
- false);\r
- Node pop = new Node(TokenStream.POP, asn, node.getDatum());\r
- result.addChildToBack(pop);\r
- }\r
- iterator.replaceCurrent(result);\r
- break;\r
- }\r
-\r
- case TokenStream.DELPROP:\r
- case TokenStream.SETNAME:\r
- {\r
- if (!inFunction || inWithStatement())\r
- break;\r
- Node bind = node.getFirstChild();\r
- if (bind == null || bind.getType() != TokenStream.BINDNAME)\r
- break;\r
- String name = bind.getString();\r
- Context cx = Context.getCurrentContext();\r
- if (cx != null && cx.isActivationNeeded(name)) {\r
- // use of "arguments" requires an activation object.\r
- ((FunctionNode) tree).setRequiresActivation(true);\r
- }\r
- VariableTable vars = getVariableTable(tree);\r
- if (vars.getVariable(name) != null) {\r
- if (type == TokenStream.SETNAME) {\r
- node.setType(TokenStream.SETVAR);\r
- bind.setType(TokenStream.STRING);\r
- } else {\r
- // Local variables are by definition permanent\r
- Node n = new Node(TokenStream.PRIMARY,\r
- new Integer(TokenStream.FALSE));\r
- iterator.replaceCurrent(n);\r
- }\r
- }\r
- break;\r
- }\r
- \r
- case TokenStream.GETPROP:\r
- if (inFunction) {\r
- Node n = node.getFirstChild().getNextSibling();\r
- String name = n == null ? "" : n.getString();\r
- Context cx = Context.getCurrentContext();\r
- if ((cx != null && cx.isActivationNeeded(name)) ||\r
- (name.equals("length") && \r
- Context.getContext().getLanguageVersion() == \r
- Context.VERSION_1_2))\r
- {\r
- // Use of "arguments" or "length" in 1.2 requires \r
- // an activation object.\r
- ((FunctionNode) tree).setRequiresActivation(true);\r
- }\r
- }\r
- break;\r
-\r
- case TokenStream.NAME:\r
- {\r
- if (!inFunction || inWithStatement())\r
- break;\r
- String name = node.getString();\r
- Context cx = Context.getCurrentContext();\r
- if (cx != null && cx.isActivationNeeded(name)) {\r
- // Use of "arguments" requires an activation object.\r
- ((FunctionNode) tree).setRequiresActivation(true);\r
- }\r
- VariableTable vars = getVariableTable(tree);\r
- if (vars.getVariable(name) != null) {\r
- node.setType(TokenStream.GETVAR);\r
- }\r
- break;\r
- }\r
- }\r
- }\r
-\r
- return tree;\r
- }\r
-\r
- protected void addVariables(Node tree, VariableTable vars) {\r
- // OPT: a whole pass to collect variables seems expensive.\r
- // Could special case to go into statements only.\r
- boolean inFunction = tree.getType() == TokenStream.FUNCTION;\r
- PreorderNodeIterator iterator = tree.getPreorderIterator();\r
- Hashtable ht = null;\r
- Node node;\r
- while ((node = iterator.nextNode()) != null) {\r
- int nodeType = node.getType();\r
- if (inFunction && nodeType == TokenStream.FUNCTION &&\r
- node != tree && \r
- ((FunctionNode) node.getProp(Node.FUNCTION_PROP)).getFunctionType() == \r
- FunctionNode.FUNCTION_EXPRESSION_STATEMENT) \r
- {\r
- // In a function with both "var x" and "function x",\r
- // disregard the var statement, independent of order.\r
- String name = node.getString();\r
- if (name == null)\r
- continue;\r
- vars.removeLocal(name);\r
- if (ht == null)\r
- ht = new Hashtable();\r
- ht.put(name, Boolean.TRUE);\r
- }\r
- if (nodeType != TokenStream.VAR)\r
- continue;\r
- ShallowNodeIterator i = node.getChildIterator();\r
- while (i.hasMoreElements()) {\r
- Node n = i.nextNode();\r
- if (ht == null || ht.get(n.getString()) == null)\r
- vars.addLocal(n.getString());\r
- }\r
- }\r
- String name = (String) tree.getDatum();\r
- if (inFunction && ((FunctionNode) tree).getFunctionType() ==\r
- FunctionNode.FUNCTION_EXPRESSION &&\r
- name != null && name.length() > 0 &&\r
- vars.getVariable(name) == null)\r
- {\r
- // A function expression needs to have its name as a variable\r
- // (if it isn't already allocated as a variable). See \r
- // ECMA Ch. 13. We add code to the beginning of the function\r
- // to initialize a local variable of the function's name\r
- // to the function value.\r
- vars.addLocal(name);\r
- Node block = tree.getLastChild();\r
- Node setFn = new Node(TokenStream.POP,\r
- new Node(TokenStream.SETVAR,\r
- new Node(TokenStream.STRING, name),\r
- new Node(TokenStream.PRIMARY,\r
- new Integer(TokenStream.THISFN))));\r
- block.addChildrenToFront(setFn);\r
- }\r
- }\r
-\r
- protected void addParameters(FunctionNode fnNode) {\r
- VariableTable vars = fnNode.getVariableTable();\r
- Node args = fnNode.getFirstChild();\r
- if (args.getType() == TokenStream.LP && vars.getParameterCount() == 0)\r
- {\r
- // Add parameters\r
- ShallowNodeIterator i = args.getChildIterator();\r
- while (i.hasMoreElements()) {\r
- Node n = i.nextNode();\r
- String arg = n.getString();\r
- vars.addParameter(arg);\r
- }\r
- }\r
- }\r
- \r
- protected void visitNew(Node node, Node tree) {\r
- }\r
-\r
- protected void visitCall(Node node, Node tree) {\r
- /*\r
- * For\r
- * Call(GetProp(a, b), c, d) // or GetElem...\r
- * we wish to evaluate as\r
- * Call(GetProp(tmp=a, b), tmp, c, d)\r
- *\r
- * for\r
- * Call(Name("a"), b, c)\r
- * we wish to evaluate as\r
- * Call(GetProp(tmp=GetBase("a"), "a"), tmp, b, c)\r
- *\r
- * and for\r
- * Call(a, b, c);\r
- * we wish to evaluate as\r
- * Call(tmp=a, Parent(tmp), c, d)\r
- */\r
- Node left = node.getFirstChild();\r
- // count the arguments\r
- int argCount = 0;\r
- Node arg = left.getNextSibling();\r
- while (arg != null) {\r
- arg = arg.getNextSibling();\r
- argCount++;\r
- }\r
- boolean addGetThis = false;\r
- if (left.getType() == TokenStream.NAME) {\r
- VariableTable vars = getVariableTable(tree);\r
- String name = left.getString();\r
- if (inFunction && vars.getVariable(name) != null && \r
- !inWithStatement()) \r
- {\r
- // call to a var. Transform to Call(GetVar("a"), b, c)\r
- left.setType(TokenStream.GETVAR);\r
- // fall through to code to add GetParent\r
- } else {\r
- // transform to Call(GetProp(GetBase("a"), "a"), b, c)\r
-\r
- node.removeChild(left);\r
- left.setType(TokenStream.GETBASE);\r
- Node str = left.cloneNode();\r
- str.setType(TokenStream.STRING);\r
- Node getProp = new Node(TokenStream.GETPROP, left, str);\r
- node.addChildToFront(getProp);\r
- left = getProp;\r
-\r
- // Conditionally set a flag to add a GETTHIS node.\r
- // The getThis entry in the runtime will take a\r
- // Scriptable object intended to be used as a 'this'\r
- // and make sure that it is neither a With object or\r
- // an activation object.\r
- // Executing getThis requires at least two instanceof\r
- // tests, so we only include it if we are currently\r
- // inside a 'with' statement, or if we are executing\r
- // a script (to protect against an eval inside a with).\r
- addGetThis = inWithStatement() || !inFunction;\r
- // fall through to GETPROP code\r
- }\r
- }\r
- if (left.getType() != TokenStream.GETPROP &&\r
- left.getType() != TokenStream.GETELEM)\r
- {\r
- node.removeChild(left);\r
- Node tmp = irFactory.createNewTemp(left);\r
- Node use = irFactory.createUseTemp(tmp);\r
- use.putProp(Node.TEMP_PROP, tmp);\r
- Node parent = new Node(TokenStream.PARENT, use);\r
- node.addChildToFront(parent);\r
- node.addChildToFront(tmp);\r
- return;\r
- }\r
- Node leftLeft = left.getFirstChild();\r
- left.removeChild(leftLeft);\r
- Node tmp = irFactory.createNewTemp(leftLeft);\r
- left.addChildToFront(tmp);\r
- Node use = irFactory.createUseTemp(tmp);\r
- use.putProp(Node.TEMP_PROP, tmp);\r
- if (addGetThis)\r
- use = new Node(TokenStream.GETTHIS, use);\r
- node.addChildAfter(use, left);\r
- }\r
-\r
- protected boolean inWithStatement() {\r
- for (int i=loops.size()-1; i >= 0; i--) {\r
- Node n = (Node) loops.elementAt(i);\r
- if (n.getType() == TokenStream.WITH)\r
- return true;\r
- }\r
- return false;\r
- }\r
-\r
- /**\r
- * Return true if the node is a call to a function that requires \r
- * access to the enclosing activation object.\r
- */\r
- private boolean isSpecialCallName(Node tree, Node node) {\r
- Node left = node.getFirstChild();\r
- boolean isSpecial = false;\r
- if (left.getType() == TokenStream.NAME) {\r
- String name = left.getString();\r
- isSpecial = name.equals("eval") || name.equals("With");\r
- } else {\r
- if (left.getType() == TokenStream.GETPROP) {\r
- String name = left.getLastChild().getString();\r
- isSpecial = name.equals("exec");\r
- }\r
- }\r
- if (isSpecial) {\r
- // Calls to these functions require activation objects.\r
- if (inFunction)\r
- ((FunctionNode) tree).setRequiresActivation(true);\r
- return true;\r
- }\r
- return false;\r
- }\r
-\r
- protected VariableTable createVariableTable() {\r
- return new VariableTable();\r
- }\r
-\r
- protected VariableTable getVariableTable(Node tree) {\r
- if (inFunction) {\r
- return ((FunctionNode)tree).getVariableTable();\r
- }\r
- VariableTable result = (VariableTable)(tree.getProp(Node.VARS_PROP));\r
- if (result == null) {\r
- result = createVariableTable();\r
- tree.putProp(Node.VARS_PROP, result);\r
- }\r
- return result;\r
- }\r
- \r
- protected void reportMessage(Context cx, String msg, Node stmt, \r
- Node tree, boolean isError,\r
- Scriptable scope)\r
- {\r
- Object obj = stmt.getDatum();\r
- int lineno = 0;\r
- if (obj != null && obj instanceof Integer)\r
- lineno = ((Integer) obj).intValue();\r
- Object prop = tree == null \r
- ? null\r
- : tree.getProp(Node.SOURCENAME_PROP);\r
- if (isError) {\r
- if (scope != null)\r
- throw NativeGlobal.constructError(\r
- cx, "SyntaxError", msg, scope, \r
- (String) prop, lineno, 0, null);\r
- else\r
- cx.reportError(msg, (String) prop, lineno, null, 0);\r
- }\r
- else\r
- cx.reportWarning(msg, (String) prop, lineno, null, 0); \r
- }\r
-\r
- protected Stack loops;\r
- protected Stack loopEnds;\r
- protected boolean inFunction;\r
- protected IRFactory irFactory;\r
-}\r
-\r
projects / org.ibex.core.git / blobdiff