options
{
  JAVA_UNICODE_ESCAPE = true;
  STATIC = false;
}

PARSER_BEGIN(OO2Parser)
package loo2.plp.orientadaObjetos2.parser;
import java.util.List;

import loo2.plp.orientadaObjetos1.comando.ChamadaMetodo;
import loo2.plp.orientadaObjetos1.comando.ComDeclaracao;
import loo2.plp.orientadaObjetos1.comando.Comando;
import loo2.plp.orientadaObjetos1.comando.IO;
import loo2.plp.orientadaObjetos1.comando.IfThenElse;
import loo2.plp.orientadaObjetos1.comando.Read;
import loo2.plp.orientadaObjetos1.comando.Sequencial;
import loo2.plp.orientadaObjetos1.comando.Skip;
import loo2.plp.orientadaObjetos1.comando.While;
import loo2.plp.orientadaObjetos1.comando.Write;
import loo2.plp.orientadaObjetos1.comando.Procedimento;
import loo2.plp.orientadaObjetos1.declaracao.Declaracao;
import loo2.plp.orientadaObjetos1.declaracao.classe.DecClasse;
import loo2.plp.orientadaObjetos1.declaracao.procedimento.DecParametro;
import loo2.plp.orientadaObjetos1.declaracao.procedimento.DecProcedimento;
import loo2.plp.orientadaObjetos1.declaracao.procedimento.DecProcedimentoComposta;
import loo2.plp.orientadaObjetos1.declaracao.procedimento.DecProcedimentoSimples;
import loo2.plp.orientadaObjetos1.declaracao.procedimento.ListaDeclaracaoParametro;
import loo2.plp.orientadaObjetos1.declaracao.variavel.CompostaDecVariavel;
import loo2.plp.orientadaObjetos1.declaracao.variavel.DecVariavel;
import loo2.plp.orientadaObjetos1.declaracao.variavel.SimplesDecVariavel;
import loo2.plp.orientadaObjetos1.expressao.Expressao;
import loo2.plp.orientadaObjetos1.expressao.ListaExpressao;
import loo2.plp.orientadaObjetos1.expressao.This;
import loo2.plp.orientadaObjetos1.expressao.binaria.ExpAnd;
import loo2.plp.orientadaObjetos1.expressao.binaria.ExpConcat;
import loo2.plp.orientadaObjetos1.expressao.binaria.ExpEquals;
import loo2.plp.orientadaObjetos1.expressao.binaria.ExpOr;
import loo2.plp.orientadaObjetos1.expressao.binaria.ExpSoma;
import loo2.plp.orientadaObjetos1.expressao.binaria.ExpSub;
import loo2.plp.orientadaObjetos1.expressao.leftExpression.AcessoAtributo;
import loo2.plp.orientadaObjetos1.expressao.leftExpression.Id;
import loo2.plp.orientadaObjetos1.expressao.leftExpression.LeftExpression;
import loo2.plp.orientadaObjetos1.expressao.unaria.ExpLength;
import loo2.plp.orientadaObjetos1.expressao.unaria.ExpMenos;
import loo2.plp.orientadaObjetos1.expressao.unaria.ExpNot;
import loo2.plp.orientadaObjetos1.expressao.valor.Valor;
import loo2.plp.orientadaObjetos1.expressao.valor.ValorBooleano;
import loo2.plp.orientadaObjetos1.expressao.valor.ValorInteiro;
import loo2.plp.orientadaObjetos1.expressao.valor.ValorNull;
import loo2.plp.orientadaObjetos1.expressao.valor.ValorString;
import loo2.plp.orientadaObjetos1.memoria.colecao.ListaValor;
import loo2.plp.orientadaObjetos1.util.Tipo;
import loo2.plp.orientadaObjetos1.util.TipoClasse;
import loo2.plp.orientadaObjetos1.util.TipoPrimitivo;
import loo2.plp.orientadaObjetos2.Programa;
import loo2.plp.orientadaObjetos2.declaracao.DecConstrutor;
import loo2.plp.orientadaObjetos2.declaracao.ListaDeclaracaoOO;
import loo2.plp.orientadaObjetos2.declaracao.classe.DecClasseSimplesOO2;
import loo2.plp.orientadaObjetos2.memoria.ContextoCompilacaoOO2;
import loo2.plp.orientadaObjetos2.memoria.ContextoExecucaoOO2;
import loo2.plp.orientadaObjetos2.comando.*;
import loo2.plp.orientadaObjetos2.expressao.leftExpression.*;
import loo2.plp.orientadaObjetos2.declaracao.variavel.DecVariavelObjetoOO2;

/**
 * Parser para a Linguagem de Programa��o Orientada a Objetos 2
 */
