title: JavaCC - Parse math expressions into a class structure
body: <p>I'm using this grammar to calculate math expressions:</p>
  
  <pre><code>    // Konfiguration (JavaCC-Manual konsultieren)
  options {
      STATIC = true; // alle Parser-operationen sind static
      // verwende zwei Token um zu entscheiden, was passieren soll
      LOOKAHEAD = 2;
  }
  
  // hier beginnt unsere Parser Klasse ("MathParse")
  PARSER_BEGIN(MathParse)
  // hier kann ganz normaler Java-Code verwendet werden
  public class MathParse {
      public static void main(String[] args) {
          // auch ein statischer Parser muss initiiert werden
          // - allerdings nur einmal
          MathParse parser = new MathParse(System.in);
          try {
              System.out.println(parser.parse());
          } catch(ParseException e) {
              e.printStackTrace();
          }
      }
  
      // die Parser-Methoden werden automatisch hinzugefügt
  }
  PARSER_END(MathParse)
  
  // Diese Zeichen ignorieren wir
  // SKIP : { $regex$ }
  SKIP : { " " | "\t" }
  
  // Jetzt definieren wir unsere Token
  
  // TOKEN : { &lt; $tokenname$ : $regex$ &gt;}
  // "NUMBER" entspricht einer unbegrenzten Anzahl (min. 1) an Zahlen
  // (von 0 bis 9)
  TOKEN : { &lt; NUMBER : (["0"-"9"])+ ("." (["0"-"9"])+)? &gt; }
  TOKEN : { &lt; EOL : "\n" &gt; }
  
  // Und fröhlich weiter mit der tatsächlichen Syntax
  double parse() : {
      double value;
  }
  {
      value=expr()
      (&lt;EOF&gt; | &lt;EOL&gt;)     { return value; }
  }
  
  double expr() : {
      double x;
      double y;
  }
  {
      x=term()
      (
          "+" y=expr()    { x += y; }
      |
          "-" y=expr()    { x -= y; } 
      )*
      { return x; }
  }
  
  double term() : {
      double x;
      double y;
  }
  {
      x=value()
      (
          "*" y=term()    { x *= y; }
          |
          "/" y=term()    { x /= y; }
      )*
      { return x; }
  }
  
  double value() : {
      double value;
  }
  {
      "-" value=number()  { return -value; }
      |
      value=number()      { return value; }
  }
  
  double number() : {
      Token t;
      double value;
  }
  {
      t=&lt;NUMBER&gt;      { return Double.parseDouble(t.image); }
      |
      "(" value=expr() ")"    { return value; }
  }
  </code></pre>
  
  <p>That works fine. But now I don't want to get a number as the result, but a class structure representing the term. I thought of something like this:</p>
  
  <pre><code>public abstract class Expression {
      public abstract double calculate();
  }
  
  public class NumberExpression extends Expression {
      public double Value;
  
      public NumberExpression(double value) {
          this.Value = value;
      }
  
      public double calculate() {
          return this.Value;
      }
  }
  
  public class ComplexExpression extends Expression {
      public Operator Operator;
      public Vector SubExpressions;
  
      public double calculate() {
          double result = ((Expression)this.SubExpressions.elementAt(0)).calculate();
  
          for (int i = 1; i &lt; this.SubExpressions.size(); ++i)
              result = this.Operator.calculate(result, ((Expression)this.SubExpressions.elementAt(i)).calculate());
  
          return result;
      }
  }
  
  public abstract class Operator {
      public abstract String getOperator();
      public abstract double calculate(double x, double y);
  }
  </code></pre>
  
  <p>I didn't have much to do with Java or JavaCC, so can you tell me how to write a grammar for that?</p>
  
  <p>PS: I'm using Java ME.</p>