示例#1
0
  /**
   * Evaluates a PostfixMathCommandI with given arguments. Not used in normal use.
   *
   * @param pfmc the command to evaluate.
   * @param children the parameters to the function.
   * @return the value of the function
   * @throws ParseException
   */
  public Object eval(PostfixMathCommandI pfmc, Node children[]) throws ParseException {
    if (pfmc instanceof SpecialEvaluationI) {
      ASTFunNode node = new ASTFunNode(ParserTreeConstants.JJTFUNNODE);
      node.setFunction("TmpFun", pfmc);
      node.jjtOpen();
      for (int i = 0; i < children.length; ++i) {
        node.jjtAddChild(children[i], i);
      }
      node.jjtClose();
      return ((SpecialEvaluationI) pfmc).evaluate(node, null, this, new Stack(), this.symTab);
    }
    if (pfmc instanceof CallbackEvaluationI) {
      ASTFunNode node = new ASTFunNode(ParserTreeConstants.JJTFUNNODE);
      node.setFunction("TmpFun", pfmc);
      node.jjtOpen();
      for (int i = 0; i < children.length; ++i) {
        node.jjtAddChild(children[i], i);
      }
      node.jjtClose();
      Object val = ((CallbackEvaluationI) pfmc).evaluate(node, this);
      return val;
    }

    Stack lstack = new Stack();
    for (int i = 0; i < children.length; ++i) {
      if (!(children[i] instanceof ASTConstant))
        throw new ParseException("buildConstantNode: arguments must all be constant nodes");
      lstack.push(((ASTConstant) children[i]).getValue());
    }
    pfmc.setCurNumberOfParameters(children.length);
    pfmc.run(lstack);
    return lstack.pop();
  }
示例#2
0
  /**
   * Visit a function node. The values of the child nodes are first pushed onto the stack. Then the
   * function class associated with the node is used to evaluate the function.
   *
   * <p>If a function implements SpecialEvaluationI then the evaluate method of PFMC is called.
   */
  public Object visit(ASTFunNode node, Object data) throws ParseException {

    if (node == null) return null;
    PostfixMathCommandI pfmc = node.getPFMC();

    // check if the function class is set
    if (pfmc == null)
      throw new ParseException("No function class associated with " + node.getName());

    // Some operators (=) need a special method for evaluation
    // as the pfmc.run method does not have enough information
    // in such cases we call the evaluate method which passes
    // all available info. Note evaluating the children is
    // the responsibility of the evaluate method.
    if (pfmc instanceof SpecialEvaluationI) {
      return ((SpecialEvaluationI) pfmc).evaluate(node, data, this, stack, this.symTab);
    }
    if (pfmc instanceof CallbackEvaluationI) {
      Object val = ((CallbackEvaluationI) pfmc).evaluate(node, this);
      stack.push(val);
      return val;
    }
    if (debug == true) {
      System.out.println("Stack size before childrenAccept: " + stack.size());
    }

    // evaluate all children (each leaves their result on the stack)

    data = node.childrenAccept(this, data);

    if (debug == true) {
      System.out.println("Stack size after childrenAccept: " + stack.size());
    }

    if (pfmc.getNumberOfParameters() == -1) {
      // need to tell the class how many parameters it can take off
      // the stack because it accepts a variable number of params
      pfmc.setCurNumberOfParameters(node.jjtGetNumChildren());
    }

    // try to run the function

    pfmc.run(stack);

    if (debug == true) {
      System.out.println("Stack size after run: " + stack.size());
    }

    return data;
  }