/*********************************
Tradutor de Pascal para Java 
Giovani Facchini
Evandro Clivatti Dall'Agnol


Changelog GB para GB

- arrays uni, bi, multi

- record: variaveis record

- bug fix lendo real para Double
- outros fix

**********************************/

options {
	IGNORE_CASE = true;
	FORCE_LA_CHECK = true;
	STATIC = false;
}

PARSER_BEGIN(PascalToJavaParser)
import java.io.FileWriter;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.util.Vector;
import java.util.Hashtable;


class PascalToJavaParser {

	/**
	 * Arquivo de saída
	 */
	public static BufferedWriter file;

	/**
	 *
	 */
	public static String temp, aux;

	/**
	 */
	public static Token global;
	public boolean multi = false;
	public int contadim = 1;

	/**
	 * Tabela contendo hashtables. Para cada posição existe uma hashtable que indica as variáveis presentes
	 * nos métodos
	 */
	public static Vector tabelaDeSimbolos = new Vector();
	public static int nivelEscopo = -1;
	public static int escopoMax = -1;
	public static Hashtable tabelaDeProcedimentos = new Hashtable();
	public static Hashtable tabelaDeRegistros = new Hashtable();
	/**
	 * Esta String será utilizada para armazenar as classes que serão criadas para representar os registros.
	 * No fim do parsing ela será escrita no arquivo para ter todas as classes presentes no mesmo arquivo.
	 */
	public static String classesDosRegistros = "";


	public static void main (String args[]) throws ParseException, TokenMgrError, NumberFormatException {
		if (args.length != 1) {
			System.out.println("Usage: <File input>");
			System.exit(1);
		}
		PascalToJavaParser parser = null;
		try {
			//file = new BufferedWriter(new FileWriter(args[1]));
			parser = new PascalToJavaParser(new FileInputStream(args[0]));
		} catch (Exception e) {
			System.err.println("Falha ao abrir arquivo");
			 e.printStackTrace();
			System.exit(1);
		}
		/* parser propriamente dito */
		parser.parseFile();
		write(classesDosRegistros);
		try {
			file.close();
		} catch (Exception e) {
			System.err.println("Sem arquivo");
			e.printStackTrace();
			System.exit(1);
		}
	}
	public static void write(String some) {
		try {
			file.write(some);
			System.out.print(some);
		} catch (Exception e) {
			System.err.println("Erro na escrita de saida");
			e.printStackTrace();
			System.exit(1);
		}
	}
}
/**
 * Essa classe armazena um conjunto de variáveis e o seu tipo
 * Ex:  a,b,c:real
 */
class Variaveis {
	public Vector variaveis;
	public String tipo;
	public Variaveis(){
		variaveis = new Vector();
	}
	public void addVariavel(String var) {
		variaveis.addElement(var);
	}
	public boolean exist(String var) {
		return variaveis.contains(var);
	}
	public void setTipo(String tipo_) {
		tipo = tipo_;
	}
	public boolean isTipo(String tipo_) {
		return tipo.equals(tipo_);
	}

}

/**
 * Classe utilizada pra armazenar os elementos de um registro.
 */
class Record {
	// cada posição contém uma classe do tipo Varialveis. Cada objeto terá as variáveis de um
	// determinado tipo do registro.
	public Vector todasVariaveis;                                                    
	public boolean isArray;   // usado quando array
	public String tamArray;   // usado quando array
	public String tipoArray;  // usado quando array
	public boolean multidim;  // usado quando array
	public int quantdim;      // usado quando array
	public Record() {
		todasVariaveis = new Vector();
		multidim = false; // usado quando array
		quantdim = 1;     // usado quando array
	}
}

PARSER_END(PascalToJavaParser)

// ******************************** Espacos ************************************
SKIP :
{ " " | "\t" | "\n" | "\r" | "\f" }

// ****************************** Comentarios **********************************
              MORE          : { "{" : COMENTARIO  }
<COMENTARIO>  SPECIAL_TOKEN : { "}" : DEFAULT     }
<COMENTARIO>  MORE          : { < ~[] >           }

// ************************* Palavras Reservadas *******************************
TOKEN :
{
  < REAL:       "real"      > | < INTEGER:  "integer"   > | < CHAR:   "char"   >
| < IF:         "if"        > | < THEN:     "then"      > | < ELSE:   "else"   >
| < BEGIN:      "begin"     > | < END:      "end"       >
| < PROGRAM:    "program"   > | < TRUE:     "true"      > | < FALSE:  "false"  >
| < PROCEDURE:  "procedure" > | < FUNCTION: "function"  > | < RETURN: "return" >
| < VAR:        "var"       > | < CONST:    "const"     >
| < ARRAY:      "array"     > | < OF:       "of"        >
| < WHILE:      "while"     > | < DO:       "do"        > | < TO:     "to"     >
| < BREAK:      "break"     > | < CONTINUE: "continue"  > | < FOR:    "for"    >
| < USES:       "uses"      > | < REPEAT:   "repeat"    > | < UNTIL:  "until"  >
| < CASE:       "case"      > | < BYTE:     "byte"      > | < STRING: "string" >
| < NOT:        "not"       > | < NIL:      "nil"       >
| < LONGINT:    "longint"   > | < BOOLEAN:  "boolean"   > | < TYPE: "type"     >
| < RECORD:      "record"   >


}