public class OO2Parser
{
  /**
     * M�todo principal que executa um dado programa que pode ser fornecido
     * atrav�s da entrada padr�o ou em um arquivo cujo nome entra como par�metro
     * para esse m�todo.
     * @param args Argumentos para o m�todo.
     */
  public static void main(String args [])
  {
    OO2Parser parser = null;
    if (args.length == 0)
    {
      System.out.println("OO2 PLP Parser Version 0.0.1:  Reading from standard input . . .");
      parser = new OO2Parser(System.in);
    }
    else if (args.length == 1)
    {
      System.out.println("OO2 PLP Parser Version 0.0.1:  Reading from file " + args [0] + " . . .");
      try
      {
        parser = new OO2Parser(new java.io.FileInputStream(args [0]));
      }
      catch (java.io.FileNotFoundException e)
      {
        System.out.println("Java Parser Version 1.0.2:  File " + args [0] + " not found.");
        return;
      }
    }
    else
    {
      System.out.println("OO2 PLP Parser Version 0.0.1:  Usage is one of:");
      System.out.println("         java OO2Parser < inputfile");
      System.out.println("OR");
      System.out.println("         java OO2Parser inputfile");
      return;
    }
    try
    {
      Programa programa = parser.processaEntrada();
      System.out.println("OO2 PLP Parser Version 0.0.1:  OO2 program parsed successfully.");
      if (programa.checaTipo(new ContextoCompilacaoOO2(new ListaValor())))
      {
        programa.executar(new ContextoExecucaoOO2());
      }
      else
      {
        System.out.println("Erro de tipo");
      }
    }
    catch (Exception e)
    {
      System.out.println("OO2 PLP Parser Version 0.0.1:  Encountered errors during parse.");
      e.printStackTrace();
    }
  }

  public static ListaValor criaListaValor(List valores)
  {
    if (valores.size() == 0)
    {
      return new ListaValor();
    }
    Valor primeiro = (Valor) valores.get(0);
    valores.remove(0);
    return new ListaValor(primeiro, criaListaValor(valores));
  }
}

PARSER_END(OO2Parser)

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

SPECIAL_TOKEN : /* COMMENTS */
{
  < SINGLE_LINE_COMMENT :
    "//" (~[ "\n", "\r" ])*
    (
      "\n"
    | "\r"
    | "\r\n"
    ) >
| < FORMAL_COMMENT :
    "/**" (~[ "*" ])* "*"
    (
      "*"
    |
      (
        ~[ "*", "/" ] (~[ "*" ])* "*"
      )
    )*
    "/" >
| < MULTI_LINE_COMMENT :
    "/*" (~[ "*" ])* "*"
    (
      "*"
    |
      (
        ~[ "*", "/" ] (~[ "*" ])* "*"
      )
    )*
    "/" >
}

TOKEN : /* TOKENS DE EXPRESSOES 1 */
{
  < AND : "and" >
| < OR : "or" >
| < NOT : "not" >
| < LENGTH : "length" >
| < TRUE : "true" >
| < FALSE : "false" >
}

TOKEN : /* TOKENS DE IMPERATIVA 1 */
{
  < VAR : "var" >
| < COMAND_SKIP : "skip" >
| < WHILE : "while" >
| < DO : "do" >
| < READ : "read" >
| < WRITE : "write" >
| < IF : "if" >
| < THEN : "then" >
| < ELSE : "else" >
}

TOKEN : /* TOKENS DE OO1 */
{
  < NEW : "new" >
| < THIS : "this" >
| < CLASSE : "classe" >
| < NULL : "null" >
| < PROC : "proc" >
}

TOKEN : /* TOKENS DE OO2 */
{
  < EXTENDS : "extends" >
}

TOKEN : /* TOKENS DOS POSS�VEIS TIPOS */
{
  < INT : "int" >
| < BOOLEAN : "boolean" >
| < STRING : "string" >
}

TOKEN : /* LITERALS */
{
  < INTEGER_LITERAL :
    < DECIMAL_LITERAL > ([ "l", "L" ])?
  | < HEX_LITERAL > ([ "l", "L" ])?
  | < OCTAL_LITERAL > ([ "l", "L" ])? >
| < #DECIMAL_LITERAL : [ "1"-"9" ] ([ "0"-"9" ])* >
| < #HEX_LITERAL : "0" [ "x", "X" ] ([ "0"-"9", "a"-"f", "A"-"F" ])+ >
| < #OCTAL_LITERAL : "0" ([ "0"-"7" ])* >
| < STRING_LITERAL :
    "\""
    (
      (~[ "\"", "\\", "\n", "\r" ])
    |
      (
        "\\"
        (
          [ "n", "t", "b", "r", "f", "\\", "'", "\"" ]
        | [ "0"-"7" ] ([ "0"-"7" ])?
        | [ "0"-"3" ] [ "0"-"7" ] [ "0"-"7" ]
        )
      )
    )*
    "\"" >
}

