// Syner.java Oct.6, 1998   By Gregor v. Bochmann & Yaoping Wang
// Adapted for Assignment 3 (March 2008)  By Jason LaValley and Esther Yu

import java.io.*;
import java.util.*;

class Syner {
	private Lexer lex;
	private Hashtable symbolTable;
	private String isOutToFile;
	
	public Syner(String inputFile) {
		lex = new Lexer(inputFile);
		symbolTable = new Hashtable();
	}

	public void parseProgram() throws IOException, EndOfFileEncountered {
		if(lex.token == lex.BEGIN){
			while (true){
				lex.getNextToken();
				parseStatement();
				if(lex.token != lex.SEMICOLON){
					break;
				}
			}
			if (lex.token != lex.END) {
				errorMessage("END token expected!");
			}
		}
		else {
			errorMessage("BEGIN token expected!");
		}
	}
	
	public void parseStatement() throws IOException, EndOfFileEncountered {
		int type;
		type = 0;
		
		if (lex.token == lex.IDENT) {
			symbolTable.put(lex.idName, new Integer(10) );
			lex.getNextToken(); 
			if (lex.token == lex.ASSIGN) {
				lex.getNextToken(); 
				parseExpression();
			
				// -------------------------------------- //
				// PORTION BELOW CREATED FOR ASSIGNMENT 3 //
				// -------------------------------------- //
			} 
			
			else if ((lex.token == lex.LESSEQ)|(lex.token == lex.LESSER)|(lex.token == lex.GREATER)|(lex.token == lex.GREATEQ)|(lex.token == lex.EQUAL))
			{
				errorMessage("cannot be statically evaluated");
			}
			
			else {
				errorMessage("assignment symbol expected");
			}

		} 
		
		else if (lex.token == lex.NUMBER){
			String temps = lex.idName;
			int tempi = Integer.valueOf(temps);			
			symbolTable.put(lex.idName,new Integer(tempi));
			lex.getNextToken();
			if (lex.token == lex.ASSIGN) {
				errorMessage("cannot be statically evaluated");
			} 
			
			else if (lex.token == lex.LESSEQ){
				type = 1;
				lex.getNextToken();
				parseExpression2(type,tempi);
			}
			
			else if (lex.token == lex.LESSER){
				type = 2;
				lex.getNextToken();
				parseExpression2(type,tempi);
			}
			
			else if (lex.token == lex.GREATEQ){
				type = 3;
				lex.getNextToken();
				parseExpression2(type,tempi);
			}
			
			else if (lex.token == lex.GREATER){
				type = 4;
				lex.getNextToken();
				parseExpression2(type,tempi);
			}
			
			else if (lex.token == lex.EQUAL){
				type = 5;
				lex.getNextToken();
				parseExpression2(type,tempi);
			}
			
			else {
				errorMessage("assignment symbol expected");
			}
		}
	
		
		// -------------------------------------- //
		// PORTION ABOVE CREATED FOR ASSIGNMENT 3 //
		// -------------------------------------- //
		
		else {
			errorMessage("identifier expected at the begining of a statement");
		}
	}
	
	
	
	public void parseExpression() throws IOException, EndOfFileEncountered{
		if(lex.token == lex.IDENT) {
			symbolTable.put(lex.idName, new Integer(10)); //put value 10 to each identifier
			String id1 = lex.idName;
			lex.getNextToken();
			if(lex.token == lex.PLUS || lex.token == lex.MINUS) {
				char op =' ';
				if(lex.token == lex.PLUS) op = '+';  //op holds the '+' or '-' operator
				else op = '-';
				lex.getNextToken();
				if(lex.token == lex.IDENT) {
					symbolTable.put(lex.idName, new Integer(10)); //put identifier and value 10 into a symbol table
					int tmp1 = ((Integer)getIdentifier(id1)).intValue(); //get the value if a identifier from the symbol table
					int tmp2 = ((Integer)getIdentifier(lex.idName)).intValue();
					int tmp = 0;
					String exprResults = "";
					if(op == '+') {
						tmp = tmp1 + tmp2; //do sum up if operator is '+'
						exprResults = id1 + " + " + lex.idName + " = " + tmp;
					}else if(op == '-') {  //do substraction if operator is '-'
						tmp = tmp1 - tmp2;
						exprResults = id1 + " - " + lex.idName + " = " + tmp;
					}
					System.out.println("\n"+exprResults);
					lex.getNextToken();
					return;
				} else {
					errorMessage("identifier expected at the end of the expression");
				}
			} else {
				return;
			}
		}
				
		else {
			errorMessage("identifier expected at the beginning of a expression");
		}
	}
	
