options
{
  //LOOKAHEAD = 2;
  DEBUG_PARSER = true;
  //FORCE_LA_CHECK = true;
  JAVA_UNICODE_ESCAPE = true;
}

PARSER_BEGIN(Func3Parser)
package lf3.plp.functional3.parser;
import java.util.ArrayList;
import java.util.List;
//Imports da Funcional3
import lf3.plp.functional3.*;
import lf3.plp.functional3.expression.*;
import lf3.plp.functional3.declaration.DecComposta;
//Imports da Funcional2
import lf3.plp.functional2.declaration.DecFuncao;
import lf3.plp.functional2.expression.ValorFuncao;
import lf3.plp.functional2.expression.ExpDeclaracao;
import lf3.plp.functional2.expression.Aplicacao;
//Imports da Funcional1
import lf3.plp.functional1.declaration.DeclaracaoFuncional;
import lf3.plp.functional1.declaration.DecVariavel;
import lf3.plp.functional1.expression.IfThenElse;
//Imports da Express�o2
import lf3.plp.expressions2.expression.Expressao;
import lf3.plp.expressions2.expression.Valor;
import lf3.plp.expressions2.expression.ValorInteiro;
import lf3.plp.expressions2.expression.ValorString;
import lf3.plp.expressions2.expression.ValorBooleano;
import lf3.plp.expressions2.expression.Id;
import lf3.plp.expressions2.expression.ExpMenos;
import lf3.plp.expressions2.expression.ExpNot;
import lf3.plp.expressions2.expression.ExpLength;
import lf3.plp.expressions2.expression.ExpSoma;
import lf3.plp.expressions2.expression.ExpSub;
import lf3.plp.expressions2.expression.ExpAnd;
import lf3.plp.expressions2.expression.ExpOr;
import lf3.plp.expressions2.expression.ExpEquals;
import lf3.plp.expressions2.expression.ExpConcat;

public class Func3Parser
{
  public static void main(String args [])
  {
    Func3Parser parser;
    if (args.length == 0)
    {
      System.out.println("Funcional 3 PLP Parser Version 0.0.1:  Reading from standard input . . .");
      parser = new Func3Parser(System.in);
    }
    else if (args.length == 1)
    {
      System.out.println("Funcional 3 PLP Parser Version 0.0.1:  Reading from file " + args [0] + " . . .");
      try
      {
        parser = new Func3Parser(new java.io.FileInputStream(args [0]));
      }
      catch (java.io.FileNotFoundException e)
      {
        System.out.println("Funcional 3 PLP Parser Version 0.0.1:  File " + args [0] + " not found.");
        return;
      }
    }
    else
    {
      System.out.println("Funcional 3 PLP Parser Version 0.0.1:  Usage is one of:");
      System.out.println("         java Func3Parser < inputfile");
      System.out.println("OR");
      System.out.println("         java Func3Parser inputfile");
      return;
    }
    Programa programa = null;
    try
    {
      programa = parser.Input();

       if (!programa.checaTipo())
 	  {
 	    System.out.println("Funcional 3 PLP Parser Version 0.0.1: Encountered errors during parse.");
      	System.exit(0);
      }
      
      System.out.println("Funcional 3 PLP Parser Version 0.0.1: Funcional3 program parsed successfully.");
    }
    catch (Exception e)
    {
      e.printStackTrace();
      System.out.println("Funcional 3 PLP Parser Version 0.0.1: Encountered errors during parse.");
      System.exit(0);
    }
    try
    {
      System.out.println("Funcional 3 PLP Parser Version 0.0.1: running...");
      Valor val = (Valor) programa.executar();
      if (val instanceof ValorString)
      {
        ValorString valStr = (ValorString) val;
        System.out.println("Funcional 3 PLP Parser Version 0.0.1: resultado=" + valStr.valor());
      }
      else if (val instanceof ValorInteiro)
      {
        ValorInteiro valInt = (ValorInteiro) val;
        System.out.println("Funcional 3 PLP Parser Version 0.0.1: resultado=" + valInt.valor());
      }
      else if (val instanceof ValorBooleano)
      {
        ValorBooleano valBool = (ValorBooleano) val;
        System.out.println("Funcional 3 PLP Parser Version 0.0.1: resultado=" + valBool.valor());
      }
      else if (val instanceof ValorFuncao)
      {
        ValorFuncao valFunc = (ValorFuncao) val;
        System.out.println("Funcional 3 PLP Parser Version 0.0.1: resultado = " + valFunc);
      }
       else if (val instanceof ValorLista)
      {
        ValorLista valLista = (ValorLista) val;
        System.out.println("Funcional 3 PLP Parser Version 0.0.1: resultado = " + valLista.valor());
      }
    }
    catch (Exception e)
    {
      e.printStackTrace();
      System.out.println("Funcional 3 PLP Parser Version 0.0.1:  Encountered errors during execution.");
    }
  }
}