TOKEN : /* IDENTIFIERS */
{
  < IDENTIFIER :
    < LETTER >
    (
      < LETTER >
    | < DIGIT >
    )* >
| < #LETTER : [ "\u0024", "\u0041"-"\u005a", "\u005f", "\u0061"-"\u007a", "\u00c0"-"\u00d6", "\u00d8"-"\u00f6", "\u00f8"-"\u00ff", "\u0100"-"\u1fff", "\u3040"-"\u318f", "\u3300"-"\u337f", "\u3400"-"\u3d2d", "\u4e00"-"\u9fff", "\uf900"-"\ufaff" ] >
| < #DIGIT : [ "\u0030"-"\u0039", "\u0660"-"\u0669", "\u06f0"-"\u06f9", "\u0966"-"\u096f", "\u09e6"-"\u09ef", "\u0a66"-"\u0a6f", "\u0ae6"-"\u0aef", "\u0b66"-"\u0b6f", "\u0be7"-"\u0bef", "\u0c66"-"\u0c6f", "\u0ce6"-"\u0cef", "\u0d66"-"\u0d6f", "\u0e50"-"\u0e59", "\u0ed0"-"\u0ed9", "\u1040"-"\u1049" ] >
}

TOKEN : /* SEPARATORS */
{
  < LPAREN : "(" >
| < RPAREN : ")" >
| < LBRACE : "{" >
| < RBRACE : "}" >
| < LBRACKET : "[" >
| < RBRACKET : "]" >
| < SEMICOLON : ";" >
| < COMMA : "," >
| < DOT : "." >
}

TOKEN : /* OPERATORS */
{
  < ATTRIB : ":=" >
| < ASSIGN : "=" >
| < GT : ">" >
| < LT : "<" >
| < BANG : "!" >
| < TILDE : "~" >
| < HOOK : "?" >
| < COLON : ":" >
| < EQ : "==" >
| < LE : "<=" >
| < GE : ">=" >
| < NE : "!=" >
| < SC_OR : "||" >
| < SC_AND : "&&" >
| < CONCAT : "++" >
| < PLUS : "+" >
| < MINUS : "-" >
| < STAR : "*" >
| < SLASH : "/" >
| < BIT_AND : "&" >
| < BIT_OR : "|" >
| < XOR : "^" >
| < REM : "%" >
}

/**
 * M�todo chamado com o intuito de processar a entrada fornecida ao parser gerando
 * objeto do tipo Programa.
 **/
Programa processaEntrada() :
{
  Programa retorno;
}
{
  retorno = PPrograma() < EOF >
  {
    return retorno;
  }
}

/*
 * A partir de agora, ser�o expostos atrav�s desse tipo de coment�rio
 * as partes da BNF envolvidas no codigo mostrado em seguida.
 */
/**
 * Programa ::= "{" ListaDeclaracaoOO ";" Comando "}"
 **/
Programa PPrograma() :
{
  ListaDeclaracaoOO declaracoes = null;
  Comando comando = null;
}
{
  < LBRACE > declaracoes = PListaDeclaracaoOO() < SEMICOLON > comando = PComando() < RBRACE >
  {
    return new Programa(declaracoes, comando);
  }
}

/**
 * Comando::= ComandoSimples | ComandoSequencial
 **/
Comando PComando() :
{
  Comando retorno;
}
{
  (
    LOOKAHEAD(PComandoSimples() < SEMICOLON >)
    retorno = PComandoSequencial()
  | retorno = PComandoSimples()
  )
  {
    return retorno;
  }
}

/**
 * ComandoSequencial ::= ComandoSimples ";" Comando
 **/
Sequencial PComandoSequencial() :
{
  Comando c1;
  Comando c2;
}
{
  c1 = PComandoSimples() < SEMICOLON > c2 = PComando()
  {
    return new Sequencial(c1, c2);
  }
}

/**
 *
 * ComandoSimples ::= Skip
 *           		| ComDeclaracao
 *           		| While
 *           		| IfThenElse
 *           		| IO
 *           		| ChamadaMetodo
 *           		| New
 *          		| Atribuicao
 *                  | "("Comando")
 **/
Comando PComandoSimples() :
{
  Comando retorno;
}
{
  (
    LOOKAHEAD(< COMAND_SKIP >)
    retorno = PSkip()
  | LOOKAHEAD(< LBRACE >)
    retorno = PComDeclaracao()
  | LOOKAHEAD(< WHILE >)
    retorno = PWhile()
  | LOOKAHEAD(< IF >)
    retorno = PIfThenElse()
  | LOOKAHEAD(< READ >
  | < WRITE >)
    retorno = PIO()
  | LOOKAHEAD(PExpressaoChamadora() < DOT > PId() < LPAREN >)
    retorno = PChamadaMetodo()
  | LOOKAHEAD(PLeftExpression() < ATTRIB > < NEW >)
    retorno = PNew()
  | LOOKAHEAD(PLeftExpression() < ATTRIB >)
    retorno = PAtribuicao()
  | < LPAREN > retorno = PComando() < RPAREN >
  )
  {
    return retorno;
  }
}

/**
 * Skip::=
 **/
Skip PSkip() :
{}
{
  < COMAND_SKIP >
  {
    return new Skip();
  }
}

/**
 * ComDeclaracao :: = "{" DecVariavel ";" Comando "}"
 **/
ComDeclaracao PComDeclaracao() :
{
  Declaracao dec;
  Comando comando;
}
{
  < LBRACE > dec = PDecVariavel() < SEMICOLON > comando = PComando() < RBRACE >
  {
    return new ComDeclaracao(dec, comando);
  }
}

