options {

//LOOKAHEAD = 2;
DEBUG_PARSER = true;
//FORCE_LA_CHECK = true;
JAVA_UNICODE_ESCAPE = true;

}

PARSER_BEGIN(Func4Parser)

package plp.functional4.parser;

import java.util.ArrayList;
import java.util.List;

//Imports da Funcional4
import plp.functional4.expression.*;
import plp.functional4.util.*;
import plp.functional4.Programa;
import plp.functional4.declaration.DecFuncao;
import plp.functional4.declaration.DeclaracaoFuncional;
import plp.functional4.declaration.DecVariavel;

//Imports da Express�o2
import plp.expressions2.expression.Expressao;
import plp.expressions2.expression.ExpressaoComplexa;
import plp.expressions2.expression.Valor;
import plp.expressions2.expression.ValorInteiro;
import plp.expressions2.expression.ValorString;
import plp.expressions2.expression.ValorBooleano;
import plp.expressions2.expression.Id;
import plp.expressions2.expression.ExpMenos;
import plp.expressions2.expression.ExpNot;
import plp.expressions2.expression.ExpLength;
import plp.expressions2.expression.ExpSoma;
import plp.expressions2.expression.ExpSub;
import plp.expressions2.expression.ExpAnd;
import plp.expressions2.expression.ExpOr;
import plp.expressions2.expression.ExpEquals;
import plp.expressions2.expression.ExpConcat;

public class Func4Parser {

    public static void main(String args[]) {

	    Func4Parser parser;

	    if (args.length == 0) {
	    	System.out.println("Funcional 4 PLP Parser Version 0.0.1:  Reading from standard input . . .");
	    	parser = new Func4Parser(System.in);
	    } else if (args.length == 1) {

	    	System.out.println("Funcional 4 PLP Parser Version 0.0.1:  Reading from file " + args[0] + " . . .");

	    	try {
	    		parser = new Func4Parser(new java.io.FileInputStream(args[0]));
	    	} catch (java.io.FileNotFoundException e) {
	        	System.out.println("Funcional 4 PLP Parser Version 0.0.1:  File " + args[0] + " not found.");
	        	return;
	    	}
	    } else {
	    	System.out.println("Funcional 4 PLP Parser Version 0.0.1:  Usage is one of:");
	    	System.out.println("         java Func4Parser < inputfile");
	    	System.out.println("OR");
	    	System.out.println("         java Func4Parser inputfile");
	    	return;
	    }

	    Programa programa = null;

	    try {

	    	programa = parser.Input();
	    	System.out.println("Funcional 4 PLP Parser Version 0.0.1: Funcional4 program parsed successfully.");
	    } catch (Exception e) {
	    	e.printStackTrace();
	    	System.out.println("Funcional 4 PLP Parser Version 0.0.1: Encountered errors during parse.");
	    	System.exit(0);
	    }

	    try {

	    	System.out.println("Funcional 4 PLP Parser Version 0.0.1: running...");
			
			if (!programa.checaTipo()) {
            	System.out.println("Erro de tipo.");
            }
            else{
              	System.out.println("Tipo correto.");
            	Valor val = (Valor)programa.executar();

	    	if (val instanceof ValorString) {
	    		ValorString valStr = (ValorString) val;
		    	System.out.println("Funcional 4 PLP Parser Version 0.0.1: resultado="+valStr.valor());
	    	} else if (val instanceof ValorInteiro) {
	    	    ValorInteiro valInt = (ValorInteiro) val;
		    	System.out.println("Funcional 4 PLP Parser Version 0.0.1: resultado="+valInt.valor());
		    } else if (val instanceof ValorBooleano) {
		        ValorBooleano valBool = (ValorBooleano) val;
		    	System.out.println("Funcional 4 PLP Parser Version 0.0.1: resultado="+valBool.valor());
		    } else if (val instanceof ValorFuncao) {
		        ValorFuncao valFunc = (ValorFuncao) val;
		    	System.out.println("Funcional 4 PLP Parser Version 0.0.1: resultado = " + val);
		    } else if (val instanceof ValorPid)
		    {
		      	ValorPid valPid = (ValorPid) val;
		      	System.out.println("Funcional 4 PLP Parser Version 0.0.1: resultado = " + valPid.valor());
		    } else if(val instanceof ValorTupla)
		    {
			   ValorTupla valTupla = (ValorTupla) val;
		       System.out.println("Funcional 4 PLP Parser Version 0.0.1: resultado = " + valTupla.toString());
		    }
            }
	   	} catch (Exception e) {
	    	e.printStackTrace();
	    	System.out.println("Funcional 4 PLP Parser Version 0.0.1:  Encountered errors during execution.");
	    }

	}

}