	// -------------------------------------- //
	// PORTION BELOW CREATED FOR ASSIGNMENT 3 //
	// -------------------------------------- //
	
	public void parseExpression2(int type, int first) throws IOException, EndOfFileEncountered{
		
		boolean answer;
		String exprResults = "";
		int last;
		last = 0;
		
		if (lex.token == lex.OPENB){
			last = parseBracket();	
		}
		
		else if (lex.token == lex.NUMBER){
			String tempsb = lex.idName;
			last = Integer.valueOf(tempsb);			
			symbolTable.put(lex.idName,new Integer(last));
		}
		
		else errorMessage("assignment symbol expected");
		
		if (type == 1){ 
			if(first <= last)  answer = true;
			else answer = false;
			exprResults = first + " <= " + last + " is " + answer;
		}
		
		else if (type == 2){ 
			if (first < last) answer = true;
			else answer = false;
			exprResults = first + " < " + last + " is " + answer;
		}
		
		else if (type == 3){ 
			if (first >= last) answer = true;
			else answer = false;
			exprResults = first + " >= " + last + " is " + answer;
		}
		
		else if (type == 4){ 
			if (first > last) answer = true;
			else answer = false;
			exprResults = first + " > " + last + " is " + answer;
		}
		
		else if (type == 5){ 
			if (first == last) answer = true;
			else answer = false;
			exprResults = first + " = " + last + " is " + answer;
		}
		
		System.out.println("\n"+exprResults);
		lex.getNextToken();
		return;
		
	}
	
	public int parseBracket() throws IOException, EndOfFileEncountered{
		int counter,total,a1,a2;
		String exprResults = " ";
		char b = ' ';


		
		a1=0;a2=0;counter=0;total=0;
		
		lex.getNextToken();
		if(lex.token == lex.NUMBER){
			String tempsb = lex.idName;
			a1 = Integer.valueOf(tempsb);			
			symbolTable.put(lex.idName,new Integer(a1));
		}
		
		lex.getNextToken();
		if (lex.token == lex.MULTIPLY) b = 'a';
		else if (lex.token == lex.DIVIDE) b = 'b';
		else if (lex.token == lex.PLUS) b = 'c';
		else if (lex.token == lex.MINUS) b = 'd';
		
		lex.getNextToken();
		if(lex.token == lex.NUMBER){
			String tempsb = lex.idName;
			a2 = Integer.valueOf(tempsb);			
			symbolTable.put(lex.idName,new Integer(a2));
		}
		
		if(b=='a') {
			total = a1*a2;
			exprResults = "bracket = " + a1 + " * " + a2 + " = " + total;
		}
		
		if(b=='b') {
			total = a1/a2;
			exprResults = "bracket = " + a1 + " / " + a2 + " = " + total;
		}
		if(b=='c') {
			total = a1+a2;
			exprResults = "bracket = " + a1 + " + " + a2 + " = " + total;
		}
		if(b=='d') {
			total = a1-a2;
			exprResults = "bracket = " + a1 + " - " + a2 + " = " + total;
		}

		System.out.println("\n"+exprResults);
		lex.getNextToken();
		return total;
	}
	
	// -------------------------------------- //
	// PORTION ABOVE CREATED FOR ASSIGNMENT 3 //
	// -------------------------------------- //

	public Object getIdentifier(String key){
		return symbolTable.get(key);
	}

	public void startAnalysis() throws IOException, EndOfFileEncountered{
		lex.start(); //start lexical analyser to get a token
		try {
			parseProgram(); //call parseProgram() to process the analysis
		} catch (EndOfFileEncountered e) {
			errorMessage("\nend of file encountered!");
		} catch (IOException e) {}
		try {
			lex.getNextToken(); //after "END" token, if there are still other tokens, error
			errorMessage("more tokens after END token");
		} catch (EndOfFileEncountered e) { //hit the end of file after "END" token, analysis complete
			System.out.println("\n"+"analysis complete, no syntax error");
		}
	}

	public void errorMessage(String s) throws IOException, EndOfFileEncountered {
		System.out.println(s);
		// skip to the end of the program
		while (true) {lex.getNextToken();}
	}
}