PARSER_END(Func3Parser)

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 FUNCIONAL 3 */
{
  < AND : "and" >
| < OR : "or" >
| < NOT : "not" >
| < LENGTH : "length" >
| < TRUE : "true" >
| < FALSE : "false" >
| < LET : "let" >
| < VAR : "var" >
| < IN : "in" >
| < IF : "if" >
| < THEN : "then" >
| < ELSE : "else" >
| < FUNC : "fun" >
| < FN : "fn" >
| < HEAD : "head" >
| < TAIL : "tail" >
| < FOR : "for" >
}

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 */
{
  < ASSIGN : "=" >
| < GT : ">" >
| < LT : "<" >
| < BANG : "!" >
| < TILDE : "~" >
| < HOOK : "?" >
| < EQ : "==" >
| < LE : "<=" >
| < GE : ">=" >
| < NE : "!=" >
| < SC_OR : "||" >
| < SC_AND : "&&" >
| < CONCAT : "++" >
| < CONS : ":" >
| < CONCAT_LISTA : "^^" >
| < SEQ : ".." >
| < PLUS : "+" >
| < MINUS : "-" >
| < STAR : "*" >
| < SLASH : "/" >
| < BIT_AND : "&" >
| < BIT_OR : "|" >
| < XOR : "^" >
| < REM : "%" >
}

Programa Input() :
{
  Programa retorno;
}
{
  retorno = PPrograma() < EOF >
  {
    return retorno;
  }
}

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

ValorBooleano PValorBooleano() :
{
}
{
  < FALSE >
  {
    return new ValorBooleano(false);
  }
| < TRUE >
  {
    return new ValorBooleano(true);
  }
}

ValorString PValorString() :
{
  Token token;
}
{
  token = < STRING_LITERAL >
  {
    String tokenStr = token.toString();
    tokenStr = tokenStr.substring(1, tokenStr.length() - 1);
    return new ValorString(tokenStr);
  }
}

Valor PValorFuncao() :
{
  List lista = null;
  Expressao expressao;
}
{
  < FN > lista = PListaId() < DOT > expressao = PExpressao()
  {
    return new ValorFuncao(lista, expressao);
  }
}

Valor PValorLista() :
{
  Expressao v = null;
  ValorLista vlista = null;
}
{
  LOOKAHEAD(< LBRACKET > < RBRACKET >)
  < LBRACKET > < RBRACKET >
  {
    return ValorLista.getInstancia(null, null);
  }
|
  (
    < LBRACKET > v = PExpressao()
    {
      vlista = ValorLista.getInstancia(v, null);
    }
    (
      < COMMA > v = PExpressao()
      {
        vlista.cons(v);
      }
    )*
    < RBRACKET >
  )
  {
    return vlista.inverter();
  }
}

Valor PValor() :
{
  Valor retorno;
}
{
  (
    retorno = PValorInteiro()
  | retorno = PValorBooleano()
  | retorno = PValorString()
  | retorno = PValorFuncao()
  | retorno = PValorLista()
  )
  {
    return retorno;
  }
}

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

Expressao PExpMenos() :
{
  Expressao retorno;
}
{
  < MINUS > retorno = PExpPrimaria()
  {
    return new ExpMenos(retorno);
  }
}

