ExpressionParser.java

Go to the documentation of this file.

 
package aud.example.expr;
 
import aud.util.Sys;
 
public class ExpressionParser {
 
  Tokenizer scanner_ = null;
  boolean   verbose_ = false;
 
  public ExpressionTree parse(String input) {
    scanner_ = new Tokenizer(input);
    scanner_.next(); // use as "lookahead"
    ExpressionTree tree=expression(0);
    expect(Tokenizer.END_OF_INPUT,"<end of input>");
    return tree;
  }
 
  public void setVerbose(boolean b) {
    verbose_=b;
  }
 
  protected String errorNear() {
    return "near '"+scanner_.matchedText()+
      "'\nbefore '"+scanner_.remainder()+"'";
  }
 
  protected int lookahead() {
    return scanner_.matchedTokenId();
  }
 
  protected void nextToken() {
    if (scanner_.next()==Tokenizer.NO_MATCH)
      throw new SyntaxError("unknown token: lexcial analysis failed at '"+
                            scanner_.remainder()+"'");
  }
 
  protected String matchedText() {
    return scanner_.matchedText();
  }
 
  protected void expect(int tokenid,String text) {
    if (lookahead()!=tokenid)
      throw new SyntaxError("expected '"+text+"' got '"+
                            scanner_.matchedText()+"'\nbefore '"+
                            scanner_.remainder());
  }
 
  protected void verbose(int level,String message) {
    if (verbose_) {
      System.err.println(Sys.indent(level)+message+
                         " ['"+scanner_.matchedText()+"','"+
                         scanner_.remainder()+"']");
    }
  }
 
  //
  // Here is the implementation of BNF rules as methods:
  //
 
  protected ExpressionTree expression(int level) {
    verbose(level,"<expression>");
    return sum(level+1);
  }
 
  protected ExpressionTree sum(int level) {
    verbose(level,"<sum>");
 
    ExpressionTree left=product(level+1);
 
    if (lookahead()==Tokenizer.PLUS) {
      nextToken();
      ExpressionTree right=sum(level+1);
      return new ExpressionTree(new Plus(),left,right);
    }
    else if (lookahead()==Tokenizer.MINUS) {
      nextToken();
      ExpressionTree right=sum(level+1);
      return new ExpressionTree(new Minus(),left,right);
    }
 
    return left;
  }
 
  protected ExpressionTree product(int level) {
    verbose(level,"<product>");
 
    ExpressionTree left=factor(level+1);
 
    if (lookahead()==Tokenizer.TIMES) {
      nextToken();
      ExpressionTree right=product(level+1);
      return new ExpressionTree(new Times(),left,right);
    }
    else if (lookahead()==Tokenizer.DIVIDE) {
      nextToken();
      ExpressionTree right=product(level+1);
      return new ExpressionTree(new Divide(),left,right);
    }
 
    return left;
  }
 
  protected ExpressionTree factor(int level) {
    verbose(level,"<factor>");
 
    ExpressionTree tree=null;
 
    if (lookahead()==Tokenizer.NUMBER) {
      tree=new ExpressionTree
                (new Number(Double.parseDouble(matchedText())));
    }
    else if (lookahead()==Tokenizer.IDENTIFIER) {
      tree=new ExpressionTree(new Symbol(matchedText()));
    }
    else if (lookahead()==Tokenizer.LEFT_PAREN) {
      nextToken();
      tree=expression(level+1);
      expect(Tokenizer.RIGHT_PAREN,"closing parenthesis )");
    }
    else if (lookahead()==Tokenizer.PLUS) { // unary plus
      nextToken();
      return factor(level+1); // ignore: +x == x
     }
    else if (lookahead()==Tokenizer.MINUS) { // unary minus
      nextToken();
      return new ExpressionTree(new UnaryMinus(),factor(level+1),null);
    }
    else
      throw new SyntaxError(errorNear());
 
    nextToken();
    assert(tree!=null);
 
    return tree;
  }
 
 
 
 
  public static void main(String[] args) {
 
    String input=(args.length>0) ? args[0] : "1+2*(3+4)";
 
    System.out.println("input = '"+input+"'");
 
    ExpressionParser p=new ExpressionParser();
    p.setVerbose(true);
    ExpressionTree tree=p.parse(input);
 
    System.out.println("output = '"+tree+"'");
 
    System.out.println(tree.postorder().toString());
 
    System.out.println(tree.toTikZ());
  }
}