//  ********************** Separadores ***************************************
TOKEN: {
  < LBRACKET:   "[" >
| < RBRACKET:   "]" >
| < OPEN_PAR:   "(" >
| < CLOSE_PAR:  ")" >
| < SEMICOLON:  ";" >
| < COMMA:      "," >
| < DOT:        "." >
| < DOTDOT:     ".." >
| < TWODOTS:    ":" >
}

// ******************************* Operadores **********************************

TOKEN :
{
  < OPADI: ( "+" | "-" )                                      >
| < IGUAL: "="                                                >
| < OPMULT: ( "/" | "*" | "div" | "mod" | "and" | "in" )      >
| < OPREL: ( "<" | "<=" | "<>" | ">=" | ">" | "or" | "and" )  >
| < ATRIB : ":="                                              >
}

// ******************************** Literais ***********************************

TOKEN :
{
  < NUM_INT: (["0"-"9"])+                   >
| < NUM_REAL: (["0"-"9"])+ "." (["0"-"9"])+ >
| < LITERAL: "\'" (~["\'"])* "\'"           >
}

// ************************ FUNCOES **********************************
TOKEN:
{
	< FUNC_WRITE: "write"     >
|	< FUNC_WRITELN: "writeln" >
|	< FUNC_READ: "read"       >
|	< FUNC_READLN: "readln"   >
|	< FUNC_LENGTH: "length"   >
}

// ************************ Identificador *************************************
TOKEN :
{
  < ID: ("_"|<LETTER>) ("_"|<LETTER>|<DIGIT>)*  >
| < #LETTER: ["a"-"z", "A"-"Z" ]                >
| < #DIGIT:  ["0"-"9"]                          >
}

void parseFile() :
{}
{  Programa()
   <EOF>
}
// ************************************ Gramatica *****************************
void Programa() :
{}
{
	<PROGRAM> <ID>
	{ String name = getToken(0).image;
	try {
		file = new BufferedWriter(new FileWriter(name+".java"));
	} catch (Exception e) {
		System.err.println("Falha ao criar arquivo!!");
		e.printStackTrace();
		System.exit(1);
	}
	  write("import java.io.*;\npublic class "+name+" {\n");
	  write("\tpublic static void main (String args[]) {\n\t\t"+name+" programa = new "+name+"();\n\t\tprograma.begin();\n\t}\n");
	}
	<SEMICOLON>
	[Uses()]
	[Constantes()]
	Corpo()
	<DOT> { write("\n}\n"); }
}

/* corpo do programa */
void Corpo() :
{ String comandos; }
{
	Declara() /* variaveis */
	Rotinas() /* rotinas   */
	{
		escopoMax=nivelEscopo;
		nivelEscopo=0;
	}
	<BEGIN> {write("\tpublic void begin() {\n");}
	comandos = Sentencas() { write(comandos); }
	<END> {write("\t}\n");}
}

void Constantes() :
{}
{
	<CONST>
(	global = <ID> {temp=global.image.toLowerCase()+" = ";}
	<IGUAL> {write("\tpublic final ");}
   (	(  [<OPADI> {temp += getToken(0).image;}]
	   (global=<NUM_INT>  { write("int ");     aux = global.image; }
	 | global=<NUM_REAL> { write("double ");   aux = global.image; })
	)
    |	global=<LITERAL>   { write("String ");  aux = "\""+global.image.substring(1,global.image.length()-1)+"\"";}
    |	global=<TRUE>      { write("boolean "); aux = global.image; }
    |	global=<FALSE>     { write("boolean "); aux = global.image; }
   )
	                { write(temp+aux+";\n");}
	<SEMICOLON>
)+
}
/* bibliotecas podem estar separadas por ',' e depois do ultimo nome ';' */
void Uses() :
{}
{
	<USES>
	<ID>
	(<COMMA> <ID>)* {write("/* Uso de bibliotecas ainda nco suportado!!!\nBibliotecas sendo omitidas. */\n");}
	<SEMICOLON>
}

/* declaracao das variaveis */
void Declara() :
{}
{
//aqui vem o type!!
  [ <TYPE>
  	(UmaDeclaracaoType()<SEMICOLON>)+

  ]
  [ <VAR>
  	{
		nivelEscopo++;
		if (tabelaDeSimbolos.size()-1 < nivelEscopo)
			tabelaDeSimbolos.addElement(new Hashtable());

	  }
    ( UmaDeclaracaoVar() <SEMICOLON> {write("\n");} )+
  ]
}

void UmaDeclaracaoType():
{
	Token token;
	String construcaoDosAtributos;
	Record registro = new Record();
	String tipoDoArray = "";
	String tamanhoDoArray = "";
	Vector retTam = new Vector();
}
{
	token = <ID> <IGUAL> //(Record() | Array() )
   (	(construcaoDosAtributos = Record(registro) {
			  	classesDosRegistros+= "class "+token.image.toLowerCase()+" {\n";
				classesDosRegistros+=construcaoDosAtributos + "\n}\n";
				tabelaDeRegistros.put(token.image.toLowerCase(), registro);
			 	  }
	)
	|
	( tamanhoDoArray = ArrayTam() <OF> tipoDoArray = Tipo()
	  {
	   registro.isArray = true;
	   registro.tamArray = tamanhoDoArray;
	   registro.tipoArray = tipoDoArray;
	   if(multi){
		registro.multidim = true;
		registro.quantdim = contadim;
		contadim = 1;
		multi = false;
	   }

	   tabelaDeRegistros.put(token.image.toLowerCase(), registro);
	  }
	)
   )
}

