/** * Sets the children of node to be those specified in array. * * @param node the node whose children will be set. * @param children an array of nodes which will be the children of the node. */ public void copyChildren(Node node, Node children[]) { int nchild = children.length; node.jjtOpen(); for (int i = 0; i < nchild; ++i) { children[i].jjtSetParent(node); node.jjtAddChild(children[i], i); } node.jjtClose(); }
/** * Parses the expression. If there are errors in the expression, they are added to the <code> * errorList</code> member. Errors can be obtained through <code>getErrorInfo()</code>. * * @param expression_in The input expression string * @return the top node of the expression tree if the parse was successful, <code>null</code> * otherwise */ public Node parseExpression(String expression_in) { Reader reader = new StringReader(expression_in); try { // try parsing errorList.removeAllElements(); topNode = parser.parseStream(reader, this); // if there is an error in the list, the parse failed // so set topNode to null if (hasError()) topNode = null; } catch (Throwable e) { // an exception was thrown, so there is no parse tree topNode = null; // check the type of error if (e instanceof ParseException) { // the ParseException object contains additional error // information errorList.addElement(((ParseException) e).getMessage()); // getErrorInfo()); } else { // if the exception was not a ParseException, it was most // likely a syntax error if (debug) { System.out.println(e.getMessage()); e.printStackTrace(); } errorList.addElement("Syntax error"); } } // If traversing is enabled, print a dump of the tree to // standard output if (traverse && !hasError()) { ParserVisitor v = new ParserDumpVisitor(); try { topNode.jjtAccept(v, null); } catch (ParseException e) { errorList.addElement(e.getMessage()); } } return topNode; }
/** * Returns the value of the expression as an object. The expression tree is specified with its top * node. The algorithm uses a stack for evaluation. * * <p>The symTab parameter can be null, if no variables are expected in the expression. If a * variable is found, an error is added to the error list. * * <p>An exception is thrown, if an error occurs during evaluation. * * @return The value of the expression as an object. * @throws ParseException if there is a problem with the evaluation. */ public Object getValue(Node topNode, SymbolTable symTab_in) throws ParseException { // check if arguments are ok if (topNode == null) { throw new ParseException("topNode parameter is null"); } // set member vars // errorList = errorList_in; symTab = symTab_in; // System.out.println("Evaluating expression " + topNode.toLongString() + " with symTab: " + // symTab); // errorFlag = false; stack.removeAllElements(); // rjm addition ensure stack is correct before beginning. // njf changed from clear() to removeAllElements for 1.1 compatibility // evaluate by letting the top node accept the visitor topNode.jjtAccept(this, null); /* } catch (ParseException e) { this.addToErrorList("Error: "+e.getMessage()); return null; } if(errorFlag) return null; */ // something is wrong if not exactly one item remains on the stack // or if the error flag has been set if (stack.size() != 1) { throw new ParseException("Stack corrupted"); } // return the value of the expression return stack.pop(); }
public Object eval(Node node) throws ParseException { MatrixValueI val = (MatrixValueI) node.jjtAccept(this, null); return val.copy(); }
/** * Evaluates a given node, in the current context. * * @param node The node to evaluate * @return result of the evaluation */ public Object eval(Node node) throws ParseException { node.jjtAccept(this, null); return stack.pop(); }