/**
 * While ::= "while" Expressao do" "{" Comando "}"
 **/
While PWhile() :
{
  Expressao expressao;
  Comando comando;
}
{
  < WHILE > expressao = PExpressao() < DO > < LBRACE > comando = PComando() < RBRACE >
  {
    return new While(expressao, comando);
  }
}

/**
 * IfThenElse ::= "if" Expressao "then" "{" Comando "}"
 *				| "if" Expressao "then" "{" Comando "}" "else" "{" Comando "}"
 **/
IfThenElse PIfThenElse() :
{
  Expressao expressao;
  Comando comandoThen;
  Comando comandoElse;
  IfThenElse resposta;
}
{
  (
    LOOKAHEAD(< IF > PExpressao() < THEN > < LBRACE > PComando() < RBRACE > < ELSE >)
    (
      < IF > expressao = PExpressao() < THEN > < LBRACE > comandoThen = PComando() < RBRACE > < ELSE > < LBRACE > comandoElse = PComando() < RBRACE >
      {
        resposta = new IfThenElse(expressao, comandoThen, comandoElse);
      }
    )
  |
    (
      < IF > expressao = PExpressao() < THEN > < LBRACE > comandoThen = PComando() < RBRACE >
      {
        resposta = new IfThenElse(expressao, comandoThen, new Skip());
      }
    )
  )
  {
    return resposta;
  }
}

/**
 * ChamadaMetodo ::= ExpressaoChamadora "." Id "(" ListaExpressao ")"
 *                 | ExpressaoChamadora "." Id "("")"
 **/
ChamadaMetodo PChamadaMetodo() :
{
  Expressao expressao;
  Id nomeMetodo;
  ListaExpressao parametros = null;
}
{
  (
    LOOKAHEAD(PExpressaoChamadora() < DOT > PId() < LPAREN > < RPAREN >)
    expressao = PExpressaoChamadora() < DOT > nomeMetodo = PId() < LPAREN > < RPAREN >
  | expressao = PExpressaoChamadora() < DOT > nomeMetodo = PId() < LPAREN > parametros = PListaExpressao() < RPAREN >
  )
  {
    if (parametros == null)
    {
      parametros = new ListaExpressao();
    }
    return new ChamadaMetodoOO2(expressao, nomeMetodo, parametros);
  }
}

/**
 * ListaExpressao ::= Expressao | Expressao "," ListaExpressao
 **/
ListaExpressao PListaExpressao() :
{
  ListaExpressao retorno;
  Expressao exp;
}
{
  (
    LOOKAHEAD(PListaExpressaoAtomica() < COMMA >)
    retorno = PListaExpressaoComposta()
  | exp = PListaExpressaoAtomica()
    {
      retorno = new ListaExpressao(exp);
    }
  )
  {
    return retorno;
  }
}

/**
 * ... Expressao "," ListaExpressao
 **/
ListaExpressao PListaExpressaoComposta() :
{
  Expressao e1;
  ListaExpressao e2;
}
{
  e1 = PListaExpressaoAtomica() < COMMA > e2 = PListaExpressao()
  {
    return new ListaExpressao(e1, e2);
  }
}

/**
 * ...Expressao
 **/
Expressao PListaExpressaoAtomica() :
{
  Expressao retorno;
}
{
  retorno = PExpressao()
  {
    return retorno;
  }
}

/**
 * New ::= LeftExpression ":=" "new" Id
 **/
NewOO2 PNew() :
{
  LeftExpression av;
  Id idClasse;
  ListaExpressao parametros= null;
}
{
  (
	  LOOKAHEAD(PLeftExpression() <ATTRIB> <NEW> PId() <LPAREN> <RPAREN>)
			av = PLeftExpression() <ATTRIB> <NEW> idClasse = PId() <LPAREN> <RPAREN>
			|
			av = PLeftExpression() <ATTRIB> <NEW> idClasse = PId() <LPAREN> parametros = PListaExpressao() <RPAREN>
	)
	{
	  	if (parametros == null){
			parametros = new ListaExpressao();
		}
		return new NewOO2(av, idClasse, parametros);
	}
}

/**
 * Atribuicao ::= LeftExpression ":=" Expressao
 **/
AtribuicaoOO2 PAtribuicao() :
{
  LeftExpression av;
  Expressao exp;
}
{
  av = PLeftExpression() < ATTRIB > exp = PExpressao()
  {
    return new AtribuicaoOO2(av, exp);
  }
}

/**
 * IO ::= "write" "(" Expressao ")" | "read" "(" Id ")"
 **/
IO PIO() :
{
  IO retorno;
}
{
  (
    LOOKAHEAD(< WRITE >)
    retorno = PWrite()
  | retorno = PRead()
  )
  {
    return retorno;
  }
}

/**
 * ... "read" "(" Id ")"
 **/
Read PRead() :
{
  Id id;
}
{
  < READ > < LPAREN > id = PId() < RPAREN >
  {
    return new Read(id);
  }
}

