Automata de Pila

Gramatica
E E+T|T
T T*F|F
F (E)|a

Analizador Lexico,Sintactico y Semantico

#include
#include
#include
#include
#include


int funcion_evaluar_cadena(char cadena[20]);
int funcion_eva_line(int envio_digital[10],int tam_digi);

char palabras_reservadas[9][10]=
{

{'i','f'},//token 1
{'w','h','i','l','e'},//token 2
{'p','r','i','n','t'},//token 3
{'s','t','r'},//token4
{'e','l','s','e'},// token 5
{'r','e','t','u','r','n'},// token 6
{'i','n','t'},// token 7
{'b','o','o','l'},// token 8
{'d','e','f'},// token 9
};

int tabla_transiones_identificadores[3][2]=
{
{0, 0},
{2, 0},
{2, 2},

};
int 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},
};
int tabla_transiones_inicio_if[6][4]=
{
{0, 0, 0, 0},
{2, 0, 0, 0},
{0, 3, 3, 0},
{0, 0, 0, 4},
{0, 5, 5, 0},
{0, 0, 0, 0},


};
int tabla_transiones_inicio_while[6][4]=
{
{0, 0, 0, 0},
{2, 0, 0, 0},
{0, 3, 3, 0},
{0, 0, 0, 4},
{0, 5, 5, 0},
{0, 0, 0, 0},


};
int tabla_transiones_programa[6][6]=
{
{0, 0, 0, 0, 0, 0},
{0, 0, 0, 0, 0, 2},
{3, 4, 2, 2, 2, 0},
{3, 4, 3, 3, 3, 0},
{3, 4, 4, 4, 4, 0},
{0, 0, 0, 0, 0, 0},
};

int tabla_transiones_inicio_print[4][3]=
{
{0, 0, 0},
{2, 0, 0},
{0, 3, 3},
{0, 0, 0},


};



int tabla_transiones_inicio_mat[7][4]=
{
{0, 0, 0, 0},
{2, 0, 0, 0},
{0, 3, 0, 0},
{4, 0, 4, 0},
{0, 0, 0, 5},
{6, 0, 6, 0},
{0, 0, 0, 0},

};




char def[50][20];
int into[50];
int gol=0;
int gil=0;
int cola[10];
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 igual='=';

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

char cadena[50][20];