String Record(Record registro):
{
	String atributos="", declaracao;
}
{
	<RECORD>
	(
	 declaracao = UmaDeclaracaoVariavelType(registro) {
	 						  	atributos+=declaracao;
	 						  }
	 <SEMICOLON>
	)+
	<END> {	return atributos; }
}

String UmaDeclaracaoVariavelType(Record registro):
{
	String tipo;
	String variaveis;
	Variaveis var;

}
{
	{ var = new Variaveis(); }
	variaveis = ListaVariaveis(var)
	<TWODOTS> tipo = Tipo() {
					var.setTipo(tipo);
					variaveis =tipo+" "+variaveis+ ";\n";
					registro.todasVariaveis.addElement(var);
					return variaveis;
//					------------
/*					
					var.setTipo(tipo);
//					variaveis += ";";
					if (tabelaDeRegistros.get(tipo)==null) {
					//	write("\t"+tipo+" "+variaveis);
					} else {
						if( ( (registro = (Record) tabelaDeRegistros.get(tipo)) != null ) && (registro.isArray) ){
							// é array
							if(registro.multidim){
								write("\t"+registro.tipoArray);
								for(int chaos=0; chaos<registro.quantdim; chaos++){
									write("[]");
								}
								write(" ");
							} else {
								write("\t"+registro.tipoArray+"[] ");
							}
							for (int jota=0; jota<var.variaveis.size()-1; jota++){
								write( var.variaveis.elementAt(jota)+" = new "+
									registro.tipoArray + registro.tamArray + "," );
							}
							write( var.variaveis.lastElement()+" = new "+
								registro.tipoArray + registro.tamArray + ";\n" );
				
							// meu codigo
						} else { // é registro
							write("\t"+tipo+" ");
							for (int j=0; j<var.variaveis.size()-1; j++) {
								write(var.variaveis.elementAt(j)+" = new "+tipo+"(),");
							}
							write(var.variaveis.lastElement()+"= new "+tipo+"();\n");
						}
					}
			        return variaveis;*/
				}
				
}

String ArrayTam():
{ String retorno = "";
  String tempor = "";
  int fim=0, tamanho;
  boolean temId = false;
  Vector dimensoes = new Vector();
}
{
	<ARRAY> <LBRACKET>
		  (<NUM_INT>|<ID>)
		  <DOTDOT>
		  (<NUM_INT> { fim = Integer.parseInt(getToken(0).image); }
		  |
		   <ID> { temId = true; tempor = getToken(0).image.toLowerCase(); }
		  )
		  ( // array multidimensional
		    <COMMA> { multi = true; contadim+=1; }
			    (	(<NUM_INT>|<ID>)
				<DOTDOT>
//				(<NUM_INT> { fim = Integer.parseInt(getToken(0).image); }
				(<NUM_INT> { dimensoes.addElement(getToken(0).image); }
				|
				 <ID> { temId = true; dimensoes.addElement(getToken(0).image.toLowerCase()); }
				)
			    )
		  )*
		<RBRACKET>
	{
	  if(temId){
		retorno = "[" + tempor + " + 1]";
		if (multi){
			for(int i=0; i<dimensoes.size(); i++) {
				retorno += "[" + dimensoes.elementAt(i) + " + 1]";
			}
		}
	  } else {
		tamanho = fim + 1;
		retorno = "[" + Integer.toString(tamanho) + "]";
		if (multi){
			for(int i=0; i<dimensoes.size(); i++) {
				retorno += "[" + dimensoes.elementAt(i) + " + 1]";
			}
		}
	  }
	return retorno;
	}
}

/* variavel e seu tipo */
void UmaDeclaracaoVar() :
{
	String tipo;
	String variaveis;
	Variaveis var;
	Record registro;
}
{
	{ var = new Variaveis();
	  registro = new Record();
	}
	variaveis = ListaVariaveis(var)
	<TWODOTS> tipo = Tipo()
	{
		var.setTipo(tipo);
		variaveis += ";";
		if (tabelaDeRegistros.get(tipo)==null) {
			write("\t"+tipo+" "+variaveis);
		} else {
			if( ( (registro = (Record) tabelaDeRegistros.get(tipo)) != null ) && (registro.isArray) ){
				// é array
				if(registro.multidim){
					write("\t"+registro.tipoArray);
					for(int chaos=0; chaos<registro.quantdim; chaos++){
						write("[]");
					}
					write(" ");
				} else {
					write("\t"+registro.tipoArray+"[] ");
				}
				for (int jota=0; jota<var.variaveis.size()-1; jota++){
					write( var.variaveis.elementAt(jota)+" = new "+
						registro.tipoArray + registro.tamArray + "," );
				}
				write( var.variaveis.lastElement()+" = new "+
					registro.tipoArray + registro.tamArray + ";\n" );

				// meu codigo
			} else { // é registro
				write("\t"+tipo+" ");
				for (int j=0; j<var.variaveis.size()-1; j++) {
					write(var.variaveis.elementAt(j)+" = new "+tipo+"(),");
				}
				write(var.variaveis.lastElement()+"= new "+tipo+"();\n");
			}
		}
		Hashtable tmp = (Hashtable)tabelaDeSimbolos.elementAt(nivelEscopo);
		for (int i=0; i<= var.variaveis.size()-1; i++) {
			tmp.put(var.variaveis.elementAt(i),var.tipo);
		}
	}
}