/**
 * ... "write" "(" Expressao ")"
 **/
Write PWrite() :
{
  Expressao exp;
}
{
  < WRITE > < LPAREN > exp = PExpressao() < RPAREN >
  {
    return new Write(exp);
  }
}

/**
 * Expressao ::= ExpUnaria | ExpBinaria | ExpPrimaria
 **/
Expressao PExpressao() :
{
  Expressao retorno;
}
{
  retorno = PExpBinaria()
  {
    return retorno;
  }
}

/**
 * ExpPrimaria ::= Valor | LeftExpression | this | "("Expressao")"
 **/
Expressao PExpPrimaria() :
{
  Expressao retorno;
}
{
  (
    LOOKAHEAD(PLeftExpression())
    retorno = PLeftExpression()
  | LOOKAHEAD(< THIS >)
    retorno = PThis()
  | LOOKAHEAD(< LPAREN > PExpressao() < RPAREN >)
    < LPAREN > retorno = PExpressao() < RPAREN >
  | retorno = PValor()
  )
  {
    return retorno;
  }
}

/**
 * Valor ::= ValorInteiro | ValorNull  | ValorBooleano | ValorString
 **/
Valor PValor() :
{
  Valor retorno;
}
{
  (
    LOOKAHEAD(< NULL >)
    retorno = PValorNull()
  | LOOKAHEAD(< INTEGER_LITERAL >)
    retorno = PValorInteiro()
  | LOOKAHEAD(< TRUE >
  | < FALSE >)
    retorno = PValorBooleano()
  | retorno = PValorString()
  )
  {
    return retorno;
  }
}

/**
 * ... ValorInteiro
 **/
Valor PValorInteiro() :
{
  Token token;
}
{
  token = < INTEGER_LITERAL >
  {
    return new ValorInteiro(Integer.parseInt(token.toString()));
  }
}

/**
 * ... ValorNull
 **/
ValorNull PValorNull() :
{}
{
  < NULL >
  {
    return new ValorNull();
  }
}

/**
 * ... ValorBooleano
 **/
Valor PValorBooleano() :
{}
{
  LOOKAHEAD(< FALSE >)
  < FALSE >
  {
    return new ValorBooleano(false);
  }
| < TRUE >
  {
    return new ValorBooleano(true);
  }
}

/**
 * ... ValorString
 **/
Valor PValorString() :
{
  Token token;
}
{
  token = < STRING_LITERAL >
  {
    String tokenStr = token.toString();
    //a seguir, serao retiradas as aspas do literal string
    tokenStr = tokenStr.substring(1, tokenStr.length() - 1);
    return new ValorString(tokenStr);
  }
}

/**
 * ExpUnaria ::= "-" Expressao | "not" Expressao | "length" Expressao | ExpPrimaria
 **/
Expressao PExpUnaria() :
{
  Expressao retorno;
}
{
  (
    retorno = PExpMenos()
  | retorno = PExpNot()
  | retorno = PExpLength()
  | retorno = PExpPrimaria()
  )
  {
    return retorno;
  }
}

/**
 * ... "-" Expressao
 **/
Expressao PExpMenos() :
{
  Expressao retorno;
}
{
  < MINUS > retorno = PExpressao()
  {
    return new ExpMenos(retorno);
  }
}

/**
 * ... "not" Expressao
 **/
Expressao PExpNot() :
{
  Expressao retorno;
}
{
  < NOT > retorno = PExpressao()
  {
    return new ExpNot(retorno);
  }
}

/**
 * ... "length" Expressao
 **/
Expressao PExpLength() :
{
  Expressao retorno;
}
{
  < LENGTH > retorno = PExpressao()
  {
    return new ExpLength(retorno);
  }
}

/**
 * ExpBinaria ::= ExpUnaria
 *        ( "+" ExpUnaria
 * 				| "-" ExpUnaria
 * 				| "and" ExpUnaria
 * 				| "or" ExpUnaria
 * 				| "==" ExpUnaria
 * 				| "++" Expressao)*
 **/
Expressao PExpBinaria() :
{
  Expressao retorno, param2;
}
{
  (
    retorno = PExpBinaria2()
    (
      < EQ > param2 = PExpBinaria2()
      {
        retorno = new ExpEquals(retorno, param2);
      }
    )*
  )
  {
    return retorno;
  }
}

Expressao PExpBinaria2() :
{
  Expressao retorno, param2;
}
{
  (
    retorno = PExpBinaria3()
    (
      < CONCAT > param2 = PExpBinaria3()
      {
        retorno = new ExpConcat(retorno, param2);
      }
    | < MINUS > param2 = PExpBinaria3()
      {
        retorno = new ExpSub(retorno, param2);
      }
    | < OR > param2 = PExpBinaria3()
      {
        retorno = new ExpOr(retorno, param2);
      }
    | < PLUS > param2 = PExpBinaria3()
      {
        retorno = new ExpSoma(retorno, param2);
      }
    )*
  )
  {
    return retorno;
  }
}