Expressao PExpNot() :
{
  Expressao retorno;
}
{
  < NOT > retorno = PExpPrimaria()
  {
    return new ExpNot(retorno);
  }
}

Expressao PExpLength() :
{
  Expressao retorno;
}
{
  < LENGTH > retorno = PExpPrimaria()
  {
    if (retorno instanceof ValorString)
    {
      ValorString val = (ValorString) retorno;
    }
    return new ExpLength(retorno);
  }
}

Expressao PExpPrimaria() :
{
  Expressao retorno;
}
{
  (
    retorno = PValor()
  | LOOKAHEAD(PId() < LPAREN >)
    retorno = PAplicacao()
  | retorno = PId()
  | < LPAREN > retorno = PExpressao() < RPAREN >
  )
  {
    return retorno;
  }
}

Expressao PAplicacao() :
{
  Id id;
  List lista;
}
{
  id = PId() < LPAREN > lista = PListaExpr() < RPAREN >
  {
    return new Aplicacao(id, lista);
  }
}

List PListaId() :
{
  List retorno = null;
  Id id;
}
{
  (
    id = PId()
    {
      if (retorno == null)
      {
        retorno = new ArrayList();
        retorno.add(id);
      }
      else
      {
        retorno.add(id);
      }
    }
  )*
  {
    return retorno;
  }
}

DeclaracaoFuncional PDeclVar() :
{
  Id id;
  Expressao expressao;
  DeclaracaoFuncional retorno;
}
{
  (
    < VAR > id = PId() < ASSIGN > expressao = PExpressao()
  )
  {
    return new DecVariavel(id, expressao);
  }
}

DeclaracaoFuncional PDeclFuncao() :
{
  Id id;
  Expressao expressao;
  DeclaracaoFuncional retorno;
  List lista;
}
{
  (
    < FUNC > id = PId() lista = PListaId() < ASSIGN > expressao = PExpressao()
  )
  {
    return new DecFuncao(id, new ValorFuncao(lista, expressao));
  }
}

DecComposta PDecComposta() :
{
	DeclaracaoFuncional d1;
	DeclaracaoFuncional d2;
}
{
  	(
  	  d1 = PDeclVar()
  	| d1 = PDeclFuncao()
  	)
	<COMMA> d2 = PDeclFuncional()
	{return new DecComposta(d1, d2);}
}

DeclaracaoFuncional PDeclFuncional() :
{
  DeclaracaoFuncional decl;
}
{
  (
    LOOKAHEAD(PDeclVar() < COMMA >)
    decl = PDecComposta()
  | LOOKAHEAD(PDeclFuncao() < COMMA >)
  	decl = PDecComposta()
  | decl = PDeclVar()
  | decl = PDeclFuncao()
  | < LPAREN > decl = PDeclFuncional() < RPAREN >
  )
  {
    return decl;
  }
}

Expressao PExpDeclaracao() :
{
  DeclaracaoFuncional  declaracoes;
  Expressao expressao;
}
{
  < LET > declaracoes = PDeclFuncional() < IN > expressao = PExpressao()
  {
    return new ExpDeclaracao(declaracoes, expressao);
  }
}

Expressao PExpCondicional() :
{
  Expressao expCond, expThen, expElse;
}
{
  < IF > expCond = PExpressao() < THEN > expThen = PExpressao() 
  < ELSE > expElse = PExpressao()
  {
    return new IfThenElse(expCond, expThen, expElse);
  }
}

List PListaExpr() :
{
  List retorno = null;
  Expressao expr;
}
{
  (
    expr = PExpressao()
    {
      retorno = new ArrayList();
      retorno.add(expr);
    }
    (
      < COMMA > expr = PExpressao()
      {
        retorno.add(expr);
      }
    )*
  )
  {
    return retorno;
  }
}

Expressao PExpHead() :
{
  Expressao tmpExp = null;
}
{
  < HEAD > tmpExp = PExpressao()
  {
    return new ExpHead(tmpExp);
  }
}

Expressao PExpTail() :
{
  Expressao tmpExp = null;
}
{
  < TAIL > tmpExp = PExpressao()
  {
    return new ExpTail(tmpExp);
  }
}

