options {
   USER_TOKEN_MANAGER=false;
   BUILD_TOKEN_MANAGER=true;
   OUTPUT_DIRECTORY="./";
   LOOKAHEAD=5;
   STATIC=false;
}

PARSER_BEGIN ( JavaCCParser )
/*
 * CS431 Summer 2004
 * Project 1.2
 * Group Members: Lo, Wing; Brown, Shallon; Lee, Myung; Luu, Huy; Shimko, Spencer
 * Explanation: This is a recursive descent parser implemented using JavaCC for 
 *              the parser generator and for lexical analysis.
 *
 * EBNF form:
 * S := VARIABLE '=' S | E | EVAL VARIABLE
 * E := ( '+' | '-' ) E T | T
 * T := ( '*' | '/' ) T F | F
 * F := EXP '(' F G ')'
 * G := VARIABLE | DOUBLE | '(' E ')' | ('arc')? TRIG '(' E ')'
 * TRIG := 'cos' | 'sin' | 'tan'
 * EVAL := 'eval'
*/
package JavaCCParser;
import java.lang.System;
import java.math.*;

public class JavaCCParser {  
  static varMap varM = new varMap ();

  public static void main(String args[]) {
    JavaCCParser parser;
    if (args.length == 0) {
      System.out.println("JavaCC Parser:  Reading from standard input . . .");
      parser = new JavaCCParser(System.in);
    } else if (args.length == 1) {
      System.out.println("JavaCC Parser:  Reading from file " + args[0] + " . . .");
      try {
        parser = new JavaCCParser(new java.io.FileInputStream(args[0]));
      } catch (java.io.FileNotFoundException e) {
        System.out.println("JavaCC Parser:  File " + args[0] + " not found.");
        return;
      }
    } else {
      System.out.println("JavaCC Parser:  Usage is one of:");
      System.out.println("         java JavaCCParser < inputfile");
      System.out.println("OR");
      System.out.println("         java JavaCCParser inputfile");
      return;
    }
    try {
      while (parser.A()!=null){
         
      }
    } catch (ParseException e) {
      System.out.println(e.getMessage());
      System.out.println("JavaCC Parser:  Encountered errors during parse.");
    }
  }
}
PARSER_END ( JavaCCParser )

SKIP : { " " | "\t" | "\n" | "\r" | "\f" | "\r\n" }

TOKEN: { < #DIGITS : (["0"-"9"])+ > }
TOKEN: { < #ALPHA : (["a"-"z","A"-"Z","_"])+ > }
TOKEN: { < #TRIG : ("cos"|"sin"|"tan")? > }

TOKEN: { < PLUS : "+" > }
TOKEN: { < MINUS : "-" > }
TOKEN: { < MUL : "*" > }
TOKEN: { < DIV : "/" > }
TOKEN: { < EQ : "=" > }
TOKEN: { < LPAREN : "(" > }
TOKEN: { < RPAREN : ")" > }
TOKEN: { < INV : "arc" > }
TOKEN: { < EXP : "exp" > }
TOKEN: { < COS : "cos" > }
TOKEN: { < SIN : "sin" > }
TOKEN: { < TAN : "tan" > }
TOKEN: { < RAD : "rads" > }
TOKEN: { < EVAL : "eval" > }
TOKEN: { < VAR : <ALPHA>(<ALPHA>|<DIGITS>)* > }
TOKEN: { < DUB : ("+"|"-")?<DIGITS>("."<DIGITS>)? > }

ParseTreeNode A ():
{ Token t,u;
  ParseTreeNode ptn;}
{
   t = <VAR> u = <EQ> ptn = A(){    
      varM.varCreate( t.image, ptn );
      return A();
   }
   |
   u = <EVAL> t = <VAR>{
      String val = varM.varLookup ( t.image );
      if ( val == null ){
         System.out.println ("eval " + t.image + " is uninitialized" );
      } else {
         System.out.println( "Variable \"" + t.image + "\" evaluates to " + val );
      }
      return A();
   }
   |
   ptn = E(){ return ptn; }
   |
   <EOF> {return null;} 
}

ParseTreeNode E ():
{ Token t, u;
  ParseTreeNode ptn, ptn2;
}
{
   <PLUS> ptn = E() ptn2 = T(){
      return (new PlusPTN ( ptn, ptn2 ));
   }
   |
   <MINUS> ptn = E() ptn2 = T(){
      return (new SubPTN ( ptn, ptn2 ));
   }
   |
   ptn = T(){
      return ptn;
   }
}

ParseTreeNode T ():
{ Token t, u;
  ParseTreeNode ptn, ptn2;
}
{
   <MUL> ptn = T() ptn2 = F(){
      return (new MulPTN ( ptn, ptn2 ));
   }
   |
   <DIV> ptn = T() ptn2 = F(){
      return (new DivPTN ( ptn, ptn2 ));
   }
   |
   ptn = F(){
      return ptn;
   }
}

ParseTreeNode F ():
{ Token t, u;
  ParseTreeNode ptn, ptn2;
}
{
   <EXP> <LPAREN> ptn = F() ptn2 = G() <RPAREN> {
       return ( new ExpPTN ( ptn, ptn2 )); 
   }
   |
   ptn = G(){
      return ptn;
   }
}  

ParseTreeNode G ():
{ Token t, u;
  t = null;
  ParseTreeNode ptn, ptn2;
}
{
   t = <VAR>{
       return (new dubPTN( varM.varLookup ( t.image ) ));
   }
   |
   t = <DUB>{
      return ( new dubPTN ( t.image ) );
   }
   |
   <LPAREN> ptn = E() <RPAREN>{
      return (ptn);
   }
   |
   (t = <INV>)? <COS> <LPAREN> ptn = E() <RPAREN>{
      if ( t != null ){
         return ( new dubPTN( String.valueOf ( Math.acos( Double.parseDouble(ptn.evaluate())))));
      } else {
         return ( new dubPTN( String.valueOf ( Math.cos( Double.parseDouble(ptn.evaluate())))));
      }
   }
   |
   (t = <INV>)? <SIN> <LPAREN> ptn = E() <RPAREN>{
      if ( t != null ){
         return ( new dubPTN( String.valueOf ( Math.asin( Double.parseDouble(ptn.evaluate())))));
      } else {
         return ( new dubPTN( String.valueOf ( Math.sin( Double.parseDouble(ptn.evaluate())))));
      }
   }
   |
   (t = <INV>)? <TAN> <LPAREN> ptn = E() <RPAREN>{
      if ( t != null ){
         return ( new dubPTN( String.valueOf ( Math.atan( Double.parseDouble(ptn.evaluate())))));
      } else {
         return ( new dubPTN( String.valueOf ( Math.tan( Double.parseDouble(ptn.evaluate())))));
      }
   }
   |
   <RAD> <LPAREN>ptn = E() <RPAREN>{
        return ( new dubPTN ( String.valueOf(
                                         Math.toRadians(
                                         Double.parseDouble(ptn.evaluate())
                                         ))));
   }
}