VPN

Compilador Javascript

Programa Archivo Cpp
#include
#include
#include
#include
#include


int funcion_evaluar_cadena(char cadena[20],int linea);
int funcion_evaluar_linea(int linea[50][2],int lineas,int y);

int funcion_evaluar_id(char cadena[20], int linea);
char palabras_reservadas[12][17]=
{
{'w','h','i','l','e'},{'i','f'},{'v','a','r'},{'e','l','s','e'},{'f','o','r'},{'c','a','s','e'},{'b','r','e','a','k'},{'s','c','r','i','p','t'},{'/','s','c','r','i','p','t'},

};
char tabla_transiones_identificadores[3][2]=
{
{0, 0},
{2, 0},
{2, 2},

};
char tabla_transiones_logicos[5][4]=
{
{0, 0, 0, 0},
{2, 2, 4, 4},
{0, 0, 3, 0},
{0, 0, 0, 0},
{0, 0, 3, 0},
};

char operadores_logicos[4]={'<','>','=','!'};
char operadores_matematicos[4]={'/','*','-','+'};
char abc[26]={'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 fin_linea=';';
char flujo_out[2]={'<','<'};
char flujo_in[2]={'>','>'};
char llaves[2] ={'{','}'};
char parentesis[2]={'(',')'};
char digito[10]={'0','1','2','3','4','5','6','7','8','9'};
char comillas={'"'};

char cadena[50][20];
int n_cadena[50][6];
char lista_identificador[20][30];
int linea_identificador[20];
int tipo_identificador[20];
int li=0;
int nop=0;
void main()
{

cout< cout<<" ***ANALIZADOR LEXICO***"< cout< cout<<"---------------------------------------------------------------------------"<
ifstream archivo("progra.txt", ios::in);
char var;
int x=0,y=0;
int tok=0;
int linea=1;
int linea_q[50][2];

while(!archivo.eof())
{
archivo.get(var);
if(var==' '||var=='\n')
{
x=0;
linea_q[y][1]=funcion_evaluar_cadena(cadena[y],linea);
cout<<"\t\tNumero de Linea "< linea_q[y][0]=linea;
if(var=='\n')
linea++;


y++;

}
else
{

cadena[y][x]=var;
cout< x++;
}
}
cout<<"-------------------------------------------------------------------"< cout< cout<<" *** ANALIZADOR SINTACTICO ***"< cout<<"-------------------------------------------------------------------"< cout< cout<//for(int p=0; p// cout<

funcion_evaluar_linea(linea_q,linea,y);
cout<<" Variables "<for(int g=0; g{
if(tipo_identificador[g]>0)
{
cout<<"La variable ";
int d =strlen(lista_identificador[g]);
for(int c=0; c {
cout< }
cout<<" es de tipo ";

if(tipo_identificador[g]==1)
{
cout<<"entero";
}
else
if(tipo_identificador[g]==2)
{
cout<<"string";
}

cout<}

}

}

//-------------------------------------------------------------------------------------------------------------
void azu()
{


ifstream archivo("progra.txt", ios::in);
char var;
int x=0,y=0;
int tok=0;
int linea=1;
char cadena[50][20];
char info_cadena[50];


while(!archivo.eof())
{
archivo.get(var);
if(var==' '||var=='\n')
{
x=0;
funcion_evaluar_id(cadena[y],linea);
cout<<"\t\tNumero de Linea "< info_cadena[y]=linea;
if(var=='\n')
linea++;
y++;
}
else
{
cadena[y][x]=var;
cout< x++;
}
}


}
/////______________________________________________________
int funcion_evaluar_id(char cadena[20], int linea)
{
int apunta=1,dir=2;
int t=strlen(cadena);
int sim=0;
int x, y;

for( x=0; x {
dir=2;

for( y=0; y<26;y++)
{
if(abc[y]==cadena[x])
{
dir=0;
y=30;

}
}
for( int z=0; z<10;z++)
{
if(digito[z]==cadena[x])
{
dir=1;
y=30;

}
}
if(dir==2)
{
apunta=0;
}
else
{
apunta=tabla_transiones_identificadores[apunta][dir];
}
}

if(apunta==2)
{




cout<<"\t\tEs_Identificador";
for(int q=0; q {
lista_identificador[li][q]=cadena[q];

}
linea_identificador[li]=linea;
li++;

return 21;

}
}
//_______________________________________________________________________________________________________________
int funcion_evaluar_cadena(char cadena[20], int linea)
{
int t=strlen(cadena);
int sim=0;
int x, y;
if(t==1)
{
char var=cadena[0];
char var1=cadena[0];
char var2=cadena[0];
if(cadena[0]==fin_linea)
{
cout<<"\t\tFin de Sentencia";

return 20;
}

for( x=0; x<4; x++)
{

if(operadores_matematicos[x]==var)
{
cout<<"\t\tOpe. Matematico ";
return 13;


}

}

for( x=0; x<2; x++)
{

if(llaves[x]==cadena[0])
{

cout<<"\t\tEs una Llave";
return 14+x;


}

}
if('='==cadena[0])
{

cout<<"\t\tes un operador matematico";
return 16;


}

for( x=0; x<2; x++)
{

if(parentesis[x]==cadena[0])
{

cout<<"\t\tEs un Parentesis ";
return 17+x;


}

}


}

sim=0;
int nofun=0;

for( x=0; x {
nofun++;
for( y=0; y<10;y++)
{
if(cadena[x]==digito[y])
{

sim++;
y=100;

}
else
nofun++;
}
if(nofun==10)
x=100;

}

if(sim==t)
{
cout<<"\t\tEsto es un Numero";
return 19;
}




for( x=0; x<12; x++)
{
sim=0;

for( y=0; y {
if(cadena[y]==palabras_reservadas[x][y])
{
sim++;
}
}
int ta=strlen(palabras_reservadas[x]);

if(sim==ta&&t==sim)
{
cout<<"\t\tPalabra_Reservada";
//if(x==0||x==1||x==3||x==4)
//cout<<" *Compatible con c*";

return x+1;
}

}
int apunta=1,dir=2;

for( x=0; x {
dir=2;

for( y=0; y<26;y++)
{
if(abc[y]==cadena[x])
{
dir=0;
y=30;

}
}
for( int z=0; z<10;z++)
{
if(digito[z]==cadena[x])
{
dir=1;
y=30;

}
}
if(dir==2)
{
apunta=0;
}
else
{
apunta=tabla_transiones_identificadores[apunta][dir];
}
}

if(apunta==2)
{




cout<<"\t\tEs_Identificador";
for(int c=0; c {
lista_identificador[nop][c]=cadena[c];
}
nop++;

return 21;

}
int igu=0;
if(cadena[0]=='"'&&cadena[t-1]=='"')
{
for(int f=1; f {
for(int z=0; z<26;z++)
{
if(cadena[f]==abc[z])
{
igu++;
}

}
}
if(igu==t-2)
{
cout<<"\t\tIdentificador Cadena"< return 25;
}
}
int azu=0;
for(int w=1; w{
for(int z=0; z<10; z++)
{
if(cadena[w]==digito[z])
{
azu++;
}
}
}
if(azu==t)
{
cout<<"\t\tIdentificador numerico"< return 26;
}





apunta=1,dir=2;

for( x=0; x {
dir=10;;

for( y=0; y<4;y++)
{
if(operadores_logicos[y]==cadena[x])
{

dir=y;

}

}
if(dir==10)
{
apunta=0;
}
else
{

apunta=tabla_transiones_logicos[apunta][dir];
}

}
int st=strlen(cadena);
if(st==1)
{
if(cadena[0]=='<')
{
return 23;
}
if(cadena[0]=='>')
{
return 24;
}


}

if(apunta==2||apunta==3)
{
cout<<"\t\tEs un Operador Logico ";
return 22;

}

cout<<"\tError no es token";

return 0;

}
/////.......................................................
int funcion_evaluar_linea(int linea[50][2],int lineas,int y)
{
int are[15][16];
int tom[15];
int ev_lin[15];
int metric=0;
for(int p=0; p<=lineas; p++)
{int tam=0;
for(int k=0; k if(p==linea[k][0])
{
are[p][tam]=linea[k][1];
tam++;
}
tom[p]=tam;
if(tom[p]==3)
{
if(are[p][0]==23)
if(are[p][1]==8)
if(are[p][2]==24)
{
cout<<"Etiqueta de inicio "< ev_lin[metric]=1;
metric++;
}

if(are[p][0]==23)
if(are[p][1]==9)
if(are[p][2]==24)
{
cout<<"Etiqueta de fin "< ev_lin[metric]=2;
metric++;
}
}
if(tom[p]==4)
{
if(are[p][0]==21)
if(are[p][1]==16)
if(are[p][2]==21)
if(are[p][3]==20)


{
cout<<"Expresion matematica "< ev_lin[metric]=3;
metric++;

}


}
if(tom[p]==6)
{
if(are[p][0]==21)
if(are[p][1]==16)
if(are[p][2]==19)
if(are[p][3]==13)
if(are[p][4]==21)
if(are[p][5]==19)
{
cout<<"Operacion matematica "< ev_lin[metric]=3;
metric++;
// cout<<"

}




if(are[p][0]==2)
if(are[p][1]==17)
if(are[p][2]==21||are[p][2]==19)
if(are[p][3]==22||are[p][3]==23||are[p][3]==24)
if(are[p][4]==21||are[p][4]==19)
if(are[p][5]==18)
{
cout<<"Inicia if"< ev_lin[metric]=4;
metric++;

}
if(are[p][0]==1)
if(are[p][1]==17)
if(are[p][2]==21||are[p][2]==19)
if(are[p][3]==22||are[p][3]==23||are[p][3]==24)
if(are[p][4]==21||are[p][4]==19)
if(are[p][5]==18)
{
cout<<"Inicia while"< ev_lin[metric]=5;
metric++;

}





}
if(tom[p]==5)
{
if(are[p][0]==3)
if(are[p][1]==21)
if(are[p][2]==16)
if(are[p][3]==19)
if(are[p][4]==20)


{
cout<<"Declaracion de variable de tipo entero "< ev_lin[metric]=6;
metric++;

tipo_identificador[li]=1;
li++;



}


}
if(tom[p]==5)
{
if(are[p][0]==3)
if(are[p][1]==21)
if(are[p][2]==16)
if(are[p][3]==25)
if(are[p][4]==20)

{
cout<<"Declaracion de variable de tipo string "< ev_lin[metric]=6;
metric++;
tipo_identificador[li]=2;
li++;



}


}
if(tom[p]==3)
{
if(are[p][0]==3)
if(are[p][1]==21)
if(are[p][2]==20)

{
cout<<"Declaracion de variable indefinida "< ev_lin[metric]=6;
metric++;

}


}


if(tom[p]==16)
{
if(are[p][0]==5)
if(are[p][1]==17)
if(are[p][2]==21)
if(are[p][3]==16)
if(are[p][4]==21||are[p][4]==19)
if(are[p][5]==20)
if(are[p][6]==21||are[p][6]==19)
if(are[p][7]==22||are[p][7]==23||are[p][7]==24)
if(are[p][8]==21||are[p][8]==19)
if(are[p][9]==20)
if(are[p][10]==21)
if(are[p][11]==16)
if(are[p][12]==21||are[p][12]==19)
if(are[p][13]==13)
if(are[p][14]==21||are[p][14]==19)
if(are[p][15]==18)

{
cout<<"inicio de for "< ev_lin[metric]=7;
metric++;

}
}
if(tom[p]==1)
{
if(are[p][0]==14)
{
cout<<"llave de inicio "< ev_lin[metric]=8;
metric++;
}
if(are[p][0]==15)
{
cout<<"llave de fin "< ev_lin[metric]=9;
metric++;
}
if(are[p][0]==4)
{
cout<<"llave de fin "< ev_lin[metric]=10;
metric++;
}

}




}


int eti_ini=0;
int eti_fin=0;
int c_mat=0;
int if_ini=0;
int while_ini=0;
int c_var=0;
int for_ini=0;
int llave_inicio=0;
int llave_fin=0;
int c_else=0;

if(ev_lin[metric-1]==2&&ev_lin[0]==1)
{
for(int w=0; w {
if(ev_lin[w]==1)
{
//etiqueta de inicio
eti_ini++;
}
if(ev_lin[w]==2)
{
//etiqueta de inicio
eti_fin++;
}
if(ev_lin[w]==3)
{
//etiqueta de inicio
c_mat++;
}
if(ev_lin[w]==4)
{
//etiqueta de inicio
if_ini++;
}
if(ev_lin[w]==5)
{
//etiqueta de inicio
while_ini++;
}
if(ev_lin[w]==6)
{
//etiqueta de inicio
c_var++;
}
if(ev_lin[w]==7)
{
//etiqueta de inicio
for_ini++;
}
if(ev_lin[w]==8)
{
//etiqueta de inicio
llave_inicio++;
}
if(ev_lin[w]==9)
{
//etiqueta de inicio
llave_fin++;
}
if(ev_lin[w]==10)
{
//etiqueta de inicio
c_else++;
}
if(llave_inicio {
cout<<"error en las llaves"< }
if(c_else>if_ini)
{
cout<<"error en la estructura if"< }

}

if(llave_inicio>llave_fin||llave_inicio {
cout<<"error en las llaves "<
}

if(c_else>if_ini)
{
cout<<"error en la sentencia if "<
}
}
else
{
cout<<"error rn las etiquetas de inicio y fin de script "<}


return 0;
}


Programa en Javascript
< script >
var x = 15 ;
var y = "hola" ;
var z = 21 ;
for ( x = 10 ; x > 15 ; x = x + 1 )
{
}
if ( y == 21 )
{
}
< /script >

Resultado en Consola

Filtro y Documentacion del Doxigen

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;


//funcion principal
int main(int argc, char** argv)
{


ifstream entrada;
if(argc>=2)
{
entrada.open(argv[1], ios::in);
// cout<<"parametros"< }
else
{
entrada.open("progra.txt");
// cout<<"sin parametros"< }
fstream a;
a.open("progra2.txt",ios::out);

// ofstream salida("procesado.h");
// salida.close();
flag_class=false;

//primero vemos si existe nuestro archivo
if(!entrada.fail())
{
a<<"class "<<"script"< a<<"public:"< while(!entrada.eof())
{
entrada.getline(cad,TAM);
if(cad[0]=='/' && cad[1]=='/')
{
int o=1;
a<<"//";
while(cad[o]!=0)
{
a< o++;
}
a< }
else
{
if(cad[0]=='f' && cad[1]=='u' && cad[2]=='n' && cad[3]=='c' && cad[4]=='t' && cad[5]=='i' && cad[6]=='o' && cad[7]=='n' && cad[8]==' ')
{
int o=0;
a<<"int ";
while(cad[o]!='(')
{
a< o++;
}
a< o++;
a<<"int ";
while(cad[o]!=0)
{
a< o++;
}
a<<";"< o=0;
a<<"{"< }
else
{


for(int t=0;cad[t]!=0;t++)
{
int t=0;
if(cad[0]=='v' && cad[1]=='a' && cad[2]=='r' && cad[3]==' ')
{
a<<"int ";
t++;
while(cad[t]!=' ')
{
a< t++;
}
a<<";"< }
else
{

}
}
a<
}
}





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

Programa Inicial que Toma el Filtro
// javascript
//funcion declara
//variables
var x;
var y;
function declara (x y)
{
}

Resultado del Filtro
class script
{
public:
/// javascript
///funcion declara
///variables
int function declara (int x y);
{

}
}

Documentacion del Doxigen

Calculo de Iniciales

Gramatica
NT = E,E',T,T',F
T = +,*,(,),#,i

E -> TE'
E' -> +TE'
E'-> #
T -> FT'
T' -> *FT'
T' -> #
F -> (E)
F -> i


Codigo de Calculo de Iniciales
Archivo CPP

#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<<"**********Calculo de Iniciales**********"<
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++ ) // calculo de los iniciales
{
calcIni.ObtenerProduccion( nt, alf, ini, i );

if( !strlen( ini ) ) calcIni.CalcIniciales( i, buffIni );
}

Salida.open( SALIDA, ios::out );

if( Salida.fail() ) cout << "ERROR! 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 << "Simbolos Iniciales Calculados" << endl;
}
}

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 ERR_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 ] ) // obtener 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 ] ) // se obtienen terminales
{
if( buffer[ i ] != ' ' && buffer[ i ] != ',' ) Terminales[ j++ ] = buffer[ i ];

i++;
}

Terminales[ j ] = 0;

while( !fgrama.eof() ) // 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++ ) // obtiene el alfa
{
if( buffer[ i ] == ' ' ) continue;

alf[ j++ ] = buffer[ i ];
}

alf[ j ] = 0;

ind = this-> BuscarProduccion( Nt ); // busca una produccion

if( ind != ERR_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 != ERR_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 ERR_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 ERR_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 ERR_NO_ENCONTRADO;
}

int CIniciales::ModificarProduccion( const char* Nterm, const char* alfa, const char* Inicial, int indice )
{
if( indice < 0 || indice > this-> ultimaProd ) return ERR_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 ERR_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 ERR_FUERA_DE_RANGO;

strcpy( Nterm, this-> prod[ indice ].Nterminal );
strcpy( alfa, this-> prod[ indice ].Alfa );
strcpy( Inicial, this-> prod[ indice ].inicial );

return indice;
}

Archivo 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 ERR_ASIGNACION_DE_MEMORIA -1
#define NOABRE -2
#define ERR_NO_ENCONTRADO -3
#define ERR_FUERA_DE_RANGO -4


typedef struct _PRODUCCION
{
char *Nterminal;
char *Alfa;
char *inicial;

} PRODUCCION;

// clase para el manejo de archivo
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

Iniciales Calculados
E -> (,i
E' -> +,#
T -> (,i
T' -> *,#
F -> (,i


Resultado en Consola

Compilador Libro

Principal
#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;
}
ANALIZLEX
#include
#include
#include "global.h"
#include

int valcomplex = NINGUNO;
int numlinea = 1;
extern entrada tablasimb[MAXSIMB];

char buflex[TAMBUFF];

int analex()
{
int t;
while(1) {
t = getchar();
if(t == ' ' || t == '\t')
;
else if (t == '\n')
numlinea = numlinea + 1;
else if (isdigit(t)) {
ungetc(t, stdin);
scanf("%d", &valcomplex);
return NUM;
}
else if (isalpha(t)) {
int p, b=0;
while (isalnum(t)) {
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;
}
}
}
ANALIZSINT
#include
#include
#include
#include "global.h"

extern int valcomplex;
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
#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
#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 */
}

Inic
#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);
}

Simbolos
#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;
}

Global
#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);

Automata de Pila

Gramatica


Tabla del automata de pila

Gramatica, filosofia y objetivos

GRAMATICA

FILOSOFIA
Este lenguaje de programación cuenta con la filosofía de mas sencillo y entendible.

OBJETIVO
El objetivo primordial es la fácil comprensión de la programación mediante un lenguaje mas sencillo.

Programa Sentencias
Sentencias  Sentencias | ListaSentencias
ListaSentencias  ciclo | mientras | si-no | menu | declara_var | opciones | Ecu

ciclo ciclo Par_abre decl_var Ecu Par_cierra abre_llave Sentencias Cierra_llave

mientras  mientras Par_abre Condicion Par_cierra abre_llave Sentencias Cierra_llave

Si-no si-no Par_abre Condicion Par_cierra abre_llave Sentencias Cierra_llave

menu  menu Par_abre id Par_cierra abre_llave Lista_opcion cierra_llave |
 menu Par_abre id Par_cierra abre_llave Lista_opcion Cierra_llave

Lista_opcion  opcion | Lista_opcion
opcion  opcion Const Pp Sentencias Fin_opcion
declara_var  var id Fin_cad | var id Operador_Asig Const Fin_cad

Simbolos
‘(’  Par_abre
‘)’  Par_cierra
‘{’  abre_llave
‘}’  cierra_llave

Operadores Aritmeticos
‘:’  Pp
+  Op_mas
-  Op_menos
/  Op_div
*  Op_por

Operadores Logicos
<  Oper_maq
>  Oper_meq