/* Secao das declaracoes */
%option noyywrap
/* Sera copiado no .c final */

	#include <stdlib.h>
	#include <string.h>
/* este include eh importante... */
	#include "tokens.h"
	#include "stack.h"


  /* Definicoes regulares */
LETRA ([a-z]|[A-Z])
DIGITO ([0-9])


%%

 /* Secao das Regras de traducao */
 /* O que consta aqui eh puramente ilustrativo...
  * Ver tambem "tokens.h" para a definicao de DIG e OPCMP
  */
(INT|integer) {return (INT);}
DOUBLE {return (DOUBLE);}
FLOAT {return (FLOAT);}
CHAR {return (CHAR);}

"*" {return (SIMBOLO_ASTERISCO);}
"+" {return (SIMBOLO_MAIS);}
"-" {return (SIMBOLO_MENOS);}
"/" {return (SIMBOLO_BARRA);}
"," {return (VIRGULA);}
";" {return (PONTOEVIRGULA);}
"'" {return (QUOTE);}
"\"" {return (DQUOTE);}
"(" {return (ABRE_PARENTESES);}
")" {return (FECHA_PARENTESES);}
"[" {return (ABRE_COLCHETE);}
"]" {return (FECHA_COLCHETE);}
"{" {return (ABRE_CHAVES);}
"}" {return (FECHA_CHAVES);}
"<" {return (SINAL_MENOR);}
">" {return (SINAL_MAIOR);}
"=" {return (SINAL_ATRIBUICAO);}
"<=" {return (LE);}
">=" {return (GE);}
"==" {return (EQ);}
"!" {return (EXCLAMACAO);}
"!=" {return (NE);}
"&&" {return (AND);}
"||" {return (OR);}
"%" {return (MOD);}
"&" {return (ECOMERCIAL);}
" " {return (BRANCO);}
"\n" {return (QUEBRALINHA);}
IF {return (IF);}
THEN {return (THEN);}
ELSE {return (ELSE);}
WHILE {return (WHILE);}
{DIGITO}*[\.]{DIGITO}+([eE][+-]{DIGITO}+)? {return (F_LIT);}
{DIGITO}+ {return (INT_LIT);}
({LETRA})+({LETRA}|{DIGITO}|[_])* { return (IDF);}

[ \t\n]* { printf("BRANCO\n");}
. { printf("Erro lexical - caractere nao reconhecido: %c.\n", yytext[0]);
exit(-1);}


%%
 /* Secao dos Procedimentos auxiliares */
/* Para redefinir a entrada padrao do LEX. */
extern FILE *yyin;
int main(int argc, char* argv[])
{
	/*
	Criamos constantes para podermos usar ponteiros para os valores
	*/
		const int E = -1;
		const int X = -2;
		const int START = E;
		const int TABRE_PARENTESES = ABRE_PARENTESES;
		const int TFECHA_PARENTESES = FECHA_PARENTESES;
		const int TSIMBOLO_ASTERISCO = SIMBOLO_ASTERISCO;
		const int TSIMBOLO_MAIS = SIMBOLO_MAIS;
		const int TSIMBOLO_MENOS = SIMBOLO_MENOS;
		const int TSIMBOLO_BARRA = SIMBOLO_BARRA;
		const int TF_LIT = F_LIT;
		const int TIDF = IDF;
		const int TINT_LIT = INT_LIT;
		const int TVAZIO = BRANCO;
		int* simbolo = NULL;
		/*
		A tabela de parse LL1 foi codificada como um array bidimensional
		*/
		int tabela[2][9] = {{0, 0, 0, 0, 0, 2, 1, 3, 0},{8, 4, 5, 6, 7, 0, 0, 0, 8}};
		stack pilha;
		int token, producao;
		if (argc != 2) {
     		printf("uso: %s <input_file>. Tente Novamente!\n", argv[0]);
     		exit(-1);
   		}
		yyin = fopen(argv[1], "r");
		if (!yyin)
		{
			printf("Uso: %s <input_file>. Could not find %s. Try again!\n",
			argv[0], argv[1]);
			exit(-1);
		}

		while (token=yylex()) {
			printf("Meu analisador lexical reconheceu o token %d\n", token);
		}
		//printf("Iniciando dados.\n");
		init_stack(&pilha);
		//printf("Push.\n");
		push(&pilha, (void *) &START);
		//printf("Le o primeiro token.\n");
		token = yylex();
		//printf("Token %d\n",token);
		if(token)
		{
			printf("Passei aqui 1 if");
			while(!empty(pilha))
			{
				printf("Passei aqui while da pilha vazia");
				simbolo = (int *) pop(&pilha);
				//printf("Desempilhando: %i\n", *simbolo);
				/* Caso seja um simbolo nao terminal */
				if(*simbolo == E || *simbolo == X)
				{
					printf("Passei aqui 2 if");
					/*
					Mapeamos o valor do simbolo e do token para enderecos no array
					e buscamos a producao que tambem eh codificada com um inteiro
					*/
					producao = tabela[(abs(*simbolo) - 1)][(token - 1)];
					//printf("tabela[%i][%i] = %i\n", (abs(*simbolo) - 1), (token - 1), producao);
					if(producao)
					{
						printf("Passei aqui 3 if");
						//printf("Empilha producao %i\n", producao);
						/* empilha cada elemento da producao */
						switch(producao)
						{
							case 1:
							//) E -> ’IDF’ X
							push(&pilha, (void *) &X);
							push(&pilha, (void *) &TIDF);
							break;
							case 2:
							//) E -> 'INT_LIT' X
							push(&pilha, (void *) &X);
							push(&pilha, (void *) &TINT_LIT);
							break;
							case 3:
							//) E -> ’(’ E ’)’ X
							push(&pilha, (void *) &X);
							push(&pilha, (void *) &TFECHA_PARENTESES);
							push(&pilha, (void *) &E);
							push(&pilha, (void *) &TABRE_PARENTESES);
							break;
							case 4:
							//) E -> ’+’ E X
							push(&pilha, (void *) &X);
							push(&pilha, (void *) &E);
							push(&pilha, (void *) &TSIMBOLO_MAIS);
							break;
							case 5:
							//) X -> ’-’ E X
							push(&pilha, (void *) &X);
							push(&pilha, (void *) &E);
							push(&pilha, (void *) &TSIMBOLO_MENOS);
							break;
							case 6:
							//) X -> ’*’ E X
							push(&pilha, (void *) &X);
							push(&pilha, (void *) &E);
							push(&pilha, (void *) &TSIMBOLO_ASTERISCO);
							break;
							case 7:
							//) X -> ’/’ E X
							push(&pilha, (void *) &X);
							push(&pilha, (void *) &E);
							push(&pilha, (void *) &TSIMBOLO_BARRA);
							break;
							case 8:
							//) X -> &
							push(&pilha, (void *) &TVAZIO);
							break;
						}
					}
					else
					{
						printf("ERROR 1");
						exit(-1);
					}
				}
				else
				{
				/* Quando o simbolo da pilha foi lido da entrada avancamos a leitura */
				if(*simbolo == token)
				{
					printf("Passei aqui 4 if");
					token = yylex();
					if(!token)
					{
					/* Sinaliza o fim do arquivo quando o yylex nao encontrar nada */
					token = CIF;
					}
				}
				else
				{
					printf("ERROR 2");
					exit(-1);
				}
				}
			}
		}
		else
		{
			printf("ERROR 3\n");
			exit(-1);
		}
		if(!yylex())
		{
			printf("OKAY\n");
		}

	return(0);
}