PARSER_END(Func4Parser)


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 : /* TOKENS DE FUNCIONAL 4 */
{
  < SELF        : "self">
| < SPAWN       : "spawn">
| < RECEIVE     : "receive">
| < END: "end">
}


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: "." >
| < ARROW: "->">
}


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;
	ExpressaoComplexa expressao;
}
{
	<FN> lista = PListaId() <DOT> expressao = PCompExp()//expressao = PExpressao()
	{
		return new ValorFuncao(lista, expressao);
		//return null;
	}
}

Valor PValorTupla():
{
  List<Valor> elems = new ArrayList<Valor>();
  Valor elem;
}
{
  <LBRACE> elem = PValor() {elems.add(elem);}
  (<COMMA> elem = PValor() {elems.add(elem);})* <RBRACE>
  {
    return new ValorTupla(elems);
  }
}


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

Expressao PSelf() :
{
}
{
  <SELF><LPAREN><RPAREN>
  {
    return new ExpSelf();
  }
}

ExpProcesso PSpawn() :
{
  Expressao func = null;
  List<Expressao > args = null;
}
{
  <SPAWN> <LPAREN> (func = PId() | func = PValorFuncao()) <COMMA> <LBRACKET> args = PListaExpr() <RBRACKET> <RPAREN>
  {
    return new ExpSpawn(func,args);
  }
}

ExpProcesso PSend() :
{
  List<Id > ids = new ArrayList<Id>();
  Id id;
  Expressao msg = null;
}
{
  (LOOKAHEAD(PId() <BANG>) id = PId() { ids.add(0, id);} <BANG>)+ msg = PExpressao()
  {
    return new ExpSend(ids, msg);
  }
}

ExpProcesso PReceive() :
{
  List<Clausula > clausulas = new ArrayList<Clausula >();
  Clausula aux = null;
}
{
  <RECEIVE> aux = PClause()
  {
    clausulas.add(aux);
  }(< SEMICOLON > aux = PClause()
  {
    clausulas.add(aux);
  })* <END>
  {
    return new ExpReceive(clausulas);
  }
}

ExpProcesso PExpProc() :
{
  ExpProcesso retorno = null;
}
{
  (   
  LOOKAHEAD((PSpawn() | PSend() | PReceive()) < COMMA> PExpProc())
  {ExpProcesso firstProc, secondProc;}
  (firstProc = PSpawn() | firstProc = PSend() | firstProc = PReceive()) <COMMA> secondProc = PExpProc()
  {retorno = new SeqExpProc(firstProc, secondProc);}
  | retorno = PSpawn()
  | retorno = PSend()
  | retorno = PReceive())
  {
    return retorno;
  }
}

ExpressaoComplexa PCompExp() :
{
 	ExpProcesso before = null;
	ExpProcesso after = null;
	Expressao exp = null;
}
{
   (
   LOOKAHEAD(PExpProc() <COMMA> PExpressao())
   before = PExpProc() <COMMA> exp = PExpressao() (LOOKAHEAD(<COMMA> PExpProc()) <COMMA> after = PExpProc())?
   | LOOKAHEAD(PExpProc())
   before = PExpProc()
   | LOOKAHEAD(PExpressao())
     exp = PExpressao() (LOOKAHEAD(<COMMA> PExpProc())<COMMA> after = PExpProc())?
   )
   {
     return new ExpressaoComposta(before, after, exp);
   }
}

