/*
 * CS431 Summer 2004
 * Project 1
 * Group Members: Lo, Wing; Brown, Shallon; Lee, Myung; Luu, Huy; Shimko, Spencer
 * Explanation: This is a recursive descent parser. It recurses through
 *              tokens passed to it from JLex's classes, parses, and evaluates
 *              each token in turn. It uses a 1 token lookahead.
 *
 * 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.*;
import java.util.Vector;

// Class: varMap
// Purpose: Store and lookup variables
class varMap {
   static Vector  variables;
   varMap(){
      variables = new Vector();
   }

   public String varLookup(String s){
      int index = variables.indexOf(s);
      if ( index == -1 ){
         System.out.println("ERROR! Unknown variable " + s);
         return "NaN";
      }
      return ( String.valueOf(variables.elementAt(index+1)) );
   }
   public void varCreate( String s, ParseTreeNode val ){
      int index = variables.indexOf(s);
      if ( index == -1 ){
         variables.add(s);
         variables.add(val.evaluate());
      } else {
         //variables.setElementAt( val.evaluate(), index+1 );
         variables.add( (index+1), val.evaluate());
      }
   }
}

// InterfacE: ParseTreeNode
// Purpose: Provide an abstraction for other PTN's to implement
interface ParseTreeNode{
   String evaluate();
}

// The *PTN classes are specialized ParseTreeNodes that evaluate
// as required
class PlusPTN implements ParseTreeNode{
   ParseTreeNode E;
   ParseTreeNode T;
   PlusPTN ( ParseTreeNode e, ParseTreeNode t ){
      E = e;
      T = t;
   }
   public String evaluate ( ){
      return String.valueOf ( Double.parseDouble (E.evaluate()) + Double.parseDouble (T.evaluate()) );
   }

}
class SubPTN implements ParseTreeNode{
   ParseTreeNode E;
   ParseTreeNode T;
   SubPTN ( ParseTreeNode e, ParseTreeNode t ){
      E = e;
      T = t;
   }
   public String evaluate ( ){
      return String.valueOf ( Double.parseDouble (E.evaluate()) - Double.parseDouble (T.evaluate()) );
   }
}


class DivPTN implements ParseTreeNode{
   ParseTreeNode E;
   ParseTreeNode T;
   DivPTN ( ParseTreeNode e, ParseTreeNode t ){
      E = e;
      T = t;
   }
   public String evaluate ( ){
      if ( Double.parseDouble (T.evaluate()) == 0.0 ){
         System.out.println("ERROR: Divide by zero goes to infinity (dumbass)");
      }
      return String.valueOf ( Double.parseDouble (E.evaluate()) / Double.parseDouble (T.evaluate()) );
   }
}


class MulPTN implements ParseTreeNode{
   ParseTreeNode E;
   ParseTreeNode T;
   MulPTN ( ParseTreeNode e, ParseTreeNode t ){
      E = e;
      T = t;
   }
   public String evaluate ( ){
      return String.valueOf ( Double.parseDouble (E.evaluate()) * Double.parseDouble (T.evaluate()) );
   }
}

class dubPTN implements ParseTreeNode{
   String S;
   dubPTN ( String s ){
      S = s;
   }
   public String evaluate ( ){
      return S;
   }
}


class trigPTN implements ParseTreeNode{
   public String evaluate ( ){
      return null;
   }

}

class ExpPTN implements ParseTreeNode{
   ParseTreeNode E;
   ParseTreeNode T;
   ExpPTN ( ParseTreeNode e, ParseTreeNode t ) {
      E = e;
      T = t;
   }
   public String evaluate ( ){
      return String.valueOf (  Math.pow(Double.parseDouble (E.evaluate()), Double.parseDouble (T.evaluate()) ) );
   }

}

// unimplemented at this point
class ErrorPTN implements ParseTreeNode{
   String err;
   ErrorPTN ( String S ){
      err = S;
   }
   public String evaluate(){
      return err;
   }
}