/* composicao das variaveis, identificador seguido de mais identificadores */
String ListaVariaveis(Variaveis var) :
{
	Token tok;
	String variaveis;
	String auxi="";
}
{
	tok = <ID> {
			variaveis = tok.image.toLowerCase();
			var.addVariavel(variaveis);
		   }
	[ <COMMA> {variaveis+=", ";}
	auxi = ListaVariaveis(var) ]
	{ return variaveis+auxi; }
}

/* tipos */
String Tipo() :
{
	Token t;
	String tipo;
}
{
	<INTEGER> { return "int";     }
|	<REAL>    { return "double";  }
|	<CHAR>    { return "char";    }
|	<BYTE>    { return "byte";    }
|	<STRING>[<LBRACKET><NUM_INT><RBRACKET>] { return "String"; }
|	<LONGINT> { return "int";     }
|	<BOOLEAN> { return "boolean"; }
|	t = <ID>  {
			tipo = t.image.toLowerCase();
			if (tabelaDeRegistros.get(tipo) == null) {
				System.err.println("Tipo de dados: \""+tipo+"\" não declarado!");
				System.exit(1);
			}			
			return t.image.toLowerCase(); 
		  }
}

/* wrapper rotinas */
void Rotinas() :
{}
{
  (  Procedimento()
   | Funcao()
  )*
  { write("/* Procedimentos e Funcoes em fase de teste */\n"); }
}

/* procedures */
void Procedimento() :
{
	String parametros, corpo;
}
{
	<PROCEDURE> <ID> {
			write("\tpublic void "+getToken(0).image.toLowerCase());
			tabelaDeProcedimentos.put(getToken(0).image.toLowerCase(),"anything");
			}

	parametros = Parametros() { write(parametros); }
	<SEMICOLON> { write("{\n"); }
	corpo=CorpoSimples() { write(corpo); }
	<SEMICOLON> { write("\t}\n"); }
}

/* functions */
void Funcao() :
{
	String nome = "", parametros, tipo, corpo;
}
{
	<FUNCTION> <ID> {
			nome = getToken(0).image.toLowerCase();
			tabelaDeProcedimentos.put(nome,"anything");
			}

	parametros=Parametros()
	<TWODOTS>
	tipo=Tipo() { write ("\tpublic "+tipo+" "+nome+parametros+" {\n"); }
	<SEMICOLON>
	corpo=CorpoSimples() { write(corpo+"}\n"); }
	<SEMICOLON>
}

/* parametros passados as rotinas */
String Parametros() :
{
	String parametros="()", lista;
}
{
	[
	<OPEN_PAR> { parametros="("; }
	lista = ListaParametros()
	<CLOSE_PAR> { parametros+=lista+")"; }
	{return parametros;}
	]
	{return parametros;}
}

/* utilizado por Parametros() */
String ListaParametros() :
{
	String variaveis="", tipo, saux;
	Vector var = new Vector();
	Hashtable tmp;
}
{
	ListaDeIdentificadores(var) <TWODOTS>
	(tipo = Tipo()
	{
		tabelaDeSimbolos.addElement(new Hashtable());
		nivelEscopo++;
		tmp = (Hashtable) tabelaDeSimbolos.elementAt(nivelEscopo);
		for(int i = 0; i<var.size(); i++) {
			variaveis+=tipo+" "+var.elementAt(i)+", ";
			//variaveis+=tipo+" "+var.elementAt(i)+""; // FUNC
			tmp.put(var.elementAt(i), tipo);
		}
	}
	)
	saux = CountListaPar()
	{ nivelEscopo--;
	if (saux.length() > 0)
		return variaveis+saux;//.substring(0,saux.length()-2);
	// else return variaveis+saux; FUNC
	else {
		if (variaveis.length() > 0) {
			if (variaveis.charAt(variaveis.length()-2)==',') {
				String ret = variaveis.substring(0,variaveis.length()-2);
				return ret;
			}
    			else return variaveis;
   		} else return variaveis;
	     }
	}
}

/* utilizado por ListaParametros() */
String CountListaPar() :
{ String saux; }
{
	[ <SEMICOLON>
	saux=ListaParametros() { return saux; } ]
	{return ""; }
}

/* utilizado por ListaParametros() e CountListaId() */
void ListaDeIdentificadores(Vector var) :
{}
{
	<ID> { var.addElement(getToken(0).image.toLowerCase()); }
	CountListaId(var)
}

/* utilizado por ListaDeIdentificadores() */
void CountListaId(Vector var) :
{}
{   [ <COMMA> ListaDeIdentificadores(var) ]   }

/* corpo de procedimentos e funcoes */
String CorpoSimples() :
{ String corpo; }
{
	Declara()
	<BEGIN>
	corpo = Sentencas()
	<END> //{corpo+="}\n";}
	{return corpo;}
}

/* sequencia de comandos */
String Sentencas() :
{ String cmd, saux=""; }
{
	cmd = Comando() <SEMICOLON> { if (cmd!="") cmd+="\n"; }
	[ saux = Sentencas() ]
	{ return cmd+saux; }
}

/* um comando somente, utilizado, por exemplo, em if's */
String Sentenca() :
{ String cmd; }
{
	cmd = Comando() { return cmd+"\n"; }
}

