sintactico.h

Compiler with latex grammar

#ifndef SINTACTICO_H
#define SINTACTICO_H

#include "Lexico.h"

#define S 101
#define E 102
#define T 103
#define F 104
#define G 105
#define I 106
#define O 107
#define A 108
#define AC 109

#define SIMBDOL 110
//Lo q viene a continuacion debe estar en el lexico
#define EX      111
#define TXT_IMP 112
#define DOL     113
#define RESERV  114
#define SQRT    115
#define FRAC    116
#define STACKREL 117
#define OPEN_KEY  118 
#define CLOSE_KEY  119
#define OPEN_BAR   120
#define CLOSE_BAR   121

class Sintactico{

	private:

		stack<int> Pila;
		stack<int> Entrada;
		
		int Accion;

		Automata* lexico;

		int ** matriz;
		
		Token* tmp;
		
		Tabla_Simbolos *EntradaT;
	
	protected:

		int PosX(int);
	public:

		Sintactico(/*Automata **/);
		~Sintactico();
		//bool Analisis(string::iterator);
		bool Analisis();
	//	bool Gramatica(int);
		//void ManejaErrores();

};

Sintactico::Sintactico(/*Automata* lexico*/)
{
	/*
	EntradaT = lexico->getTabla_Simbolos();
	EntradaT->Empilar(Entrada);*/
	int tabla[][20]={
	/*desplazamiento positivo reduccion negativos
	/*Esta x txt_imp dol reserv sqrt frac stack  {    }   [   ]   $   S   E  T  G  F  I   A  O*/
	/*0*/  0,  0,    2,   0,     0,   0,   0,    0,   0,  0,  0,  0,  1,  0, 0, 0, 0, 0,  0, 0,
	/*1*/  0,  0,    0,   0,     0,   0,   0,    0,   0,  0,  0,  AC, 0,  0, 0, 0, 0, 0,  0, 0,	
 	/*2*/  0,  5,   -4,   6,    10,  11,  12,   13,  -4,  0,  0,  0,  0,  3, 4, 8, 7, 9,  0, 0,
	/*3*/  0,  0,   14,   0,     0,   0,   0,    0,   0,  0,  0,  0,  0,  0, 0, 0, 0, 0,  0, 0,
	/*4*/ 17,  5,   -4,   6,    10,  11,  12,   13,  -4,  0,  0,  0,  0, 15, 4, 8, 7, 9, 16, 0,	
	/*5*/ -5, -5,   -5,  -5,    -5,  -5,  -5,   -5,  -5,  0, -5,  0,  0,  0, 0, 0, 0, 0,  0, 0,
	/*6*/ -6, -6,   -6,  -6,    -6,  -6,  -6,   -6,  -6,  0, -6,  0,  0,  0, 0, 0, 0, 0,  0, 0,
	/*7*/ -7, -7,   -7,  -7,    -7,  -7,  -7,   -7,  -7,  0, -7,  0,  0,  0, 0, 0, 0, 0,  0, 0,
	/*8*/ -8, -8,   -8,  -8,    -8,  -8,  -8,   -8,  -8,  0, -8,  0,  0,  0, 0, 0, 0, 0,  0, 0,
	/*9*/ -9, -9,   -9,  -9,    -9,  -9,  -9,   -9,  -9,  0, -9,  0,  0,  0, 0, 0, 0, 0,  0, 0,
	/*10*/ 0,  0,    0,   0,     0,   0,   0,  -17,   0, 19,  0,  0,  0,  0, 0, 0, 0, 0,  0,18,
	/*11*/ 0,  0,    0,   0,     0,   0,   0,   13,   0,  0,  0,  0,  0,  0, 0,20, 0, 0,  0, 0,
	/*12*/ 0,  0,    0,   0,     0,   0,   0,   13,   0,  0,  0,  0,  0,  0, 0,21, 0, 0,  0, 0,
	/*13*/ 0,  5,   -4,   6,    10,  11,  12,   13,  -4,  0,  0,  0,  0, 22, 4, 8, 7, 9,  0, 0,
	/*14*/ 0,  0,    0,   0,     0,   0,   0,    0,   0,  0,  0,  -2, 0,  0, 0, 0, 0, 0,  0, 0,
	/*15*/ 0,  0,   -3,   0,     0,   0,   0,    0,  -3,  0,  0,  0,  0,  0, 0, 0, 0, 0,  0, 0,
	/*16*/-14,-14,  -14, -14,   -14, -14, -14,  -14, -14,  0,-14,  0,  0,  0, 0, 0, 0, 0,  0, 0,
	/*17*/ 0,  5,    0,   6,    10,  11,  12,   13,   0,  0,  0,  0,  0,  0,23, 8, 7, 9,  0, 0,	
	/*18*/ 0,  0,    0,   0,     0,   0,   0,   13,   0,  0,  0,  0,  0,  0, 0,24, 0, 0,  0, 0,
	/*19*/ 0,  5,    0,   6,    10,  11,  12,   13,   0,  0,  0,  0,  0,  0,23, 8, 7, 9,  0, 0,
	/*20*/ 0,  0,    0,   0,     0,   0,   0,   13,   0,  0,  0,  0,  0,  0, 0,26, 0, 0,  0, 0,
	/*21*/ 0,  0,    0,   0,     0,   0,   0,   13,   0,  0,  0,  0,  0,  0, 0,27, 0, 0,  0, 0,
	/*22*/ 0,  0,    0,   0,     0,   0,   0,    0,  28,  0,  0,  0,  0,  0, 0, 0, 0, 0,  0, 0,
	/*23*/-15,-15,  -15, -15,   -15, -15, -15,  -15, -15,  0,-15,  0,  0,  0, 0, 0, 0, 0, 16, 0,
	/*24*/-11,-11,  -11, -11,   -11, -11, -11,  -11, -11,  0,-11,  0,  0,  0, 0, 0, 0, 0,  0, 0,
	/*25*/ 17,  0,    0,   0,     0,   0,   0,    0,   0,  0, 29,  0,  0,  0, 0, 0, 0, 0, 16, 0,
	/*26*/-12,-12,  -12, -12,   -12, -12, -12,  -12, -12,  0,-12,  0,  0,  0, 0, 0, 0, 0,  0, 0,
	/*27*/-13,-13,  -13, -13,   -13, -13, -13,  -13, -13,  0,-13,  0,  0,  0, 0, 0, 0, 0,  0, 0,
	/*28*/-10,-10,  -10, -10,   -10, -10, -10,  -10, -10,  0,-10,  0,  0,  0, 0, 0, 0, 0,  0, 0,
	/*29*/ 0,  0,    0,   0,     0,   0,   0,  -16,   0,  0,  0,  0,  0,  0, 0, 0, 0, 0,  0, 0,
	};
	
	//int ir_A[][7]={};

	matriz = new int*[30];  
	for(int i=0;i<30;i++){
		matriz[i] = new int[20];
		for(int j=0;j<20;j++)
			matriz[i][j] = tabla[i][j];}
//	cout<<matriz[23][3];
}
	