int codigo_digital[100];
int num_tokens=0;
int linea_val[30];
void main()
{

cout<<" ANALISIS LEXICO "<
cout<<"palabra____________tipo________________linea"< ifstream archivo("cod.txt", ios::in);
char var;
int x=0,y=0;
int tok=0;
int linea=1;
int linea_q[50];
int tama_digi=0;
int envio_digital[10];
while(!archivo.eof())
{
archivo.get(var);
if(var==' '||var=='\n')
{
x=0;
cout<<" ";
codigo_digital[num_tokens]=funcion_evaluar_cadena(cadena[y]);

cout<<" "< linea_q[y]=linea;
num_tokens++;
if(var=='\n')
{
linea++;
codigo_digital[num_tokens]=50;
num_tokens++;



}


y++;

}
else
{

cadena[y][x]=var;
cout< x++;
}
}
cout< cout<<"Presiona enter para continuar";


cout< getch();
system("cls");
cout<
cout<<" ANALISIS SINTACTICO "< int lin=0;
for(int f=0; f{

if(codigo_digital[f]==50){
cout<<"linea "< linea_val[lin]=funcion_eva_line(envio_digital,tama_digi);
tama_digi=0;
cout< lin++;
}
else
{

envio_digital[tama_digi]=codigo_digital[f];
tama_digi++;

}
}
cout<<" Variables"<





for(int w=0; w{
if(into[w]==1||into[w]==2)
{
cout<<" la variable ";
int rom=strlen(def[w]);
for(int e=0; e {
cout< }
cout<<" El tipo ";
cout< cout< }
}

}



//
int funcion_evaluar_cadena(char cadena[20])
{
int t=strlen(cadena);
int sim=0;
int x, y;




if(cadena[0]=='"'&&cadena[t-1]=='"')
{
cout<<"cadena ";
return 14;
}
if(t==1)
{
char var=cadena[0];
char var1=cadena[0];
char var2=cadena[0];
if(cadena[0]=='=')
{
cout<<"igual ";
return 15;
}

if(cadena[0]=='(')
{
cout<<"parentesis A";
return 30;
}
if(cadena[0]==')')
{
cout<<"parentesis B";
return 31;
}
if(cadena[0]==',')
{
cout<<"coma";
return 32;
}





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

if(operadores_matematicos[x]==var)
{
cout<<"operador matematicos ";
return 16;


}

}



}
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<<"numero";
return 17;
}




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

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

if(sim==ta)
{
cout<<"palabra reservada";
if(x==0||x==1||x==4||x==5||x==6||x==7)
{
cout<<" Compatible con lenguaje 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)
{

for(int h=0; h {
def[gil][h]=cadena[h];

}

gil++;





return 18;
}
//
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];
}

}

if(apunta==2||apunta==3)
{
cout<<"operador logico ";
return 19;

}


cout<<"¡no es token! ";

return 0;
}


int funcion_eva_line(int envio_digital[10],int tam_digi)
{


int valores1[4]={1,18,17,19};
int inicia=1;
int err=0;
for(int c=0; c {
for(int g=0; g<4; g++)
{
if(envio_digital[c]==valores1[g])
{
inicia=tabla_transiones_inicio_if[inicia][g];
}

}
}



/*if(tam_digi==2)
{
if(envio_digital[0]==7||envio_digital[0]==8||envio_digital[0]==4)
{
if(envio_digital[1]==18)
{
cout<<"<<<--------------------- Es una declaracion de variable"< return 5;

}
}
}*/
if(tam_digi==2)
{
if(envio_digital[0]==7)
if(envio_digital[1]==18)
{
cout<<"<<<--------------------- Es una variable entera"< into[gol]=2;
gol++;
return 5;
}
}
if(tam_digi==2)
{
if(envio_digital[0]==4)
if(envio_digital[1]==18)
{
cout<<"<<<--------------------- Es una variable de cadena"<
into[gol]=1;
gol++;



return 5;
}
}

if(tam_digi==6)
{
if(envio_digital[0]==9)
{
if(envio_digital[1]==18)
{
if(envio_digital[2]==30)
{
if(envio_digital[3]==7||envio_digital[3]==8||envio_digital[3]==4)
{
if(envio_digital[4]==18)
{
if(envio_digital[5]==31)
{
cout<<"<<<--------------------- Es una funcion"< return 8;

}
}

}

}
}

}
}

if(inicia==5)
{
cout<<"<<<--------------------- Es un inicio de if"< return 1;
}
err=0;
inicia=1;
int valores2[4]={2,17,18,19};
//////////
for(int p=0; p {
for(int g=0; g<4; g++)
{
if(envio_digital[p]==valores2[g])
inicia=tabla_transiones_inicio_while[inicia][g];
else
err++;
}
if(err==4)
{
inicia=0;
}
err=0;
}
if(inicia==5)
{
cout<<"<<<--------------------- Es un inicio de while"< return 2;
}
//////////////////////////
err=0;
inicia=1;
int valores3[3]={3,17,18};
//////////
for(int r=0; r {
for(int g=0; g<3; g++)
{
if(envio_digital[r]==valores3[g])
inicia=tabla_transiones_inicio_print[inicia][g];
else
err++;
}
if(err==3)
{
inicia=0;
}
err=0;
}
if(inicia==3)
{
cout<<"<<<--------------------- Es una sentencia print "< return 3;
}
err=0;
inicia=1;
int valores6[4]={18,15,17,16};
//////////
for(int q=0; q {
for(int g=0; g<4; g++)
{
if(envio_digital[q]==valores6[g])
inicia=tabla_transiones_inicio_mat[inicia][g];
else
err++;
}
if(err==4)
{
inicia=0;
}
err=0;
}
if(inicia==6)
{
cout<<"<<<--------------------- Es una sentencia matematica"< return 6;
}
err=0;
inicia=1;
int valores4[3]={9,17,18};
//////////
for(int w=0; w {
for(int g=0; g<3; g++)
{
if(envio_digital[w]==valores4[g])
inicia=tabla_transiones_inicio_print[inicia][g];
else
err++;
}
if(err==3)
{
inicia=0;
}
err=0;
}
if(inicia==3)
{

cout<<"<<<--------------------- Es un return"< return 4;
}

cout<<"<<<--------------------- No se reconoce";
return 0;

}

Filtro Doxygen

#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("Pyth.txt");
// cout<<"sin parametros"< }
fstream a;
a.open("Pyth2.txt",ios::out);

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

//primero vemos si existe nuestro archivo
if(!entrada.fail())
{
a<<"class "<<"Python"< 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;
}

Calculo de Seguidores

//C.Gramatica.h//
#ifndef GRAMATICA_H
#define GRAMATICA_H
#include
#include
using namespace std;
typedef struct _Gramatica
{ char* NT;
char* Alfa;
char* Iniciales;
char* Seguidres;}
Gramatical;
class CGramatica
{ private: int cantProds;
Gramatical *Prod;
public:
int CmpTerms(const char next);
char* Terminales;
CGramatica();
~CGramatica();
void setNT(const int ind,const char* nNT);
void setAlfa(const int ind, const char* nAlfa);
void setIniciales(const int ind, const char* nInis);
void setSeguidores(const int ind, const char* nSeg);
char* getNoterminal(const int ind);
char* getAlfa(const int ind);
char* getIniciales(const int ind);
char* getSeguidores(const int ind);
int getCantProds(); void setCantProds();
void CargarGramatica();
void agregarProduccion(const char* nNT,const char* nAlfa,const char* nInis,const char* nSeg);
void CargarIniciales();
void CalcularSeguidores();
void CalcularPorNT(int indm, char* Slista);
int BuscarProduccion(const char* nNT);};
#endif
//CalcSeguidores.cpp//
#include "CGramatica.h"
#include "CGramatica.cpp"
#include
#include
using namespace std;
int main(int argc, char** argv)
{ CGramatica ObjCarga;
ObjCarga.CargarGramatica();
ObjCarga.CargarIniciales();
ObjCarga.CalcularSeguidores();
fstream b;
b.open("Seguidores.txt",ios::out);
for(int m=0;m<=ObjCarga.getCantProds();m++)
{ b< char SF[100];SF[0]=0;
for(int k=0;k{ char Ss[2];
bool flag=false;
char Sg[100];
Sg[0]=0;
strcat(Sg,ObjCarga.getSeguidores(m));
for(int n=0;n{ if(Sg[n]==Sg[k]){flag=true;}
} if(flag==false)
{ Ss[0]=Sg[k];
Ss[1]=0;
strcat(SF,Ss);
strcat(SF,",");
} }
cout<<"\nSF="< cout<<"SFfin"< if(SF[strlen(SF)-1]==',')
{ SF[strlen(SF)-1]=' ';
cout<<"SFfin"< } b<if(m!=ObjCarga.getCantProds())
{ b<<"\n"; } }
return 0;}
//CGramatica.cpp//
#include "CGramatica.h"
#include
CGramatica::CGramatica()
{ this->Prod=NULL; this->cantProds=-1;}
CGramatica::~CGramatica()
{ int i=this->cantProds;
if(this->Prod) { for(; i>=0;i--)
{ delete[] this->Prod[i].NT;
delete[] this->Prod[i].Alfa;
delete[] this->Prod[i].Iniciales;
delete[] this->Prod[i].Seguidres; }
delete[] this->Prod; }}
void CGramatica::setNT(const int ind,const char* nNT)
{ delete[] this->Prod[ind].NT; this->Prod[ind].NT = new char [ strlen( nNT ) + 1 ]; strcpy(this->Prod[ind].NT,nNT);}
void CGramatica::setAlfa(const int ind, const char* nAlfa){ delete[] this->Prod[ind].Alfa; this->Prod[ind].Alfa = new char [ strlen( nAlfa ) + 1 ]; strcpy(this->Prod[ind].Alfa,nAlfa);}void CGramatica::setIniciales(const int ind, const char* nInis){
delete[] this->Prod[ind].Iniciales; this->Prod[ind].Iniciales = new char [ strlen( nInis ) + 1 ];
strcpy(this->Prod[ind].Iniciales,nInis);}
void CGramatica::setSeguidores(const int ind, const char* nSeg){
char* temp; int t=strlen(this->Prod[ind].Seguidres)+1; temp = new char [strlen( nSeg ) + t ]; strcpy(temp,this->Prod[ind].Seguidres);
delete[] this->Prod[ind].Seguidres;
strcat(temp,nSeg);
this->Prod[ind].Seguidres = new char [ strlen( temp ) + 1 ]; strcpy(this->Prod[ind].Seguidres,temp);

}
void CGramatica::setCantProds(){ this->cantProds++;}
char* CGramatica::getNoterminal(const int ind){ return this->Prod[ind].NT;}char* CGramatica::getAlfa(const int ind){ return this->Prod[ind].Alfa;}
char* CGramatica::getIniciales(const int ind){ return this->Prod[ind].Iniciales;}char* CGramatica::getSeguidores(const int ind){ return this->Prod[ind].Seguidres;}
int CGramatica::getCantProds(){ return this->cantProds;}
void CGramatica::CargarGramatica(){ char buffer[512];
char NT[20];
char Alfa[512];
int i=0;
int j=0;
int k=0;
fstream a;
a.open("Gramatica.txt", ios::in);
a.getline(buffer,512);
cout<a.getline(buffer,512);
for(i=0;buffer[i]!='=';i++){} i++;
char Terms[30];
for(j=0;buffer[i];i++) { if(buffer[i]==','buffer[i]==' '){continue;}
else { Terms[j]=buffer[i]; j++; } } Terms[j]=0; this->Terminales=new char[strlen(Terms)+1]; strcpy(this->Terminales,Terms);
cout<<"\nTERMINALES"<Terminales<<"\n";
cout< a.getline(buffer,512); for( j=0, i=0; buffer[ i ]; i++ ) { if( buffer[ i ] == ' ' ) continue;
if( buffer[ i ] != '-' && buffer[ i+1 ] != '>' )
{ NT[ j ] = buffer[ i ];
j++;
continue;
}
else
{ NT[ j ] = 0;
i += 2;
break; } }
for(j=0;buffer[i];i++) { if(buffer[i]==' ') continue;
Alfa[j]=buffer[i];
j++;
}
Alfa[j]=0;
cout<<"NNTT="<int oks=this->BuscarProduccion(NT);
if(oks>=0) { cout<<"%%%%%";
char tempA[50];
strcpy(tempA,this->Prod[oks].Alfa);
strcat(tempA,",");
strcat(tempA,Alfa);
delete[] this->Prod[oks].Alfa; this->Prod[oks].Alfa = new char [strlen(tempA) + 1];
strcpy(this->Prod[oks].Alfa,tempA); }
else { cout<<":("; char n[2];n[0]=0;
this->agregarProduccion(NT,Alfa,"",n); } } a.close(); cout<<"!";
cout<<"\nTERMINÓ LECTURA DE GRAMATICA\n"; }void CGramatica::agregarProduccion(const char* nNT, const char* nAlfa, const char* nInis,const char* nSeg){ cout<<"AGREGAR PROD PARA"< Gramatical *temporal; this->cantProds++; i=0; temporal = new Gramatical[ (this->cantProds) + 1 ];
for( ; i <>cantProds ; i++) { temporal[i].NT = this->Prod[i].NT; temporal[i].Alfa = this->Prod[i].Alfa; temporal[i].Iniciales = this->Prod[i].Iniciales; temporal[i].Seguidres = this->Prod[i].Seguidres; }
delete[] this->Prod;
temporal[ i ].NT = new char[ strlen( nNT ) +1 ];
temporal[ i ].Alfa = new char[ strlen( nAlfa ) +1 ];
temporal[ i ].Iniciales = new char[ strlen( nInis ) +1 ];
temporal[ i ].Seguidres = new char[ strlen( nSeg ) +1 ];
strcpy(temporal[i].NT,nNT);
strcpy(temporal[i].Alfa,nAlfa);
strcpy(temporal[i].Seguidres,nSeg);
strcpy(temporal[i].Iniciales,nInis);
this->Prod = temporal;}
void CGramatica::CargarIniciales(){ fstream In; In.open("Iniciales.txt",ios::in); if(In.fail()) {cout<<"No se pudo abrir el archivo de Iniciales\n";} char buffer[512]; char NT[20]; char Inis[100]; int i=0,j=0,k=0; while(!In.eof()) { In.getline(buffer,512); for(i=0,j=0;buffer[ i ];i++) { if(buffer[ i ]==' ') continue; if(buffer[ i ]!='=') { NT[j]=buffer[ i ];
j++;
continue; }
else { NT[j]=0; i++; break; }
} int ind = this->BuscarProduccion(NT);
if(ind!=-2) { for(j=0;buffer[i];i++) { if(buffer[i]==' 'buffer[i]==',') {continue;} else { Inis[j]=buffer[i]; j++;
} } Inis[j]=0; }
else { cout<<"\nError: No se encontró el elemento en las estructuras\n"; return; } this->setIniciales(ind,Inis);
} for(int m=0;m<=this->cantProds;m++) { cout<<"\nPos"<Prod[m].NT; cout<<"\nAlfa="<Prod[m].Alfa; cout<<"\nIniciales"<Prod[m].Iniciales; } In.close();}int CGramatica::BuscarProduccion(const char* nNT){ int i=0; while(i<=this->cantProds) { if(strcmp(this->Prod[i].NT,nNT)==0){ return i;} i++; }
return -2;}void CGramatica::CalcularSeguidores(){ int i=0; char Seguis[50];
for(;i<=this->cantProds;i++) { cout<<"\nMANDE";
if(strlen(this->Prod[i].Seguidres)==0){CalcularPorNT(i,Seguis);} }}
void CGramatica::CalcularPorNT(int indice, char* Slista){
int tamA=0,ind=0; char p[100]="";
char SAct[100];SAct[0]=0; while(ind<=this->cantProds) { cout<<"\nEntre a Calcular\n"; cout<Prod[indice].NT;
tamA=strlen(this->Prod[ind].Alfa);
char tempA [3]; char next[3];
for(int i=0,j=0,k=0;iProd[ind].Alfa[i]; cout<<"\nFOR-"; tempA[j]=this->Prod[ind].Alfa[i]; j++; tempA[j]=0;
cout<<"\n----"< int oks=this->CmpTerms(tempA[0]); if(oks!=-1) { cout<<"\nSi es terminal y se brinca";
tempA[0]=0;tempA[1]=0;tempA[2]=0;
j=0; continue; } else { cout<<"\n"< if(this->Prod[ind].Alfa[i+1]==39) { cout<<"\nAPOSTROFE"; i++;tempA[j=39;j++;tempA[j]=0;
} else {tempA[j]=0;j++;}
cout<<"\nTEMPA"<Prod[indice].NT;
if(strcmp(this->Prod[indice].NT,tempA)==0) { cout<<"Es el buscado"; } else {cout<<"\nNO ES EL BUSCADO";j=0;continue;}
if((!this->Prod[ind].Alfa[i+1])(this->Prod[ind].Alfa[i+1]==',')) { cout<<"\n"< cout<<"\nCOMO ES FINAL COMPARA CON="<getNoterminal(ind);
cout<<"\nalfa[i]="<Prod[ind].Alfa[i]<Prod[ind].Alfa[i+1]; i
f(strcmp(tempA,this->getNoterminal(ind==0) { cout<<"\nIGUALES";
j=0;
continue; }
else{cout<<"\nDIFERENTES";}
if(strlen(this->Prod[ind].Seguidres)==0) { cout<<"\nNO SE HAN CALCULADO SEGUIDORES PARA"<Prod[ind].NT;
this->CalcularPorNT(ind,SAct); strcat( SAct, Slista );
k = strlen( Slista ); }
else { cout<<"\n Como estan calculados, SE ANADEN A Slista";
strcat(SAct,this->Prod[ind].Seguidres); cout<<"SActual:"< cout<<"\nNEXT="<Prod[ind].Alfa[i+1]; next[0]=this->Prod[ind].Alfa[i+1];i++; next[1]=0;
cout<<"\n=NEXT="< cout<<"\n"<Terminales<<"\n";
int ind2=this->CmpTerms(next[0]); cout<<"\nIND2"<cout<<"\n"< i++; cout<<"Checo a ver si es 39="<Prod[ind].Alfa[i]<<"\\"; if(this->Prod[ind].Alfa[i]==39) { next[1]=this->Prod[ind].Alfa[i++]; next[2]=0; } else { next[1]=0; } int ok1=this->BuscarProduccion(next); cout<<"\nOK1="<Prod[ok1].Iniciales); cout<<"Next="<Prod[ok1].Iniciales);t++) {
if(this->Prod[ok1].Iniciales[t]=='#') { vac=true; break; } } if(vac==true) { cout<<"\nSI TENIA VACIO EN INCIALES"; if(strlen(this->Prod[ind].Seguidres)==0) { cout<<"\nNO SE HAN CALCULADO SEGUIDORES PARA"<Prod[ind].NT; this->CalcularPorNT(ind,SAct); strcat( SAct, Slista ); k = strlen( Slista ); } else { strcat(SAct,this->Prod[ind].Seguidres); cout<<"SActual:"< } } } } } ind++; }
cout<<"IND"<cout<<"SEGUIS RESCATADOS"<char SF[100];for(int h=0,g=0;SAct[h];h++){ if(SAct[h]=='#') continue;
SF[g]=SAct[h];g++;}SF[g]=0;
this->setSeguidores(indice,SF);

strcpy( Slista, SF );

}int CGramatica::CmpTerms(const char next){ char* Ts; Ts=this->Terminales; for(int s=0;sTerminales);s++) {
if(Ts[s]==next){return s;} } return -1;}

Compilador libro

//principal.cpp//

#include "global.h"

main(){

inic();

analsint();

exit(0);}

//global.h//

#include

#include

#define TAMBUFF 128

#define ninguno -1

#define FDC '\0'

#define NUM 256

#define DIV 257

#define MOD 258

#define ID 259

#define FIN 260int valcomplex;int numlinea;

struct entrada{ char *aplex; int complex;};

struct entrada tablasimb[];

//analizlex.cpp//

#include "global.h"

char buflex [TAMBUFF];

int numlinea=1;

int valcomplex=NINGUNO;

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

cin>>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 del 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; }}}

//emisor.cpp//

#include "global.h"

emite(t,tval)int t=0,tval=0;

{

switch(t)

{ case '+': case'-': case'*': case'/': printf("%c\n",t);

break;

case DIV: printf("DIV\n");

break;

case MOD: printf("MOD\N");

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.cpp//

#include "global.h"

char *m;

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

exit(1);
}

//simbolos.cpp//

#include"global.h"

#define MAXLEX 999

#define MAXSIMB 100char lexemas[MAXLEX];

int ultcar=-1;struct entrada tablasimb[MAXSIMB];

int ultent=0;int busca(s)char s[];

{ int p;

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

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

return p;

return 0;}

int inserta(s,clex)char s[];

int clex;{

int lon;

lon=strlen(s);

if(ultent + 1 >= MAXSIMB) error("tabla de simbolos llena");

if(ultcar + lon + 1>= MAXLEX) error("matriz de lexemas 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;}

//inic.cpp//

#include "global.h"

struct entrada palsclave [] ={ "div", DIV, "mod", MOD, 0, 0};

inic(){ struct entrada *p;

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

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

Gramatica de lenguaje

Objetivo:

Programas útiles y eficientes con un mínimo de código.

Filosofía:

Creación de programas entendibles y legibles para una mayor comprensión mediante este lenguaje de programación.

GRAMATICA EN LENGUAJE PMGC

Gramatica en Lenguaje PMGC--
program->entrada
entrada->lista_declaraciones
lista_declaraciones→variables lista_variables
NAME-> NAME (Texto_escrito) NAME (Texto_copiado)
SI-> SI (Condicion) SI (Sentencia) SI (Lista_sentencias)
INTO-> INTO(Texto_escrito) INTO(Mete_Valor)
IDEN_X -> Sentencia Condicion
LETRA-> a + b + c ....z + A + B + C .....Z
NUMERO-> 0 + 1 + 2 + 3 ....9
OP_MAT-> + - * /
MUESTRA-> MUESTRA (INTO)
CLASE -> CLASE (INTO LETRA NUMERO)
FUNCTION-> IDEN_X {Sentencia Lista_Sentencias Condicion}

Programacion de Sistemas

Lenguaje Artificial;

Definicion:
Un lenguaje formal es un lenguaje artificial que esta formado por símbolos y formulas que tiene como objetivo fundamental formalizar la programación de computadoras o representar simbólicamente un conocimiento.

Caracteristicas;

Se han desarrollado como un medio para formalizar matemáticamente una teoría.
Su sintaxis es capaz de definir oraciones rigurosamente definidas.
Constituyen un poderoso instrumento para la investigación y el procesamiento del Lenguaje Natural por computadora.
Un lenguaje de programación es un lenguaje Artificial usado para escribir instrucciones que pueden ser traducidas a lenguaje maquina y ejecutadas en una computadora.