/* os comandos propriamente ditos */
String Comando() :
{
	String cmd="", vread="", id=""; Token aux;
}
{
(	/* read, readln */
	((aux=<FUNC_READ>|aux=<FUNC_READLN>)
	[<OPEN_PAR> cmd = VarRead() <CLOSE_PAR>{return cmd;}] )
	{
		if (aux.image.toLowerCase().equals("readln")) {
			cmd = "try {\nBufferedReader br = new BufferedReader(new InputStreamReader(System.in));\nbr.readLine();\n} catch (Exception e) {\n";
			cmd+= "System.err.println(\"Falha ao ler do teclado!\");\n";
			cmd+= "e.printStackTrace();\nSystem.exit(1);\n}\n";
			return cmd;
		} else {
			return "";
		}
	}
|
	/* write, writeln */
	((<FUNC_WRITE>{cmd="System.out.print";}|<FUNC_WRITELN>{cmd="System.out.println";})
	[<OPEN_PAR> vread = VarWrite() <CLOSE_PAR>]{cmd+="("+vread+");";})
|
	/* for */
	(<FOR>
	aux = <ID> <ATRIB> { id=aux.image.toLowerCase(); cmd="for ("+id+"="; } vread = Expressao()
	<TO> { cmd+=vread+";"; } vread = Expressao() <DO>
	{ cmd+=id+"<="+vread+";"+id+"++) {\n"; }
	<BEGIN> vread = Sentencas() <END> { cmd+=vread+"}\n"; } )
|
	/* repeat */
	(<REPEAT> { cmd+="do {\n";}
	vread = Sentencas()
	<UNTIL> { cmd+=vread+"} while (!("; }
	vread = Condicao() { cmd+=vread+"));\n"; } )
|
	/* while */
	(<WHILE> { cmd="while ("; } vread = Condicao() <DO>
	<BEGIN> { cmd+=vread+") {\n"; }
	vread = Sentencas()
	<END> { cmd+=vread+"}\n"; } )
|
	/* if */
        /* com warning mas funfa */
        (<IF> { cmd="if ("; } vread = Condicao() { cmd+=vread+")";}
                <THEN> (( {cmd+=" {\n";} vread = Sentenca() { cmd+=vread+"}\n";} ) |
                        (<BEGIN> {cmd+=" {\n";} vread = Sentencas() <END> { cmd+=vread+"}\n";})
                        )

                [<ELSE> ((<BEGIN> {cmd+="else {\n";} vread = Sentencas() <END> {cmd+=vread+"}\n";})   |
                         ( {cmd+="else {\n";} vread = Sentenca() {cmd+=vread+"}\n";}) ) ])
|
	/* case */
	<CASE> vread = Variavel() <OF> { cmd = "switch ("+vread+") {\n";}
	((aux=<LITERAL>|/*aux=<TRUE>|aux=<FALSE>|*/aux=<NUM_INT>)
	{	//Java nao suporta switch com boolean!! Transformar em if!
		cmd+="case ";
		if (aux.image.equalsIgnoreCase("true")) {
			cmd+="true: {\n";
		} else if (aux.image.equalsIgnoreCase("false")) {
			cmd+="false: {\n";
		} else {
			if ((aux.image.length()>3)&&(aux.image.charAt(0)=='\'')) {
				System.err.println("Case com string nco permitido!!!");
				System.exit(1);
			}
			cmd+=aux.image+": {";
		}
	}
	<TWODOTS> (vread=Sentenca() <SEMICOLON> | (<BEGIN>vread=Sentencas()<END><SEMICOLON>))
	{cmd+=vread+"break;\n}\n";} )*
	[ <ELSE> (vread=Sentenca() <SEMICOLON> | <BEGIN> vread=Sentencas() <END>)
	{ cmd+="default: {\n"+vread+"\n}\n"; } ]
	<END> { cmd+="}"; }
|
	/* atribuicoes */
	aux = <ID> vread = ComandoAux(aux.image) {
							if (vread.startsWith("return"))
								cmd = vread;
							else {//como nao temos clrscr apenas eliminamos
								if (aux.image.toLowerCase().equals("clrscr"))
									cmd="";
								else cmd = aux.image.toLowerCase()+vread+";";
							}

						 }
) { return cmd; }
}

/* argumentos do write e writeln */
String VarWrite() :
{ String vv="", ret="", variavel=""; }
{
  (
   <LITERAL> { vv="\""+getToken(0).image.substring(1,getToken(0).image.length()-1)+"\""; }
   [ <COMMA> { vv+="+"; } ret = VarWrite() ] { vv += ret; }
 |
   variavel = Variavel() { vv = variavel; }
   [ <COMMA> { vv+="+"; } ret = VarWrite() ] { vv += ret; }
  )
  { return vv; }
}