Clausula PClause() :
{
  	PadraoAbstrato pattern;
	ExpressaoComplexa exp;
}
{
  pattern = PPattern() <ARROW> exp = PCompExp()
  {
    return new Clausula(pattern, exp);
  }
}

PadraoAbstrato PPattern() :
{
  Expressao exp, elem;
  PadraoAbstrato padrao;
  PadraoAbstrato retorno;
}
{
  (  
    exp = PId() {retorno = new Padrao(exp);}
 	| LOOKAHEAD(PValor()) exp = PValor() {retorno = new Padrao(exp);}
 	| <LBRACE> padrao = PPattern() { 
  		List<PadraoAbstrato> padroes = new ArrayList<PadraoAbstrato>();
		padroes.add(padrao);
 		}
 	(LOOKAHEAD(<COMMA> PPattern())
 	<COMMA> padrao = PPattern() {padroes.add(padrao);}
 	)* <RBRACE>
	{retorno = new PadraoTupla(padroes);}
 ) 
 {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>
	| retorno = PSelf()
	)
	{
		return retorno;
	}
}

Expressao PExpTupla():
{
  List<Expressao > list = null;
}
{
  <LBRACE>
  {
    Expressao elem;
    list = new ArrayList<Expressao>();
  }
  elem = PExpressao() {list.add(elem);}
  (<COMMA> elem = PExpressao() {list.add(elem);})* <RBRACE>
  {
    return new ExpTupla(list);
  }
  
}

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;
	ExpressaoComplexa expressao;
}
{
	(
	  <VAR> id = PId() <ASSIGN> expressao = PCompExp()//expressao = PExpressao()
	)
	{
		//return null;//
		return new DecVariavel(id, expressao);
	}
}

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

List PDeclFuncional() :
{
	List retorno=null;
	DeclaracaoFuncional decl;
}
{
	(
	  decl = PDeclVar()
	| decl = PDeclFuncao()
	)
	  {
         retorno = new ArrayList();
         retorno.add(decl);
	  }
	(
	(
	  LOOKAHEAD(<COMMA> <VAR>)
	  <COMMA> decl = PDeclVar()
	|
	  LOOKAHEAD(<COMMA> <FUNC>)
	  <COMMA> decl = PDeclFuncao()
	)
	  {
	     retorno.add(decl);
	  }
	)*
	{
	    return retorno;
	}
}

Expressao PExpDeclaracao() :
{
	List declaracoes;
	ExpressaoComplexa expressao;
}
{
	<LET> declaracoes = PDeclFuncional() <IN> expressao = PCompExp() //expressao = PExpressao()
	{
		return new ExpDeclaracao(declaracoes, expressao);
		//return null;
	}
}

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

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

Expressao PExpUnaria() :
{
	Expressao retorno;
}
{
	(
	  LOOKAHEAD (PExpMenos())
	  retorno = PExpMenos()
	|
	  LOOKAHEAD (PExpNot())
	  retorno = PExpNot()
	|
	  LOOKAHEAD (PExpLength())
	  retorno = PExpLength()  
	|
	  LOOKAHEAD (PExpDeclaracao())
	  retorno = PExpDeclaracao()
	|
	  LOOKAHEAD (PExpCondicional())
	  retorno = PExpCondicional()
	|
	  LOOKAHEAD (PExpPrimaria())
	  retorno = PExpPrimaria()
    | LOOKAHEAD(PExpTupla())
      retorno = PExpTupla() 
	)
	{
		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);
	  }
	|
	  <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);
	}
}