Expressao PExpCompreensaoLista() :
{
  ExpCompreensaoLista retorno = null;
  Expressao expressao = null;
  Expressao filtro = null;
  List geradores = new ArrayList();
  Gerador geradorTemp = null;
}
{
  < LBRACKET > expressao = PExpressao()
  (
    geradorTemp = PGerador()
    {
      geradores.add(geradorTemp);
    }
  )+
  (
    < IF > filtro = PExpressao()
  )?
  < RBRACKET >
  {
    retorno = new ExpCompreensaoLista(expressao);
    retorno.setFiltro(filtro);
    retorno.setGeradores(geradores);
    return retorno;
  }
}

Gerador PGerador() :
{
  Id id = null;
  Expressao expressao = null;
}
{
  < FOR > id = PId() < IN > expressao = PExpressao() (< COMMA >)?
  {
    return new Gerador(id, expressao);
  }
}

Expressao PExpUnaria() :
{
  Expressao retorno;
}
{
  (
    LOOKAHEAD(PExpMenos())
    retorno = PExpMenos()
  | 
    LOOKAHEAD(PExpNot())
    retorno = PExpNot()
  | 
    LOOKAHEAD(PExpLength())
    retorno = PExpLength()
  | 
    LOOKAHEAD(PExpHead())
    retorno = PExpHead()
  | 
    LOOKAHEAD(PExpTail())
    retorno = PExpTail()
  | 
    LOOKAHEAD(PExpDeclaracao())
    retorno = PExpDeclaracao()
  | 
    LOOKAHEAD(PExpCondicional())
    retorno = PExpCondicional()
  | 
    LOOKAHEAD(PExpCompreensaoLista())
    retorno = PExpCompreensaoLista()
  | 
    LOOKAHEAD(PExpPrimaria())
    retorno = PExpPrimaria()
  )
  {
    return retorno;
  }
}

Expressao PExpBinaria() :
{
  Expressao retorno, param2;
  Id id;
  List list = null;
}
{
  (
    retorno = PExpUnaria()
    (
      < PLUS > param2 = PExpUnaria()
      {
        retorno = new ExpSoma(retorno, param2);
      }
    | 
      < MINUS > param2 = PExpUnaria()
      {
        retorno = new ExpSub(retorno, param2);
      }
    | 
      < AND > param2 = PExpUnaria()
      {
        retorno = new ExpAnd(retorno, param2);
      }
    | 
      < OR > param2 = PExpUnaria()
      {
        retorno = new ExpOr(retorno, param2);
      }
    | 
      < EQ > param2 = PExpUnaria()
      {
        retorno = new ExpEquals(retorno, param2);
      }
    | 
      < CONCAT > param2 = PExpUnaria()
      {
        retorno = new ExpConcat(retorno, param2);
      }
    | 
      < CONS > param2 = PExpressao()
      {
        retorno = new ExpCons(retorno, param2);
      }
    | 
      < CONCAT_LISTA > param2 = PExpressao()
      {
        retorno = new ExpConcatLista(retorno, param2);
      }
    | 
      < SEQ > param2 = PExpressao()
      {
        retorno = new ExpSequencia(retorno, param2);
      }
    | 
      < GT > param2 = PExpressao()
      {
        retorno = new ExpMaiorQue(retorno, param2);
      }
    | 
      < LT > param2 = PExpressao()
      {
        retorno = new ExpMenorQue(retorno, param2);
      }
    | 
      < STAR > param2 = PExpressao()
      {
        retorno = new ExpMult(retorno, param2);
      }
    | 
      < LPAREN > [ list = PListaExpr() ] < RPAREN >
      {
        retorno = new Aplicacao((Expressao) retorno, list);
      }
    )*
  )
  {
    return retorno;
  }
}

Expressao PExpressao() :
{
  Expressao retorno;
}
{
  retorno = PExpBinaria()
  {
    return retorno;
  }
}

Programa PPrograma() :
{
  Expressao retorno;
}
{
  retorno = PExpressao()
  {
    return new Programa(retorno);
  }
}