/* argumentos do read e readln */
String VarRead() :
{
	String var, aux=null, construcao;
}
{
	construcao = Variavel() {
		var="try {\n";
		String[] camposRegistros;// = construcao.split(".");
		Vector helper = new Vector();
		int lastOcurrence = 0;
		for (int xxx = 0; xxx<construcao.length() ; xxx++){
                        if (construcao.charAt(xxx)=='.'){
                                helper.addElement(construcao.substring(lastOcurrence,xxx));
                                lastOcurrence = xxx+1;
                        }
                }
                helper.addElement(construcao.substring(lastOcurrence));
                camposRegistros = new String[helper.size()];
                for (lastOcurrence=0;lastOcurrence<helper.size();lastOcurrence++)
                        camposRegistros[lastOcurrence] = (String)helper.elementAt(lastOcurrence);
                construcao = construcao.toLowerCase();
                System.err.println(camposRegistros.length);
                //TODO : eh por aqui!! conferir!
                if (camposRegistros.length==1 ){
			if (construcao.indexOf("[")==-1) {
				System.err.println("variavel primitiva");
				//caso de acesso a uma variavel primitiva
				if ((aux = (String) ((Hashtable)tabelaDeSimbolos.elementAt(nivelEscopo)).get(construcao))==null){
					aux = (String) ((Hashtable)tabelaDeSimbolos.elementAt(0)).get(construcao);
				}
			} else { //caso em que só existe o array
				//aqui é certo que o array é de um tipo primitivo, pois não podemos fazer um readln em um tipo record.
//				System.err.println("array de primitivo");
				// TODO: pego o nome do array e consulto a tabela. Entao vejo de que tipo primitivo é o array.
				if ((aux = (String) ((Hashtable)tabelaDeSimbolos.elementAt(nivelEscopo)).get(construcao.substring(0,construcao.indexOf("["))))==null){
					aux = (String) ((Hashtable)tabelaDeSimbolos.elementAt(0)).get(construcao.substring(0,construcao.indexOf("[")));
				}
				aux = ((Record) tabelaDeRegistros.get(aux)).tipoArray;
			}
		} else { //nesse caso existem registros
			System.err.println("registros"+construcao);
			boolean discovered = false;
			int j = 0;
			Record registro;
			String tipo;
			//procura na tabela qual o tipo do primeiro ID
			if ((tipo = (String) ((Hashtable)tabelaDeSimbolos.elementAt(nivelEscopo)).get(camposRegistros[0]))==null) {
				if ((tipo = (String) ((Hashtable)tabelaDeSimbolos.elementAt(0)).get(camposRegistros[0]))==null) {
					if ((tipo = (String) ((Hashtable)tabelaDeSimbolos.elementAt(nivelEscopo)).get(camposRegistros[0].substring(0,camposRegistros[0].indexOf("["))))==null) {
						tipo = (String) ((Hashtable)tabelaDeSimbolos.elementAt(0)).get(camposRegistros[0].substring(0,camposRegistros[0].indexOf("[")));
					}
				}
			}
			//System.err.println(tipo);
			while (!discovered){
				registro = (Record) tabelaDeRegistros.get(tipo);
				//esse ID representa um registro
					
				//pega o nome do proximo campo
				String next;
				if (camposRegistros[j+1].indexOf("[")==-1) {
					//o proximo campo não é um array.
					//Ou é um registro ou um tipo primitivo
					next = camposRegistros[j+1];
				} else {
					//o proximo campo é um array
					//aqui devemos descobrir de que tipo o array é formado
					//pode ser um type ou um primitivo. Se primitivo pára! Senão descobre o próximo.
			
					next = camposRegistros[j+1].substring(0,camposRegistros[j+1].indexOf("["));
				}
				//System.err.println(next);
				boolean foundCampo = false;
				//tentativa de mesclar array com record
					if (registro.isArray){
						registro = (Record) tabelaDeRegistros.get(registro.tipoArray);
						//System.err.println("array");
					}
				//fim tentativa
				Variaveis variaveis_ = null;
				//System.err.println(registro.todasVariaveis.size());
				for(int k=0; k<registro.todasVariaveis.size();k++) {
					variaveis_ = (Variaveis) registro.todasVariaveis.elementAt(k);
					for (int w = 0; w<variaveis_.variaveis.size(); w++){
						String campo = (String) variaveis_.variaveis.elementAt(w);
						if (campo.equals(next)) {
							foundCampo = true;
							break;
						}
						}
					if (foundCampo)
						break;
				}
				//campo encontrado. Se for um registro prossegue.
				//Se não for, então é tipo primitivo e a busca pode parar.
				if (variaveis_==null) System.err.println("fuck ahhhhhhhh");
				if (tabelaDeRegistros.get(variaveis_.tipo)==null){
					//tipo primitivo
					discovered = true;
					aux = variaveis_.tipo;
				} else {
					//o tipo nao é primitivo. Então deve-se conseguir o proximo tipo
					tipo = variaveis_.tipo;
				}
				j++;
			}

		}
		if (aux!=null) {
		var+="BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));\n";
			var+=construcao;
			if (aux.equals("int")) {
				var+= "=Integer.parseInt(bf.readLine());\n";
			} else if (aux.equals("double")) {
				var+= "=Double.parseDouble(bf.readLine());\n";
			} else if (aux.equals("boolean")) {
				System.err.println("Tentando ler um boolean???");
				System.exit(1);
			} else if (aux.equals("char")) {
				var+="=bf.readLine().charAt(0);\n";
			} else if (aux.equals("String")) {
				var+="=bf.readLine();\n";
			} else if (aux.equals("byte")) {
				var+="=Byte.parseByte(bf.readLine());\n";
			} else {
				System.err.println("Tipo nco suportado pra leitura!!");
				System.exit(1);
			}
		} else {
			System.err.println("Variavel nco declarada!!");
			System.exit(1);
		}
		var+="} catch (Exception e) {\nSystem.err.println(";
		var+="\"Runtime error :)\");\nSystem.exit(1);\n}\n";
	}
	[aux=MaisVarRead() {var+=aux;}]
	{return var;}
}