Expressao PExpBinaria3() :
{
  Expressao retorno, param2;
}
{
  (
    retorno = PExpUnaria()
    (
      < AND > param2 = PExpUnaria()
      {
        retorno = new ExpAnd(retorno, param2);
      }
    )*
  )
  {
    return retorno;
  }
}

/**
 * ... this
 **/
This PThis() :
{}
{
  < THIS >
  {
    return new This();
  }
}

/**
 * LeftExpression ::= Id | AcessoAtributo
 **/
LeftExpression PLeftExpression() :
{
  LeftExpression retorno;
}
{
  (
    LOOKAHEAD(PAcessoAtributoId())
    retorno = PAcessoAtributoId()
  | LOOKAHEAD(PAcessoAtributoThis())
    retorno = PAcessoAtributoThis()
  | LOOKAHEAD(< IDENTIFIER >)
    retorno = PId()
  )
  {
    return retorno;
  }
}

/**
 * ... Id
 **/
Id PId() :
{
  Token token;
}
{
  token = < IDENTIFIER >
  {
    return new Id(token.toString());
  }
}

/**
 * AcessoAtributo ::= this.Id | (this).id | "("LeftExpression")".Id | Id.Id
 **/
AcessoAtributo PAcessoAtributo() :
{
  AcessoAtributo retorno;
}
{
  (
    LOOKAHEAD(< THIS >)
    retorno = PAcessoAtributoThis()
  | retorno = PAcessoAtributoId()
  )
  {
    return retorno;
  }
}

/**
 * ... this.Id | (this).id
 **/
AcessoAtributoThisOO2 PAcessoAtributoThis() :
{
  This t;
  Id id;
}
{
  (
    LOOKAHEAD(< LPAREN >)
    < LPAREN > t = PThis() < RPAREN > < DOT > id = PId()
  | t = PThis() < DOT > id = PId()
  )
  {
    return new AcessoAtributoThisOO2(t, id);
  }
}

/**
 * ... "("LeftExpression")".Id | Id.Id
 **/
AcessoAtributoIdOO2 PAcessoAtributoId() :
{
  LeftExpression av;
  Id id;
}
{
  (
    LOOKAHEAD(< LPAREN >)
    < LPAREN > av = PLeftExpression() < RPAREN >
  | av = PId()
  )
  < DOT > id = PId()
  {
    return new AcessoAtributoIdOO2(av, id);
  }
}

/**
 * Uma expressao chamadora eh aquela que chama um m�todo. Ela sabe separar
 * o acesso de atributo, que � o que ela retorna, da chamada do m�todo em si
 * (<DOT><IDENTIFIER><LPAREN>).
 *
 * PExpressaoChamadora:: this | id | LeftExpressionChamadora
 *
 */
Expressao PExpressaoChamadora() :
{
  Expressao exp;
}
{
  (
    LOOKAHEAD(< THIS > < DOT > < IDENTIFIER > < LPAREN >)
    exp = PThis()
  | LOOKAHEAD(< IDENTIFIER > < DOT > < IDENTIFIER > < LPAREN >)
    exp = PId()
  | LOOKAHEAD(PLeftExpressionChamadora() < DOT > < IDENTIFIER > < LPAREN >)
    exp = PLeftExpressionChamadora()
  )
  {
    return exp;
  }
}

/**
 * LeftExpressionChamadora ::=  AcessoAtributoChamador | AcessoAtributoThis | id
 **/
LeftExpression PLeftExpressionChamadora() :
{
  LeftExpression retorno;
}
{
  (
    LOOKAHEAD(PAcessoAtributoIdChamador())
    retorno = PAcessoAtributoIdChamador()
  | LOOKAHEAD(PAcessoAtributoThis())
    retorno = PAcessoAtributoThis()
  | LOOKAHEAD(< IDENTIFIER >)
    retorno = PId()
  )
  {
    return retorno;
  }
}

/**
 * ... "("LeftExpressionChamadora")".Id | Id.Id
 **/
AcessoAtributoIdOO2 PAcessoAtributoIdChamador() :
{
  LeftExpression av;
  Id id;
}
{
  (
    LOOKAHEAD(< LPAREN > PLeftExpressionChamadora() < RPAREN > < DOT > < IDENTIFIER >)
    < LPAREN > av = PLeftExpressionChamadora() < RPAREN > < DOT > id = PId()
  | LOOKAHEAD(< IDENTIFIER > < DOT > < IDENTIFIER >)
    av = PId() < DOT > id = PId()
  )
  {
    return new AcessoAtributoIdOO2(av, id);
  }
}

/**
*ListaDeclaracaoOO := DecClasse
*                   | DecClasse "," ListaDeclaracaoOO
**/

ListaDeclaracaoOO PListaDeclaracaoOO() :
{
	ListaDeclaracaoOO retorno;
	DecClasse decClasse;
}
{
  (
    LOOKAHEAD(PDecClasseAtomica() < COMMA >)
    	retorno = PDecClasseComposta()
  	|decClasse = PDecClasseAtomica()
  	{
    	retorno = new ListaDeclaracaoOO(decClasse);
  	}
  )
  {
    return retorno;
  }
}