Sintactico::~Sintactico(){
	
	for(int i=0;i<29;i++)
		delete(matriz[i]);

}

int Sintactico::PosX(int n){

	switch(n){

		case EX:		return 0;
		case TXT_IMP:	return 1;
		case DOL:		return 2;
		case RESERV:	return 3;
		case SQRT:		return 4;
		case FRAC:		return 5;
		case STACKREL:	return 6;
		case OPEN_KEY:	return 7;
		case CLOSE_KEY:	return 8;
		case OPEN_BAR:	return 9;
		case CLOSE_BAR:	return 10;
		case SIMBDOL:	return 11;
		case S:			return 12;
		case E:			return 13;
		case T:			return 14;
		case G:			return 15;
		case F:			return 16;
		case I:			return 17;
		case A:			return 18;
		case O:			return 19;
	}

return 25;
}
/*bool Sintactico::Gramatica(int produccion){
	switch(produccion)
	{
			
	}

}
*/

bool Sintactico::Analisis()
{	
	Pila.push(0);
	
	
	//Pasar De la tabla de simbolos a la Pila Entrada para trabajar con esta
	//Tienes q hacer algo +/- asi
	//while(tabla_simbolos!= Fin)
	//		Entrada.push(Tabla->token->tipo)

	//En el lexico obviamente tienes q hacer un automata para reconoder TXT_IMP texto implicito
	//cosa  en el Lexico  en la Tabla de Simbolos pones Token->Agregar("134-8.73",TXT_IMP,linea de mierda)	
	//Falta implementar eso, a continuacion es lo q debe tener la Pila de Entrada MARICA
	//Estas dos pilas de entradas las hice para probar

/*
	$\prod_{a}^\infty{134-c}$
	Que sintacticamente viene a ser lo mismo que
	$\prod_{128}^\infinity{134-8.73}$
	Que son tus dos entradas cojudas q hiciste en tu MAIN
*/
	Entrada.push(SIMBDOL);
	Entrada.push(DOL);
	Entrada.push(CLOSE_KEY);
	Entrada.push(TXT_IMP);
	Entrada.push(OPEN_KEY);
	Entrada.push(RESERV);
	Entrada.push(TXT_IMP);
	Entrada.push(CLOSE_KEY);
	Entrada.push(TXT_IMP);
	Entrada.push(OPEN_KEY);
	Entrada.push(RESERV);
	Entrada.push(DOL);
/*	
	//esta corresponde a 
	//$\frac {a}{b}$
	Entrada.push(SIMBDOL);
	Entrada.push(DOL);
	Entrada.push(CLOSE_KEY);
	Entrada.push(TXT_IMP);
	Entrada.push(OPEN_KEY);
	Entrada.push(CLOSE_KEY);
	Entrada.push(TXT_IMP);
	Entrada.push(OPEN_KEY);
	Entrada.push(FRAC);
	Entrada.push(DOL);
*/	
	Accion=matriz[Pila.top()][PosX(Entrada.top())];
	cout<<Accion<<"\n";
	//Quiza pueda ir un control de error

	while((Accion!=AC||Pila.empty())&&Accion!=0){
	
		//Accion=matriz[Pila.top()][PosX(Entrada.top())];

		if(Accion>=0){		

			Pila.push(Entrada.top());
			Pila.push(Accion);
			Entrada.pop();
			Accion=matriz[Pila.top()][PosX(Entrada.top())];
			cout<<Accion<<"\n";
		}

		if(Accion<0)//De una Vez con la gramatica nomas
		{	
			Accion=abs(Accion);
			int tmp;
			switch(Accion){
			
			case 1://S'->S
					break;
			case 2://S->dol E dol
				
				Pila.pop();
				if(Pila.top()==DOL)
				{	Pila.pop();Pila.pop();
					if(Pila.top()==E)
					{	Pila.pop();Pila.pop();
						if(Pila.top()==DOL)
						{	Pila.pop();
							tmp=Pila.top();
							Pila.push(S);
							Pila.push(matriz[tmp][PosX(S)]);
							break;
						}//Control de Errores
						else break;
					}
				}
			break;


		case 3:	//E	->T E
			Pila.pop();
			if(Pila.top()==E)
			{	Pila.pop();Pila.pop();
				if(Pila.top()==T)
				{
					Pila.pop();
					tmp=Pila.top();
					Pila.push(E);
					Pila.push(matriz[tmp][PosX(E)]);
					break;
				}
				else break;
			}
			break;

		case 4:	//E->EPS (Vacio)
			tmp=Pila.top();
			Pila.push(E);
			Pila.push(matriz[tmp][PosX(E)]);

			break;
			
		case 5:	//T->txt_imp
			Pila.pop();
			if(Pila.top()==TXT_IMP)
			{	Pila.pop();
			//	cout<<"entra";
				tmp=Pila.top();
				Pila.push(T);
				Pila.push(matriz[tmp][PosX(T)]);
					//Accion=matriz[Pila.top()][PosX(Entrada.top())];
						break;

			}
			break;
		case 6:	//T->reserv		

			Pila.pop();
			if(Pila.top()==RESERV)
			{	Pila.pop();
				tmp=Pila.top();
				Pila.push(T);
				Pila.push(matriz[tmp][PosX(T)]);
					//Accion=matriz[Pila.top()][PosX(Entrada.top())];
						break;
			}
		case 7:	//T->F
			Pila.pop();
			if(Pila.top()==F)
			{	Pila.pop();
				tmp=Pila.top();
				Pila.push(T);
				Pila.push(matriz[tmp][PosX(T)]);
					//Accion=matriz[Pila.top()][PosX(Entrada.top())];
						break;
			}
			break;
		case 8:	//T->G	

			Pila.pop();
			if(Pila.top()==G)
			{	Pila.pop();
				tmp=Pila.top();
				Pila.push(T);
				Pila.push(matriz[tmp][PosX(T)]);
					//Accion=matriz[Pila.top()][PosX(Entrada.top())];
						break;
			}
			break;
		case 9:	//T->I
			Pila.pop();
			if(Pila.top()==I)
			{	Pila.pop();
				tmp=Pila.top();
				Pila.push(T);
				Pila.push(matriz[tmp][PosX(T)]);
					//Accion=matriz[Pila.top()][PosX(Entrada.top())];
						break;
			}
			break;
		case 10: //G-{E}
			Pila.pop();
			if(Pila.top()==CLOSE_KEY)
			{	Pila.pop();Pila.pop();
				if(Pila.top()==E)
				{	Pila.pop();Pila.pop();
					if(Pila.top()==OPEN_KEY)
					{	Pila.pop();
						tmp=Pila.top();
						Pila.push(G);
						Pila.push(matriz[tmp][PosX(G)]);
						//Accion=matriz[Pila.top()][PosX(Entrada.top())];
						break;
					}
					else
						//Control de Errores
						break;
				}
			}

			break;
		case 11://F->sqrt O G
			Pila.pop();
			if(Pila.top()==G)
			{	Pila.pop();Pila.pop();
				if(Pila.top()==O)
				{	Pila.pop();Pila.pop();
					if(Pila.top()==SQRT)
					{	Pila.pop();
						tmp=Pila.top();
						Pila.push(F);
						Pila.push(matriz[tmp][PosX(F)]);
						//Accion=matriz[Pila.top()][PosX(Entrada.top())];
						break;
					}
					else
						//Control de Errores
						break;
				}
			}

			break;
		case 12://F->frac G G
			Pila.pop();
			if(Pila.top()==G)
			{	Pila.pop();Pila.pop();
				
				if(Pila.top()==G)
				{	Pila.pop();Pila.pop();
					if(Pila.top()==FRAC)
					{	Pila.pop();
						tmp=Pila.top();
						Pila.push(F);
						Pila.push(matriz[tmp][PosX(F)]);
						//Accion=matriz[Pila.top()][PosX(Entrada.top())];
						break;
					}
					else break;
						//Control de Errores
						
				}
			}
			break;

		case 13://F->stackrel G G

			Pila.pop();
			if(Pila.top()==G)
			{	Pila.pop();Pila.pop();
				if(Pila.top()==G)
				{	Pila.pop();Pila.pop();
					if(Pila.top()==STACKREL)
					{	Pila.pop();
						tmp=Pila.top();
						Pila.push(F);
						Pila.push(matriz[tmp][PosX(F)]);
						//Accion=matriz[Pila.top()][PosX(Entrada.top())];
						break;
					}
					else
						//Control de Errores
						break;
				}
			}

			break;
		case 14://I->T A
			Pila.pop();
			if(Pila.top()==A)
			{	Pila.pop();Pila.pop();
				if(Pila.top()==T)
				{
					Pila.pop();
					tmp=Pila.top();
					Pila.push(I);
					Pila.push(matriz[tmp][PosX(I)]);
					//Accion=matriz[Pila.top()][PosX(Entrada.top())];
						break;
				}
				else break;
			}
			break;

		case 15://A->x T

			Pila.pop();
			if(Pila.top()==T)
			{	Pila.pop();Pila.pop();
				if(Pila.top()==EX)
				{
					Pila.pop();
					tmp=Pila.top();
					Pila.push(A);
					Pila.push(matriz[tmp][PosX(A)]);
					//Accion=matriz[Pila.top()][PosX(Entrada.top())];
						break;
				}
				else break;
			}
			break;
		case 16://O->[ T ]
			
			Pila.pop();
			if(Pila.top()==CLOSE_KEY)
			{	Pila.pop();
				if(Pila.top()==E)
				{	Pila.pop();
					if(Pila.top()==OPEN_KEY)
					{	Pila.pop();
						tmp=Pila.top();
						Pila.push(S);
						Pila.push(matriz[tmp][G]);
						//Accion=matriz[Pila.top()][PosX(Entrada.top())];
						break;
					}
					else
						//Control de Errores
						break;
				}
			}

			break;

		case 17://O->EPS
			break;

			}//swtich
		Accion=matriz[Pila.top()][PosX(Entrada.top())];
		cout<<Accion<<"\n";
		}//if	
	}//WHILE
	if(Accion==AC){
		cout<<"Expresion bien escrita";
			return true;}
	else
		cout<<"Expresion mal escrita";
		return false;
}


#endif