String MaisVarRead() :
{ String var=""; }
{
	<COMMA> VarRead()
	{ return var; }
}

/* utilizado em repeat, while e if */
String Condicao() :
{ String cmd; }
{
	cmd = Expressao()
	{return cmd; }
}

/* utilizado para atribuicoes e chamar funções e procedures*/
String ComandoAux(String proc) :
{
	String exp, va="";
	Token t;
}
{
	va = VariavelAux() <ATRIB>
	(
		exp = Expressao()
		{ if (va.equals("")&&(tabelaDeProcedimentos.get(proc)!=null)) {
			return "return "+exp+";";
		  } else return va+"="+exp;
		}
		|<FUNC_LENGTH><OPEN_PAR>t=<ID>va=VariavelAux()<CLOSE_PAR>
		{ return "="+t.image.toLowerCase()+va+".length();\n"; }
	)

|
	exp = Argumentos()
	{ return exp; }
}

/* utilizado no case */
String Variavel() :
{
	String var="";
	Token t;
}
{
	t = <ID> var = VariavelAux()
	{ return t.image.toLowerCase()+var; }
}

String VariavelAux() :
{
	String vaux="",lista;
	Token t;
}
{
	[
		<LBRACKET> lista = ListaDeSubscrito() <RBRACKET> vaux = VariavelAux()
		{ return "["+lista+"]"+vaux; }
	|
		<DOT> t = <ID> vaux = VariavelAux()
		{ return "."+t.image.toLowerCase()+vaux; }
	|
		"^" vaux = VariavelAux()
		{ return "."+vaux; }
	]
	{ return ""; }
}

String ListaDeSubscrito() :
{
	String exp, lista="";
}
{
	exp = Expressao() lista = ListaDeSubscritoAux()
	{ return exp+lista; }
}

String ListaDeSubscritoAux() :
{
	String exp, lista="";
}
{
	[<COMMA> exp=Expressao() lista=ListaDeSubscritoAux(){return ","+exp+lista;}]
	{ return ""; }
}

/* expressoes (lado direito atribuicoes) */
String Expressao() :
{
	String cmd, vaux="";
}
{
	cmd = ExpressaoSimples() vaux = ExpressaoAux()
	{ return cmd+vaux; }
}
String ExpressaoAux() :
{
	String cmd="", vaux="";
	Token taux=null;
}
{
	[(taux = <OPREL>|taux = <IGUAL>) cmd = ExpressaoSimples() vaux = ExpressaoAux()]
	{ if (taux != null) {
		String bla;
		if (taux.image.equalsIgnoreCase("or"))
			return "||"+cmd+vaux;
		else if (taux.image.equalsIgnoreCase("and"))
			return "&&"+cmd+vaux;
		else if (taux.image.equals("="))
			return "=="+cmd+vaux;
		else if (taux.image.equals("<>"))
			return "!="+cmd+vaux;
		else return taux.image.toLowerCase()+cmd+vaux;
	  } else {
	  	return cmd+vaux;
	  }
	}
}

String ExpressaoSimples() :
{ String cmd, vaux=""; }
{
	cmd = Termo() vaux = ExpressaoSimplesAux()
	{ return cmd+vaux; }
}
String ExpressaoSimplesAux() :
{
	String cmd="",vaux="";
	Token taux=null;
}
{
	[taux = <OPADI> cmd = Termo() vaux = ExpressaoSimplesAux()]
	{
		if (taux!=null)
			return taux.image+cmd+vaux;
		else return cmd+vaux;
	}
}
String Termo() :
{ String cmd, vaux=""; }
{
	cmd = Fator() vaux = TermoAux()
	{ return cmd+vaux; }
}
String TermoAux() :
{
	String cmd="", vaux="";
	Token taux=null;
}
{
	[taux = <OPMULT> cmd = Fator() vaux = TermoAux()]
	{
		if (taux!=null)
			return taux.image+cmd+vaux;
		else return cmd+vaux;
	}
}
String Fator() :
{
	String cmd;
	Token taux = null;
}
{
	(
	taux = <OPADI> cmd = Fator()
	|
	cmd = Exponenciacao()
	)
	{
		if (taux!=null)
			return taux.image+cmd;
		else return cmd;
	}
}
String Exponenciacao() :
{
	String prim, exp="";
}
{
	prim = Primario() //exp = ExpoAux()
	{ return prim+exp; }
}
/*
String ExpoAux() :
{
	String exp="";
}
{
	["**" exp = Exponenciacao() {return "**"+exp; } ]
	{ return exp; }

}*/
String Primario() :
{
	String some="";
	Token taux = null;
}
{           //LOOKAHEAD(2)
     (    
	//( taux = <ID> {System.err.println("ID: "+taux.image);}(LOOKAHEAD(2)some = ParametrosPassados() | some = AcessoVariavelAux()) )
	( taux = <ID> (some = FuncaoOuVariavel()))
  |
	( some = ConstanteSemSinal() /*{System.err.println("constante sem sinal"+some);}*/)
  |
	( some = ConstrutorDeConjunto() /*{System.err.println("construtor de conjunto"+some);}*/)
  |
	( <OPEN_PAR> some = Expressao() <CLOSE_PAR> { some="("+some+")"; } )
  |
	( taux = <NOT> some = Primario() )//descobrir no lex o que eh _NOT, acho q eh 'not'
    )
	{
		if (taux!=null)
			return taux.image+some;
		else return some;
	}
}