/**
 * DecClasse ::= "classe" Id ["extends" Id] "{" DecVariavel ";" DecConstrutor ";" DecProcedimento "}"
 **/
 
DecClasse PDecClasseAtomica() :
{
  Id nomeClasse;
  Id superClasse = null;
  DecVariavel atributos;
  DecConstrutor decConstrutor = null;
  DecProcedimento metodos;
  DecClasse resposta;
}
{
	(
		LOOKAHEAD(<CLASSE> PId() <EXTENDS> PId())
		(
			<CLASSE> nomeClasse = PId() <EXTENDS> superClasse = PId()
			<LBRACE> 
				atributos = PDecVariavel() <SEMICOLON>
				decConstrutor = PDecConstrutor(nomeClasse) <COMMA>
				metodos = PDecProcedimento() 
			<RBRACE>
			{
				resposta = new DecClasseSimplesOO2(nomeClasse, superClasse, atributos, decConstrutor, metodos);
			}	
		)
		|
		LOOKAHEAD(<CLASSE> PId())
		(
			<CLASSE> nomeClasse = PId() 
			<LBRACE> 
				atributos = PDecVariavel() <SEMICOLON>
				decConstrutor = PDecConstrutor(nomeClasse) <COMMA>
				metodos = PDecProcedimento() 
			<RBRACE>
			{
				resposta = new DecClasseSimplesOO2(nomeClasse, superClasse, atributos, decConstrutor, metodos);
			}
		) 
	)
	{
		return resposta;
	}
}

/**
 * ...  | DecClasse "," ListaDeclaracaoOO
 **/
ListaDeclaracaoOO PDecClasseComposta() :
{
  DecClasse d1;
  ListaDeclaracaoOO d2;
}
{
  d1 = PDecClasseAtomica() < COMMA > d2 = PListaDeclaracaoOO()
  {
    return new ListaDeclaracaoOO(d1, d2);
  }
}

/**
 * DecVariavel ::= Tipo Id "=" Expressao
 *				 | DecVariavel "," DecVariavel
 *               | Tipo Id ":=" "new" Id
 *               | "("DecVariavel")"
 **/
DecVariavel PDecVariavel() :
{
  DecVariavel retorno;
}
{
  (
    LOOKAHEAD(PDecVariavelAtomica() < COMMA >)
    retorno = PCompostaDecVariavel()
  | retorno = PDecVariavelAtomica()
  )
  {
    return retorno;
  }
}

/**
 * DecConstrutor
 **/

DecConstrutor PDecConstrutor(Id nomeClasse):
{
	Id nomeMetodo;
	ListaDeclaracaoParametro listaPar = null;
	Comando comando;
}
{
    (
        LOOKAHEAD(PId() <LPAREN> <RPAREN>)
    		nomeMetodo = PId() <LPAREN> <RPAREN>
    		<LBRACE> comando = PComando() <RBRACE>
    	|
    		nomeMetodo = PId() <LPAREN> listaPar = PListaDeclaracaoParametro() <RPAREN>
    		<LBRACE> comando = PComando() <RBRACE>
    )
    
	{
	    if(listaPar == null) {
	        listaPar = new ListaDeclaracaoParametro();
	    }

	    return new DecConstrutor(nomeClasse, nomeMetodo, listaPar, comando);
	}
}

/**
 * ... DecVariavel "," DecVariavel
 **/
CompostaDecVariavel PCompostaDecVariavel() :
{
  DecVariavel d1;
  DecVariavel d2;
}
{
  d1 = PDecVariavelAtomica() < COMMA > d2 = PDecVariavel()
  {
    return new CompostaDecVariavel(d1, d2);
  }
}

/**
 * ... Tipo Id "=" Expressao | Tipo Id ":=" "new" Id | "("DecVariavel")"
 **/
DecVariavel PDecVariavelAtomica() :
{
  DecVariavel retorno;
}
{
  (
    LOOKAHEAD(PTipo() PId() < ATTRIB > < NEW >)
    retorno = PDecVariavelObjeto()
  | LOOKAHEAD(< LPAREN > PDecVariavel() < RPAREN >)
    < LPAREN > retorno = PDecVariavel() < RPAREN >
  | LOOKAHEAD(PTipo() PId() < ASSIGN > PExpressao())
    retorno = PSimplesDecVariavel()
  )
  {
    return retorno;
  }
}

/**
 * ... Tipo Id ":=" "new" Id
 **/
DecVariavelObjetoOO2 PDecVariavelObjeto() :
{
	Id id, idClasse;
	ListaExpressao parametros= null;
	Tipo tipo;
}
{
  (
    LOOKAHEAD( PTipo() PId() <ATTRIB> <NEW> PId() <LPAREN> <RPAREN> )
			tipo = PTipo() id = PId() <ATTRIB> <NEW> idClasse = PId() <LPAREN> <RPAREN>
			|
			tipo = PTipo() id = PId() <ATTRIB> <NEW> idClasse = PId() <LPAREN> parametros = PListaExpressao() <RPAREN>
  )
	{
	  	if (parametros == null){
			parametros = new ListaExpressao();
		}
		return new DecVariavelObjetoOO2(tipo, id, idClasse, parametros);
	}
}


