Analizador Lexico, Sintactico y Semantico

<<<<<<  Programa de Analizador Lexico, Sintactico y Semántico >>>>>>>>


#include
#include
#include
#include
#include

int funcion_pal_reserv(char cadena[30]);
int funcion_digi(char cadena[30]);
int funcion_identificador(char cadena[30]);
int funcion_cadena(char cadena[30]);
int funcion_simbolos(char cadena[30]);
int funcion_logicos(char cadena[30]);
int funcion_matematicos(char cadena[30]);
char pal_reserv[6][10]=
{
{'i','f'},
{'w','h','i','l','e'},
{'p','r','i','n','t'},
{'<','s','t','d','i','n','>'},
{'f','o','r'},
{'e','l','s','e'}
};

char digi[10]={'1','2','3','4','5','6','7','8','9','0'};

char Operadores_logicos[5][3]=
{

{'<'},
{'>'},
{'=','>'},
{'<','='},
{'=','='},



};

char abc[27]={'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','_'};




char vara[50][20];
int we=0;
int load[50];
int fu=0;

int s_linea=0,fun=0;
int num[20][20];
int es[20];
char leer;
char cadena[100][30];
int p=0;
void main()
{
int x=0;
cout<<" Analizador Lexico"<
cout<<"Token               Numero"<<

ifstream codigo("perl.txt");
fun=0;
    while(!codigo.eof())
    {
        codigo.get(leer);

if(leer=='\n'||leer==' ')
{


int token=funcion_pal_reserv(cadena[p]);
if(token==0)
token=funcion_digi( cadena[p]);
if(token==0)
token=funcion_identificador(cadena[p]);
if(token==0)
token=funcion_cadena(cadena[p]);
if(token==0)
token=funcion_simbolos(cadena[p]);
if(token==0)
token=funcion_logicos(cadena[p]);
if(token==0)
token=funcion_matematicos(cadena[p]);

cout<<"         "<<

cout<

if(leer=='\n')
{

es[s_linea]=fun+1;
num[s_linea][fun]=token;

fun=0;


s_linea++;

p++;
x=0;

}

if(leer==' ')
{ num[s_linea][fun]=token;
fun++;
p++;
x=0;


}
num[s_linea][fun]=token;



        

}
else
{
cout<
cadena[p][x]=leer;
x++;
}

}
cout<<"Analizador Sintactico"<
int eva=0;
int anterior=0;
int conteo1=0;
int conteo2=0;
cout<
for(int d=0; d
{
eva=0;
cout<<"Linea "<<<" ";
if(es[d]==3)
{
if(num[d][0]==3)
if(num[d][1]==8||num[d][1]==9)
if(num[d][0]==3)

{
cout<<"Esta linea es una sentencia print "<
eva++;
}




}
if(es[d]==6)
{
if(num[d][0]==8)
if(num[d][1]==11)
if(num[d][2]==7||num[d][2]==8)
if(num[d][3]==13)
if(num[d][4]==7||num[d][4]==8)
if(num[d][5]==10)
{
cout<<"Esta linea es una operacion matematica"<
eva++;
}
}
if(es[d]==4)
{
if(num[d][0]==8)
if(num[d][1]==11)
if(num[d][2]==7)
if(num[d][3]==10)
{
cout<<"Esta linea es una asigancion de valor a variable tipo entero"<
load[fu]=1;
fu++;
eva++;
}
if(num[d][0]==8)
if(num[d][1]==11)
if(num[d][2]==9)
if(num[d][3]==10)
{
cout<<"Esta linea es una asigancion de valor a variable tipo string"<
load[fu]=2;
fu++;
eva++;
              

}
            if(num[d][0]==8)
if(num[d][1]==11)  /// tipo entero
if(num[d][2]==8)
if(num[d][3]==10)
{
cout<<"Esta variable se esta convirtiendo al tipo de dato de la variable asignada [entero] "<
eva++;

}

if(num[d][0]==8)
if(num[d][1]==11)
if(num[d][2]==7||num[d][2]==8)
if(num[d][3]==13)
if(num[d][4]==8||num[d][2]==0)
if(num[d][5]==10)
{
cout<<"Error de asignacion, verifique la asignacion  "<
eva++;
}
}



if(es[d]==6)
{
if(num[d][0]==1)
if(num[d][1]==14)
if(num[d][2]==8||num[d][2]==7)
if(num[d][3]==12)
if(num[d][4]==8||num[d][4]==7)
if(num[d][5]==15)
{
cout<<"Esta linea es un if"<
eva++;
anterior=d;
}

if(num[d][0]==2)
if(num[d][1]==14)
if(num[d][2]==8||num[d][2]==7)
if(num[d][3]==12)
if(num[d][4]==8||num[d][4]==7)
if(num[d][5]==15)
{
cout<<"Esta linea es un while"<
eva++;
anterior=d;
}

}
// cout<

if(num[d][0]==5)
if(num[d][1]==14)
if(num[d][2]==8)
if(num[d][3]==11)
if(num[d][4]==7)
if(num[d][5]==10)
if(num[d][6]==8)
if(num[d][7]==12)
if(num[d][8]==7)
            if(num[d][9]==10)
if(num[d][10]==8)
           if(num[d][11]==18)
if(num[d][12]==15)
{
cout<<"esta linea es un for"<
eva++;
anterior=d;
}

if(es[d]==1)
{
if(num[d][0]==16)
{
cout<<"esta linea es una llave de inicio de proceso"<
eva++;
conteo1++;
if(anterior==d-1)
{
}
else
{
cout<<"error en esta llave de apertura (la llaves de apertura ban despues de un inicio de if,while o for)"<
}
}
if(num[d][0]==17)
{
cout<<"esta linea es una llave de fin "<
eva++;
conteo2++;
if(conteo2>conteo1)
{
cout<<"error en la llaves de cerradura "<
}
}



}

if(eva==0)
{
cout<<"Esta linea no es aceptada, verifique su sintaxis"<
}
cout<


}
if(conteo2==conteo1)
{
}
else
{
if(conteo1>conteo2)
{
cout<<"faltan llaves de cerradura"<
}
if(conteo2>conteo1)
{
          cout<<"se encontraron llaves de cerraduras ilegales"<
}
}

/*for(int da=0;da
{
if(load[da]==1||load[da]==2)
{
cout<<"La variable ";
int fg=strlen(vara[da]);
for(int f=0;f
{
cout<
}
cout<<" es de  tipo ";
cout<
cout<
}

}*/



}

int funcion_pal_reserv(char cadena[30])
{


   int e=0;
   int w=strlen(cadena);

for(int m=0; m<6;m++)
{
int d=strlen(pal_reserv[m]);

if(d==w)
{


e=0;
for(int q=0; q
{
if(pal_reserv[m][q]==cadena[q])
{
e++;
}

}
if(w==e)
{
return m+1;
}
}

}





return 0;
}

int funcion_digi(char cadena[30])
{
int m=0;
int t=strlen(cadena);
for(int g=0; g
{
for(int k=0; k<10; k++)
{
if(cadena[g]==digi[k])
m++;

}
}

if(m==t)
{

return 7;
}
return 0;

}
///
int funcion_identificador(char cadena[30])
{
int m=0;
int tam=strlen(cadena);

    int i=0;
int b=0;

if(cadena[0]=='$')
  b++;




for(int x=0; x<25; x++)
{
if(cadena[1]==abc[x])
i++;

}

if(i>0&&b==1)
{

for(int y=1; y
{
for(int z=0; z<10; z++)
{
if(cadena[y]==digi[z])
m++;

}
for(int a=0; a<25; a++)
{
if(cadena[y]==abc[a])
m++;

}
}

if(m==tam-1)
{
for(int rt=0;rt
{
vara[we][rt]=cadena[rt];
}
we++;



return 8;
}
}

return 0;



}
///
int funcion_cadena(char cadena[30])
{
int m=0;
int tam=strlen(cadena);

    int i=0;
int b=0;

if(cadena[0]=='"'&&cadena[tam-1]=='"')
  b++;






if(b==1)
{

for(int y=1; y
{
for(int z=0; z<10; z++)
{
if(cadena[y]==digi[z])
m++;

}
for(int a=0; a<25; a++)
{
if(cadena[y]==abc[a])
m++;

}
}

if(m==tam-2)
{

return 9;
}
}
return 0;



}

////
int funcion_simbolos(char cadena[30])
{
int tam=strlen(cadena);

if(tam==1&&cadena[0]==';')
{

return 10;
}
if(tam==1&&cadena[0]=='=')
{

return 11;
}
if(tam==1&&cadena[0]=='(')
{

return 14;
}
if(tam==1&&cadena[0]==')')
{

return 15;
}
if(tam==1&&cadena[0]=='{')
{

return 16;
}
if(tam==1&&cadena[0]=='}')
{

return 17;
}
if(tam==2&&cadena[0]=='+'&&cadena[1]=='+')
{

return 18;
}
if(tam==2&&cadena[0]=='-'&&cadena[1]=='-')
{

return 18;
}



return 0;
}
////
int funcion_logicos(char cadena[30])
{
int tam=strlen(cadena);
if(tam==2&&cadena[0]=='='&&cadena[1]=='=')
{

return 12;
}
if(tam==1&&cadena[0]=='<')
{

return 12;
}
if(tam==1&&cadena[0]=='>')
{

return 12;
}
if(tam==2&&cadena[0]=='='&&cadena[1]=='>')
{

return 12;
}
if(tam==2&&cadena[0]=='<'&&cadena[1]=='=')
{

return 12;
}

return 0;

}
///
int funcion_matematicos(char cadena[30])
{
   int tam=strlen(cadena);
if(tam==1&&cadena[0]=='+')
{

return 13;
}
if(tam==1&&cadena[0]=='-')
{

return 13;
}
if(tam==1&&cadena[0]=='*')
{

return 13;
}
if(tam==1&&cadena[0]=='/')
{

return 13;
}
return 0;
}

<<<<<<<   Código que Los Analizadores Detectan para Verificar    >>>>>>>>

<<<<<<     Imágenes del Resultado   >>>>....

Doxygen Perl

<<<<<<  Programa Doxigen  Perl  [[[   Filtro   ]]]]   >>>>>>>>>


#include
#include
#include

using namespace std;
#define TAM 170

//definimos variables globales
    char cad[TAM];
    int cont_esp;
    bool flag_coment=false,flag_pal=false,flag_pre=false,flag_class;
int cont=0;


//funcion principal
int main(int  argc, char** argv)
{
  
  
    ifstream entrada;
if(argc>=2)
{
            entrada.open(argv[1], ios::in);
        //    cout<<"parametros"<
    }
    else
    {
        entrada.open("Perl.txt");
      //  cout<<"sin parametros"<
    }
    fstream a;
a.open("Perl2.txt",ios::out);
  
   // ofstream salida("procesado.h");
  //  salida.close();
    flag_class=false;
  
    //primero vemos si existe nuestro archivo
    if(!entrada.fail())
    {
a<<"class "<<"doxygen"<<<"{"<
a<<"public:"<
        while(!entrada.eof())
        {
             entrada.getline(cad,TAM);
if(cad[0]=='#')
{
            int o=1;
a<<"///";
while(cad[o]!=0)
{
            a<
o++;
}
a<
}
else
{
if(cad[0]=='d' && cad[1]=='e' && cad[2]=='f' && cad[3]==' ')
{

                 cont=1;
int o=4;
                 a<<"int ";
while(cad[o]!='(')
{
                 a<
o++;
}
a<
o++;
a<<"int ";
while(cad[o]!=0)
{
                 a<
o++;
}
a<<";"<
o=0;


}
}

        }//while
a<<"};"<
    }
    //sino existe
    else
    cout<<"El archivo no fue encontrado"<
    entrada.close();
   // salida.close();
    system("pause");
    return 0;
}

Entrada y salida del Programa Perl, leeido por el filtro

<<<<<<<  Programa ya en Perl  >>>>>>>>>>

Calculo de Iniciales

<<<<<<<  Programa Para Calculo de Iniciales  >>>>>>>>>


#include "Iniciales.h"

char NoTerminales[ 100 ];
char Terminales[ 100 ];

int main( int argc, char** argv )
{
   CIniciales calcIni;
   fstream Salida;
   char buffIni[ 100 ] = "";
   int i;
   cout<<"     Programa de Calculo de Iniciales"<
   cout<
   cout<<"     Misael Miramotes Flores"<
   cout<
   cout<

         calcIni.SetFname( "Gramatica.txt" );//Nombre del archivo

if( calcIni.CargarGramatica() == NOABRE )
     cout << "error al abrir la gramatica!" << endl;
  
  
   else
    {   char nt[ 100 ], alf[ 100 ], ini[ 100 ];
      
        for( i=0; i <= calcIni.NumProducciones(); i++ ) // cal. los iniciales
         {
           calcIni.ObtenerProduccion( nt, alf, ini, i );
          
           if( !strlen( ini ) ) calcIni.CalcIniciales( i, buffIni );
         }
      
        Salida.open( SALIDA, ios::out );
      
        if( Salida.fail() ) cout << "No se puede guardar el archivo de iniciales" << endl;
      
        else
         {
           for( i=0; i <= calcIni.NumProducciones(); i++ )
            {
              calcIni.ObtenerProduccion( nt, alf, ini, i );
              Salida << nt << " -> " << ini << endl;
 cout<< nt << " -> " << ini << endl;
            }
           cout<
           cout << "Este fue el resultado del calculo de iniciales" << endl;
  cout<
  cout<<"Este resultado tambien se puede encontrar en la misma carpeta en Iniciales.txt"<
  cout<
         }
    }

   if( argc > 1 ) cin.sync(), cin.get();
  
   cout << 0;
  
   return 0;
}

int BuscarTerminal( const char* T )
{
  int i;
 
  for( i=0; Terminales[ i ]; i++ ) if( Terminales[ i ] == T[0] ) return i;
 
  return ERROR_NO_ENCONTRADO;
}

CIniciales::CIniciales()
{
   this-> prod = NULL;
   this-> ultimaProd = -1;
}

CIniciales::~CIniciales()
{
   int i = this-> ultimaProd;
  
   if( this-> prod ) // si es distinto de NULL
    {
      for( ; i >= 0; i--)
       {
          delete[] this-> prod[ i ].Nterminal;
          delete[] this-> prod[ i ].Alfa;
          delete[] this-> prod[ i ].inicial;
       }
    
      delete[] this-> prod;
    }
}
  
inline int CIniciales::NumProducciones() { return this-> ultimaProd; }

inline int CIniciales::SetFname( const char* File )
{ strcpy( this-> archivo, File ); return 0; }

int CIniciales::CargarGramatica()
{
   char buffer[ MAX_BUFF ];
   char Nt[ 20 ], alf[ 100 ];
   char auxNt[ 20 ], auxAlfa[ 100 ], auxIni[ 3 ];
   int i = 0, j = 0, ind;
   fstream fgrama;
  
   fgrama.open( this-> archivo, ios::in );
   if( fgrama.fail() ) return NOABRE;
  
   fgrama.getline( buffer, MAX_BUFF );
  
   while( buffer[ i++ ] != '=' ) ;
  
   i++;
  
   while( buffer[ i ] ) // obtienes no terminales
    {
      if( buffer[ i ] != ' ' ) NoTerminales[ j++ ] = buffer[ i ];
      
      i++;
    }
      
   NoTerminales[ j ] = 0;
  
   fgrama.getline( buffer, MAX_BUFF );
      
   i = 0; j = 0;
  
   while( buffer[ i++ ] != '=' ) ;
  
   i++;
      
   while( buffer[ i ] ) // obtienes terminales
    {
      if( buffer[ i ] != ' ' && buffer[ i ] != ',' ) Terminales[ j++ ] = buffer[ i ];

      i++;
    }
      
   Terminales[ j ] = 0;
  
   while( !fgrama.eof() ) // carga las producciones
    {
       fgrama.getline( buffer, MAX_BUFF );
      
       if( !strlen( buffer ) ) continue;
      
       for( j=0, i=0; buffer[ i ]; i++ ) // obtiene el no terminal
        {
           if( buffer[ i ] == ' ' ) continue;

           if( buffer[ i ] != '-' && buffer[ i+1 ] != '>' )
            {
              Nt[ j++ ] = buffer[ i ];
              continue;
            }
          
           else
            {
              Nt[ j ] = 0;
              i += 2;
              break;
            }
        }
      
       for( j=0; buffer[ i ]; i++ )
        {
           if( buffer[ i ] == ' ' ) continue;
          
           alf[ j++ ] = buffer[ i ];
        }
      
       alf[ j ] = 0;
      
       ind = this-> BuscarProduccion( Nt ); // busca una produccion
      
       if( ind != ERROR_NO_ENCONTRADO )
        {
          this-> ObtenerProduccion( auxNt, auxAlfa, auxIni, ind );
        
          strcat( auxAlfa, "," ); strcat( auxAlfa, alf );
        
          this-> ModificarProduccion( Nt, auxAlfa, "", ind );
        }
      
       else  this-> AgregarProduccion( Nt, alf, "" );
      
    }
  
   fgrama.close();
  
   return 0;
}

int CIniciales::CalcIniciales( int indice, char* lista_ini )
{
   int i, j, tam, ind, k;
   char temp[ 5 ];
  
   tam = strlen( this-> prod[ indice ].Alfa );
   k = strlen( lista_ini );
  
   for( i=0, j=0, k=0; i < tam; i++ )
    {
      temp[ j ] = this-> prod[ indice ].Alfa[ i ];

      if( this-> prod[ indice ].Alfa[ i+1 ] == '\'' )
       {
         temp[ j++ ] = this-> prod[ indice ].Alfa[ i++ ];
       }
    
      temp[ ++j ] = 0;

      ind = BuscarTerminal( temp );
    
      if( ind != ERROR_NO_ENCONTRADO ) // si es terminal, lo agrega como inicial
       {
         lista_ini[ k++ ] = Terminales[ ind ];
         lista_ini[ k++ ] = ',';
         lista_ini[ k ] = 0;
       }
      
      else // si es un no terminal, busca sus iniciales
       {
         ind = this-> BuscarProduccion( temp );
        
         this-> CalcIniciales( ind, lista_ini );
         k = strlen( lista_ini );
       }
    
      for( i++; this-> prod[ indice ].Alfa[ i ]; i++ )
       {
         if( this-> prod[ indice ].Alfa[ i ] == ',' ) break;
       }
      
      j = 0;
    }
  
   if( this-> prod[indice].inicial ) delete[] this-> prod[ indice ].inicial;
  
   if( lista_ini[ k-1 ] == ',' ) lista_ini[ k-1 ] = 0;
  
   this-> prod[ indice ].inicial = new char[ strlen( lista_ini )+1 ];
   strcpy( this-> prod[ indice ].inicial, lista_ini );
  
   return 0;
}

int CIniciales::AgregarProduccion( const char* Nterm, const char* alfa, const char* Inicial )
{
   int i = 0;
   PRODUCCION *temp;
  
   this-> ultimaProd++;
  
   temp = new PRODUCCION[ this-> ultimaProd+1 ];
  
   if( !temp ) return ERROR_DE_ASIGNACION_DE_MEMORIA;
  
   for( ; i < this-> ultimaProd; i++ )
    {
      temp[ i ].Nterminal = this-> prod[ i ].Nterminal;
      temp[ i ].Alfa    = this-> prod[ i ].Alfa;
      temp[ i ].inicial = this-> prod[ i ].inicial;
    }
  
   delete[] this-> prod;
  
   temp[ i ].Nterminal = new char[ strlen( Nterm ) +1 ];
   temp[ i ].Alfa    = new char[ strlen( alfa ) +1 ];
   temp[ i ].inicial = new char[ strlen( Inicial ) +1 ];
  
   if( !temp[ i ].Nterminal || !temp[ i ].Alfa || !temp[ i ].inicial )
     return ERROR_DE_ASIGNACION_DE_MEMORIA;
    
   strcpy( temp[ i ].Nterminal, Nterm );
   strcpy( temp[ i ].Alfa, alfa );
   strcpy( temp[ i ].inicial, Inicial );
  
   this-> prod = temp;
  
   return this-> ultimaProd;
}

int CIniciales::BuscarProduccion( const char* Nterm )
{
   int i = 0;
  
   while( i <= this-> ultimaProd )
    {
      if( !strcmp( this-> prod[ i ].Nterminal, Nterm ) ) return i;
      i++;
    }
      
   return ERROR_NO_ENCONTRADO;
}

int CIniciales::ModificarProduccion( const char* Nterm, const char* alfa, const char* Inicial, int indice )
{
   if( indice < 0 || indice > this-> ultimaProd ) return ERROR_FUERA_DE_RANGO;
  
   delete[] this-> prod[ indice ].Nterminal;
   delete[] this-> prod[ indice ].Alfa;
   delete[] this-> prod[ indice ].inicial;
  
   this-> prod[ indice ].Nterminal = new char[ strlen( Nterm ) +1 ];
   this-> prod[ indice ].Alfa    = new char[ strlen( alfa ) +1 ];
   this-> prod[ indice ].inicial = new char[ strlen( Inicial ) +1 ];
  
   if( !prod[ indice ].Nterminal || !prod[ indice ].Alfa || !prod[ indice ].inicial )
      return ERROR_DE_ASIGNACION_DE_MEMORIA;
    
   strcpy( this-> prod[ indice ].Nterminal, Nterm );
   strcpy( this-> prod[ indice ].Alfa, alfa );
   strcpy( this-> prod[ indice ].inicial, Inicial );
  
   return indice;
}

int CIniciales::ObtenerProduccion( char* Nterm, char* alfa, char* Inicial, int indice )
{
   if( indice < 0 || indice > this-> ultimaProd ) return ERROR_FUERA_DE_RANGO;
  
   strcpy( Nterm, this-> prod[ indice ].Nterminal );
   strcpy( alfa, this-> prod[ indice ].Alfa );
   strcpy( Inicial, this-> prod[ indice ].inicial );
  
   return indice;
}

<<<<<<   Programa En .h   >>>>>>>

#ifndef INICIALES_H

#define INICIALES_H

#include

#include

#include

using namespace std;

#ifndef MAX_PATH

#define MAX_PATH 256

#endif

#define MAX_BUFF 256

#define SALIDA "iniciales.txt"

#define ERROR_DE_ASIGNACION_DE_MEMORIA -1

#define NOABRE   -2

#define ERROR_NO_ENCONTRADO   -3

#define ERROR_FUERA_DE_RANGO           -4

typedef struct _PRODUCCION

{

   char *Nterminal;

   char *Alfa;

   char *inicial;

   

} PRODUCCION;

 // clase que se utilizan para el de archivos

class CIniciales

{

   private:

    PRODUCCION *prod;

    int  ultimaProd;

    char archivo[ MAX_PATH ];

   public:

    CIniciales();

    ~CIniciales();

    

    int SetFname( const char* File );

    int CalcIniciales( int indice, char* lista_ini );

    int NumProducciones();

    

    int CargarGramatica();

    int AgregarProduccion( const char* Nterm, const char* alfa, const char* Inicial );

    int BuscarProduccion( const char* Nterm );

    int ModificarProduccion( const char* Nterm, const char* alfa, const char* Inicial, int indice );

    int ObtenerProduccion( char* Nterm, char* alfa, char* Inicial, int indice );

};

int BuscarTerminal( const char* T );

#endif

<<<<<<<<<<<<<<<<<<<<<<<<<<<<<

Automata de Pila

>>>>  Programa .cpp  <<<<<<
#include
#include "Pila.h"

using namespace std;

#define E1    -1
#define E2 -2
#define E3 0
#define Maximo   100

char *Prod[12] = { "T", "T'", "E", "E'", "F", "+", "*", "#", "I", "(", ")", "$" };

int tblAutomata[6][6]={
{0,99,99,0,99,99},
{99,1,99,99,2,2},
{3,99,99,3,99,99},
{99,5,4,99,5,5},
{6,99,99,7,99,99},
{99,99,99,99,99,100}};

enum Producciones { T, T_P, E, E_P, F, ADD, MUL, V, ID, PAR_A, PAR_C, FC };



CStack Pila( sLong(100) ); // DECLARACION DE LA PILA

int AutoTabla( const char* cadena );




void main()
{
   char cadena_ent[ Maximo ];
  
   cout << "*******AUTOMATA DE PILA**********"<<
     cout << "INCERTA CADENA: ";
     cin.getline( cadena_ent, Maximo);    
     strcat( cadena_ent,"$" ); //AGREGA SIMBOLO AL FINAL DE LA CADENA
    
     switch(AutoTabla(cadena_ent))
      {
        case E1: cout << "Error en la sintaxis" << endl; break;
        case E2: cout << "Caracter no valido" <
        case E3: cout << "ACEPTADA"<
      }
    
     Pila.sDelete();//ELIMINA LA PILA
}

int AutoTabla( const char *cadena )
{
   int i=0,tamCad=strlen(cadena);
   long elem, col=0,fil=0,pa=0;
   char *tmp;
  
   Pila.sPush( (long)&Prod[ FC ][ 0 ],NULL ); // INSERTA SIMBOLO DE FIN DE CADENA
   Pila.sPush( (long)&Prod[ E ][ 0 ], NULL ); // INSERTA INCIAL DE L APILA
  
   while(cadena[i])
    {
       Pila.sPeek( elem, NULL );
       tmp=(char*)elem;
      
       if(tmp[0]==cadena[i] || (isalpha(cadena[i]) && tmp[0]=='I'))
        {
          if( cadena[ i ] == '$' )
            if( !pa ) return E3;
else
return E1;
        
          if( cadena[ i ] == '(' )
 pa++;
          else
 if( cadena[ i ] == ')' ) pa--;
          
          Pila.sPop( elem,NULL );
          i++;
 continue;
        }
 
 
 
 
 
 
  ///////////////////////////////////////////////////////////////////////////////////////////////
  /////////////DA VALORES A FINA Y COLUMNA PARA RECORRER LA TABLA////////////////////////////////
  ///////////////////////////////////////////////////////////////////////////////////////////////
        
       if( !strcmp((char*)elem,Prod[E]))
  fil = 0;  
       else
  if( !strcmp( (char*)elem,Prod[E_P]) )
  fil = 1;
  else
  if( !strcmp( (char*)elem,Prod[T]) )
  fil = 2;
  else
  if( !strcmp( (char*)elem,Prod[T_P]) )
  fil = 3;
  else
  if( !strcmp( (char*)elem,Prod[F]) )
  fil = 4;
  else
  if( !strcmp( (char*)elem,Prod[FC]) )
  fil = 5;
      
       if( isalpha( cadena[ i ] ) )
  col = 0;
       else
  if( cadena[ i ] == '+' )
  col = 1;
  else
  if( cadena[ i ] == '*' )
  col = 2;
  else
  if( cadena[ i ] == '(' )
  col = 3;
  else if( cadena[ i ] == ')' )
  col = 4;
  else
  if( cadena[ i ] == '$' ) col = 5;

  else return E2;

  ///////////////////////////////////////////////////////////////////////////////////////////////
  ///////////////////////////////////////////////////////////////////////////////////////////////
  //////////////////////////////////////////////////////////////////////////////////////////////



       switch( tblAutomata[fil][col] )//RECORRE LA TABLA
        {
          case 0:Pila.sPop( elem,NULL ); Pila.sPush( (long)&Prod[E_P][0],NULL );Pila.sPush( (long)&Prod[T][0],NULL );
            break;          
          case 1:Pila.sPop( elem,NULL);Pila.sPush( (long)&Prod[E_P][0],NULL );Pila.sPush( (long)&Prod[T][0],NULL );
 Pila.sPush( (long)&Prod[ADD][0],NULL );
            break;          
          case 2:Pila.sPop( elem,NULL );break;
 case 3:Pila.sPop( elem,NULL );Pila.sPush( (long)&Prod[T_P][0],NULL );Pila.sPush( (long)&Prod[F][0],NULL );
           break;          
          case 4:Pila.sPop( elem,NULL );Pila.sPush( (long)&Prod[T_P][0],NULL );Pila.sPush( (long)&Prod[F][0],NULL );
 Pila.sPush( (long)&Prod[MUL][0],NULL );
 break;
 case 5:Pila.sPop( elem,NULL );break;        
          case 6:Pila.sPop( elem,NULL );Pila.sPush( (long)&Prod[ID][0],NULL );break;          
          case 7:Pila.sPop( elem,NULL );Pila.sPush( (long)&Prod[PAR_C][0],NULL );Pila.sPush( (long)&Prod[E][0],NULL );
             Pila.sPush( (long)&Prod[PAR_A][0],NULL );break;          
          case 99: return E2;
        
          case 100: return E3;
        }


    }

   return E1;
}

>>>>>>  Programa en .h   <<<<<<<

#ifndef STACK_CPP_H

#define STACK_CPP_H

#ifndef NULL

 #define NULL 0

#endif

  // constantes de excepciones

#define STACK_SUCCESS    0

#define STACK_EMPTY     -1

#define STACK_FULL      -2

#define STACK_ERR_MEM   -3

#define STACK_OUT_RANGE -4

#define sShort(code) (short)code

#define sLong(value) (long)value

typedef struct _STACK_SEGMENT // segmento de pila

{

  long dwData;

  void *vpAux;

  

} STACK_SEGMENT;

  

class CStack // clase manejadora de pila

{

   private:

    STACK_SEGMENT **sSegments;

    long dwSP;

    long dwSSize;

    short wExCod;

    

   public:

    CStack( long sMaxSize );

    CStack( short wCode ) : wExCod(wCode) { this-> sSegments = NULL; }

    ~CStack();

    

    const char* what() const throw();

    

    short sGetExCode();

    long GetSP();

    long GetStackMaxSize();

    long sPush( long dwData, const void** vpAux );

    long sPop( long& dwData, void** vpAux );

long sPeek( long& dwData, void** vpAux );

    long sDelete();

};

  // constructor

CStack::CStack( long sMaxSize )

{ 

  this-> dwSP      = -1;

  this-> wExCod    = 0;

  this-> dwSSize   = sMaxSize;

  this-> sSegments = NULL;

}

CStack::~CStack() { this-> sDelete(); } // Destructor

inline long CStack::GetSP() { return this-> dwSP; } // obtiene el puntero de pila

inline long CStack::GetStackMaxSize() { return this-> dwSSize;} // obtiene el tamaño maximo de pila

inline short CStack::sGetExCode() { return this-> wExCod; } // obtiene el codigo de excepcion

long CStack::sPush( long dwData, const void** vpAux ) // inserta un elemento en la pila

{

   STACK_SEGMENT **sAux;

   long i;

      // si la pila esta llena

   if( this-> dwSP >= this-> dwSSize-1 ) throw CStack( sShort(STACK_FULL) );

   this-> dwSP++;

   

   if( !this-> dwSP ) // si es el primer elemento

    {

      this-> sSegments = new STACK_SEGMENT* [this-> dwSP+1];

      if( !this-> sSegments ) throw CStack( sShort(STACK_ERR_MEM) );

      

      this-> sSegments[ this-> dwSP ] = new STACK_SEGMENT;

      if( !this-> sSegments[ this-> dwSP ] ) throw CStack( sShort(STACK_ERR_MEM) );

    }

   

   else // numero de elementos > 1

    {

      sAux = new STACK_SEGMENT* [this-> dwSP+1];

      if( !sAux ) throw CStack( sShort(STACK_ERR_MEM) );

      

      sAux[ this-> dwSP ] = new STACK_SEGMENT;

      if( !sAux[ this-> dwSP ] ) throw CStack( sShort(STACK_ERR_MEM) );

      

      for( i=0 ; i < this-> dwSP; i++ ) sAux[ i ] = this-> sSegments[ i ];

      

      delete[] this-> sSegments;

      

      this-> sSegments = sAux;

    }

   this-> sSegments[ this-> dwSP ]-> dwData = dwData;

   

   if( vpAux )

     this-> sSegments[ this-> dwSP ]-> vpAux  = (void*)*vpAux;

   else

     this-> sSegments[ this-> dwSP ]-> vpAux  = NULL;

   

   return this-> dwSP;

} // fin de sPush()

long CStack::sPop( long& dwData, void** vpAux ) // extrae un elemento de la pila

{

   STACK_SEGMENT **sAux;

   long i, tmpSP;

      // si la pila esta vacia

   if( this-> dwSP < 0 ) throw CStack( sShort(STACK_EMPTY) );

     

   dwData  = this-> sSegments[ this-> dwSP ]-> dwData;

   if( vpAux ) *vpAux = this-> sSegments[ this-> dwSP ]-> vpAux;

 

   if( !this-> dwSP ) // si hay un elemento

    {  

      delete this-> sSegments[ this-> dwSP ];

      delete[] this-> sSegments;

      

      this-> dwSP = -1;

    }

   

   else // si hay mas de 1 elemento

    { 

      sAux = new STACK_SEGMENT* [ this-> dwSP ];

      if( !sAux ) throw CStack( sShort(STACK_ERR_MEM) );

      

      delete this-> sSegments[ this-> dwSP ];

   

      this-> dwSP--;

 

      for( i=0; i <= this-> dwSP; i++ ) sAux[ i ] = this-> sSegments[ i ];

   

      delete[] this-> sSegments;

      

      this-> sSegments = sAux;

    }

    

   return this-> dwSP;

} // fin de sPop()

  // obtiene el elemeto en la cima sin extraerlo

long CStack::sPeek( long& dwData, void** vpAux )

{

   if( this-> dwSP < 0 ) throw CStack( sShort(STACK_EMPTY) );

   

   dwData = this-> sSegments[ this-> dwSP ]-> dwData;

   if( vpAux ) *vpAux  = this-> sSegments[ this-> dwSP ]-> vpAux;

   

   return this-> dwSP;

}

long CStack::sDelete() // Elimina la pila

{

   if( this-> sSegments )

    {

      for( ; this-> dwSP >= 0; this-> dwSP-- ) delete this-> sSegments[ this-> dwSP ];

      delete[] this-> sSegments;

    }

    

   return STACK_SUCCESS;

}

const char* CStack::what() const throw() // devuelve el texto de la excepcion

{

   switch( this-> wExCod )

    {

      case STACK_SUCCESS: return "Exito";

      case STACK_FULL:    return "Pila llena";

      case STACK_EMPTY:   return "Pila Vacia";

      case STACK_ERR_MEM: return "Error de asignacion de memoria";

    }

   

   return NULL;

}

#endif

Programa del Libro

/* ---------- global.h ----------------*/

#include

#include

#include

#include

#define MAXLEX 999 /* tamano de la matriz de lexema */

#define MAXSIMB 100 /* tamano de la tabla de simbolos */

#define TAMBUFF 128

#define NINGUNO -1

#define FDC '\0'

#define NUM 256

#define DIV 257

#define MOD 258

#define ID 259

#define FIN 260

//int valcomplex = NINGUNO; /* valor del atributo del componente lexico */

//int numlinea = 1;

typedef struct _entrada { /* forma del elemento de entrada de la tabla de simbolos */

char *aplex;

int complex;

}entrada;

//entrada tablasimb[MAXSIMB]; /* tabla de simbolos */

//void analizsint();

int analex();

int busca(char *s);

void inic();

void error(char *m);

void emite (int t,int tval);

void analsint();

int inserta(char *s, int clex);

void expr();

//void expre();

void termino();

void factor();

void parea (int t);

 /* *********************** analizlex.c ****************************/

#include

#include

#include "global.h"

#include

int valcomplex = NINGUNO; /* valor del atributo del componente lexico */

int numlinea = 1;

extern entrada tablasimb[MAXSIMB]; /* tabla de simbolos */

char buflex[TAMBUFF];

//int numlinea = 1;

//int valcomplex = NINGUNO;

int analex() /* analizador lexico */

{

int t;

while(1) {

t = getchar();

if(t == ' ' || t == '\t')

; /* elimina espacios en blanco */

else if (t == '\n')

numlinea = numlinea + 1;

else if (isdigit(t)) { /* t es un digito */

ungetc(t, stdin);

scanf("%d", &valcomplex);

return NUM;

}

else if (isalpha(t)) { /* t es una letra */

int p, b=0;

while (isalnum(t)) { /* t es alfanumerico */

buflex[b] = t;

t = getchar();

b = b+1;

if (b >= TAMBUFF)

error("error de compilador");

}

buflex[b] = FDC;

if (t != EOF)

ungetc(t, stdin);

p = busca(buflex);

if (p == 0)

p = inserta(buflex, ID);

valcomplex = p;

return tablasimb[p].complex;

}

else if(t == EOF)

return FIN;

else {

valcomplex = NINGUNO;

return t;

}

}

}

/* ********************* analizsintactico.c ********************/

#include

#include

#include

#include "global.h"

extern int valcomplex; /* valor del atributo del componente lexico */

extern int numlinea;

extern entrada tablasimb[MAXSIMB]; /* tabla de simbolos */

int preanalisis;

void analsint() /* analiza sintecticamente y traduce la lista de la expresion */

{

preanalisis = analex();

while (preanalisis != FIN) {

expr(); parea(';');

}

}

void expr()

{

int t;

termino();

while(1)

switch (preanalisis) {

case '+': case '-':

t = preanalisis;

parea (preanalisis); termino(); emite(t, NINGUNO);

continue;

default:

return;

}

}

void termino()

{

int t;

factor();

while(1)

switch(preanalisis) {

case '*': case '/': case DIV: case MOD:

t = preanalisis;

parea (preanalisis); factor(); emite(t, NINGUNO);

continue;

default:

return;

}

}

void factor()

{

switch(preanalisis) {

case '(':

parea('(');

        expr();

        parea(')');

        break;

case NUM:

emite(NUM, valcomplex); parea(NUM); break;

case ID:

emite(ID, valcomplex); parea(ID); break;

default:

error("error de sintaxis");

}

}

void parea (int t)

{

if(preanalisis == t)

preanalisis = analex();

else error ("error de sintaxis");

}

/* **************** emisor.c *******************/

#include

#include

#include

#include "global.h"

extern int valcomplex; /* valor del atributo del componente lexico */

extern int numlinea;

extern entrada tablasimb[MAXSIMB]; /* tabla de simbolos */

void emite (int t,int tval) /* genera la salida */

{

switch(t) {

case '+': case '-': case '*': case '/':

printf("%c\n",t); break;

case DIV:

printf("%DIV\n"); break;

case MOD:

printf("%MOD"); break;

case NUM:

printf("%d\n", tval); break;

case ID:

printf("%s\n", tablasimb[tval].aplex); break;

default:

printf("complex %d, valcomplex %d\n", t, tval);

}

}

/************* error.c ***********************/

#include

#include

#include

#include "global.h"

extern int valcomplex; /* valor del atributo del componente lexico */

extern int numlinea;

extern entrada tablasimb[MAXSIMB]; /* tabla de simbolos */

void error(char *m) /* genera todos los mensajes de error */

{

fprintf(stderr, "linea %d: %s\n", numlinea, m);

exit(1); /* terminacion sin exito */

}

/* **************** ini.c ********************/

#include

#include

#include

#include "global.h"

extern int valcomplex; /* valor del atributo del componente lexico */

extern int numlinea;

extern entrada tablasimb[MAXSIMB]; /* tabla de simbolos */

struct _entrada palsclave[] = {

"div",DIV,"mod", MOD,0,0

};

void inic() /* carga las palabras clave en la tabla de simbolos */

{

        

struct _entrada *p = palsclave;

for (; p->complex; p++)

inserta(p->aplex, p->complex);

}

/* ******************** principal.c ***************/

#include

#include

#include

#include "global.h"

extern int valcomplex; /* valor del atributo del componente lexico */

extern int numlinea;

entrada tablasimb[MAXSIMB]; /* tabla de simbolos */

int main()

{

inic();

analsint();

exit(0); /* terminacion con exito */

return 0;

}

/* ********************* simbolos.c  ****************/

#include

#include

#include "global.h"

extern int valcomplex; /* valor del atributo del componente lexico */

extern int numlinea;

extern entrada tablasimb[MAXSIMB]; /* tabla de simbolos */

char lexemas[MAXLEX];

int ultcar = -1; /* ultima posicion usada en los lexemas */

int ultent = 0; /* ultima posicion usada en tablasimb */

int busca(char *s)   /*debuelve la posicion del elemento de entrada de s */

{

int p;

for(p=ultent;p>0;p=p-1)

if(strcmp(tablasimb[p].aplex, s) == 0)

return p;

return 0;

}

int inserta(char *s, int clex) /* debuelve la posicion del elemento de entrada de s */

{

int lon;

lon = strlen(s); /* strlen evvalua la longitud de s */

if (ultent + 1 >= MAXSIMB)

error("tabla simbolos llena");

if (ultcar + lon + 1 >= MAXLEX)

error("matriz de lexema llena");

ultent = ultent + 1;

tablasimb[ultent].complex = clex;

tablasimb[ultent].aplex = &lexemas[ultcar + 1];

ultcar = ultcar + lon + 1;

strcpy(tablasimb[ultent].aplex, s);

return ultent;

}