String FuncaoOuVariavel():
{
	String lista="",parametros="", acessoVar="", listaIndices="";
}
{       
	[
	(<OPEN_PAR> { parametros="("; }
	lista = ListaParametrosPassados()
	<CLOSE_PAR> { parametros+=lista+")"; }
	{return parametros;})
//|	(acessoVar = AcessoVariavelAux() {return acessoVar;})
// 
	(<LBRACKET> listaIndices=ListaDeExpressaoDeIndice() <RBRACKET> acessoVar = AcessoVariavelAux()
	{ acessoVar = "["+listaIndices+"]"+acessoVar; return acessoVar;} )
|
	( <DOT> <ID> {listaIndices = getToken(0).image.toLowerCase();} acessoVar = AcessoVariavelAux()  
	{ acessoVar = "."+listaIndices+acessoVar; return acessoVar;} )
|
	( "^" acessoVar = AcessoVariavelAux() {return acessoVar;}) //verificar!! ponteiros viram objetos assim como registros
//	{ return acessoVar; }
	]
	{return "";}

}

String ConstanteSemSinal() :
{ String constante=""; }
{
	constante = NumeroSemSinal() { return constante; }
|
	<LITERAL> { return "\""+getToken(0).image.substring(1,getToken(0).image.length()-1)+"\"";}
|
	<NIL> { return "null"; }
}

String NumeroSemSinal() :
{ Token t; }
{
	(t = <NUM_INT> | t = <NUM_REAL>)
	{ return t.image; }
}

String ConstrutorDeConjunto() :
{ String lista=""; }
{
	<LBRACKET> [lista = ListaDeDesignadorDeMembros()] <RBRACKET>
	{ return "["+lista+"]"; }
}

String ListaDeDesignadorDeMembros() :
{ String desig, lista=""; }
{
	desig = DesignadorDeMembro() lista = ListaDeDesigAux()
	{ return desig+lista; }
}

String ListaDeDesigAux() :
{ String desig, lista=""; }
{
	[<COMMA> desig=DesignadorDeMembro() lista=ListaDeDesigAux() { return ","+desig+lista; }]
	{ return ""; }
}

String DesignadorDeMembro() :
{ String exp, desig=""; }
{
	exp = Expressao() desig = DesignadorDeMembroAux()
	{ return exp+desig; }
}

String DesignadorDeMembroAux() :
{ String exp, desig=""; }
{
	[".." exp = Expressao() desig = DesignadorDeMembroAux() {return ".."+exp+desig;}]
	{ return ""; }
}

String  AcessoVariavelAux() :
{ String saux, algo=""; }
{       //LOOKAHEAD(2)
( //{System.err.println("AcessoVariavelAux alcancado") ;}
	[
	(<LBRACKET> saux=ListaDeExpressaoDeIndice() <RBRACKET> algo = AcessoVariavelAux()
	{ algo = "["+saux+"]"+algo; } )
|
	( <DOT> <ID> {saux = getToken(0).image.toLowerCase();} algo = AcessoVariavelAux()  
	{ algo = "."+saux+algo; } )
|
	( "^" algo = AcessoVariavelAux() ) //verificar!! ponteiros viram objetos assim como registros
	]
)
	{ return algo; }
}

String ListaDeExpressaoDeIndice() :
{ String exp, lista=""; }
{
	exp = Expressao() lista = ListaDeExpDeIndAux()
	{ return exp+lista; }
}

String ListaDeExpDeIndAux() :
{ String exp, lista=""; }
{
	[<COMMA> exp = Expressao() lista = ListaDeExpDeIndAux(){return ","+exp+lista;}]
	{ return ""; }
}

/* argumentos nas atribuicoes */
String Argumentos():
{ String lista=""; }
{
	[
		<OPEN_PAR>
		lista = ListaDeArgumentos()
		<CLOSE_PAR>
		{ return "("+lista+")"; }
	]
	{ return ""; }
}

String ListaDeArgumentos() :
{ String exp, cont=""; }
{
	exp = Expressao() cont = ContinuacaoListaDeArgumentos()
	{ return exp+cont; }
}

String ContinuacaoListaDeArgumentos() :
{ String lista; }
{
	[
		<COMMA>
		lista = ListaDeArgumentos()
		{ return ","+lista; }
	]
	{ return ""; }
}
/*
String ParametrosPassados() :
{ String parametros="", lista; }
{     {System.err.println("ParametrosPassados atingido");}
	[
	<OPEN_PAR> { parametros="("; }
	lista = ListaParametrosPassados()
	<CLOSE_PAR> { parametros+=lista+")"; }
	{return parametros;}
	]
	{return parametros;}
}
*/
String ListaParametrosPassados() :
{ String lista=""; }
{
	 (<ID>|<NUM_INT>|<NUM_REAL>|<TRUE>|<FALSE>) { lista=getToken(0).image.toLowerCase(); }
	( <COMMA> (<ID>|<NUM_INT>|<NUM_REAL>|<TRUE>|<FALSE>) { lista+="," +getToken(0).image.toLowerCase();} )*

	{ return lista; }
}