/**
 * ... Tipo Id "=" Expressao
 **/
SimplesDecVariavel PSimplesDecVariavel() :
{
  Id id;
  Expressao exp;
  SimplesDecVariavel retorno;
  Tipo tipo;
}
{
  (
    tipo = PTipo() id = PId() < ASSIGN > exp = PExpressao()
    {
      retorno = new SimplesDecVariavel(tipo, id, exp);
    }
  )
  {
    return retorno;
  }
}

/**
 * DecProcedimento ::= "proc" Id "("")" "{"Comando"}"
 *                   | "proc" Id "(" ListaDeclaracaoParametro ")" "{"Comando"}"
 *                   | DecProcedimento "," DecProcedimento
 **/
DecProcedimento PDecProcedimento() :
{
  DecProcedimento retorno;
}
{
  (
    LOOKAHEAD(PDecProcedimentoSimples() < COMMA >)
    retorno = PDecProcedimentoComposta()
  | retorno = PDecProcedimentoSimples()
  )
  {
    return retorno;
  }
}

/**
 * ... DecProcedimento "," DecProcedimento
 **/
DecProcedimentoComposta PDecProcedimentoComposta() :
{
  DecProcedimento d1;
  DecProcedimento d2;
}
{
  d1 = PDecProcedimentoSimples() < COMMA > d2 = PDecProcedimento()
  {
    return new DecProcedimentoComposta(d1, d2);
  }
}

/**
 * ... "proc" Id "("")" "{"Comando"}"|"proc" Id "(" ListaDeclaracaoParametro ")" "{"Comando"}"
 **/
DecProcedimento PDecProcedimentoSimples() :
{
  Id nome;
  ListaDeclaracaoParametro listaPar = null;
  Comando comando;
}
{
  (
    LOOKAHEAD(< PROC > PId() < LPAREN > < RPAREN >)
    < PROC > nome = PId() < LPAREN > < RPAREN > < LBRACE > comando = PComando() < RBRACE >
  | < PROC > nome = PId() < LPAREN > listaPar = PListaDeclaracaoParametro() < RPAREN > < LBRACE > comando = PComando() < RBRACE >
  )
  {
    if (listaPar == null)
    {
      listaPar = new ListaDeclaracaoParametro();
    }
    return new DecProcedimentoSimples(nome, listaPar, comando);
  }
}

/**
 * ListaDeclaracaoParametro ::= Tipo Id | Tipo Id "," ListaDeclaracaoParametro
 **/
ListaDeclaracaoParametro PListaDeclaracaoParametro() :
{
  ListaDeclaracaoParametro retorno;
  DecParametro decPar;
}
{
  (
    LOOKAHEAD(PDecParametroAtomico() < COMMA >)
    retorno = PDecParametroComposto()
  | decPar = PDecParametroAtomico()
    {
      retorno = new ListaDeclaracaoParametro(decPar);
    }
  )
  {
    return retorno;
  }
}

/**
 * ... Tipo Id "," ListaDeclaracaoParametro
 **/
ListaDeclaracaoParametro PDecParametroComposto() :
{
  DecParametro d1;
  ListaDeclaracaoParametro d2;
}
{
  d1 = PDecParametroAtomico() < COMMA > d2 = PListaDeclaracaoParametro()
  {
    return new ListaDeclaracaoParametro(d1, d2);
  }
}

/**
 * ...Tipo Id
 **/
DecParametro PDecParametroAtomico() :
{
  DecParametro retorno;
  Tipo tipo;
  Id id;
}
{
  tipo = PTipo() id = PId()
  {
    return new DecParametro(id, tipo);
  }
}

/**
 * Tipo ::= TipoClasse | TipoPrimitivo
 **/
Tipo PTipo() :
{
  Tipo tipo;
}
{
  (
    LOOKAHEAD(< STRING >
  | < INT >
  | < BOOLEAN >)
    tipo = PTipoPrimitivo()
  | tipo = PTipoClasse()
  )
  {
    return tipo;
  }
}

/**
 * TipoPrimitivo ::= "string" | "int" | "boolean"
 **/
Tipo PTipoPrimitivo() :
{
  Tipo retorno;
}
{
  (
    LOOKAHEAD(< INT >)
    < INT >
    {
      retorno = TipoPrimitivo.TIPO_INTEIRO;
    }
  | LOOKAHEAD(< BOOLEAN >)
    < BOOLEAN >
    {
      retorno = TipoPrimitivo.TIPO_BOOLEANO;
    }
  | < STRING >
    {
      retorno = TipoPrimitivo.TIPO_STRING;
    }
  )
  {
    return retorno;
  }
}

/**
 * TipoClasse ::= Id
 **/
Tipo PTipoClasse() :
{
  Tipo retorno;
  Id id;
}
{
  (
    id = PId()
    {
      retorno = new TipoClasse(id);
    }
  )
  {
    return retorno;
  }
}