angelucha84
16 de Abril del 2006

Hola a todos tengo analizadores lexicos en C para kien los necesite escribanme a mi correo
Y kisisera k me ayudaran con unos programillas en C++ se los voy a agradecer mucho
mi e-mail es
[email protected]

claudug
16 de Abril del 2006

holas me puedes enviar los analizadores gracias

Jumior
16 de Abril del 2006

me lo podrias enviar a mi correo porfa [email protected]

cladug
16 de Abril del 2006

hola me los puedes enviar por favor

anmavini
16 de Abril del 2006

Me gustaria que me enviara los analizadores lexivos. Gracias!"!

r
16 de Abril del 2006

Aqui dejo uno ojala y sea de ayuda

# include <iostream.h>
# include <conio.h>
# include <string.h>
# include <stdio.h>
# include <io.h>
# include <ctype.h>
# define max 20

typedef char cadena[80];

typedef enum{verdadero,falso} bandera;

typedef enum{letra, guionBajo, digito, amperson, or, aritmetico,
igual, relacional, menos, mas, negacion, letraHexa, e, punto,
h, FDC, otros} entradas;

typedef enum{m=-2, ok, L0, L1, L2, L3, L4, L5, L6, L7, L8, L9,
L10, L11, L12, L13, L14, L15, L16, L17, L18, L19,
L20, L21, L22, L23, L24} edo_automata;

typedef enum{identificador, entero, Oparitmetico, real, Oprelacional,
logico, hexadecimal, exponencial} resultados;

edo_automata transicion[25][18]={
{L1, L1, L15, L12, L13, L6, L7, L9, L3, L11, L19, L1, L1, L4, L1, m, m, L6},
{L1, L1, L1, m, m, m, m, m, m, m, m, L1, L1, m, L1, ok, m, m},
{m, m, L2, m, m, m, m, m, m, m, m, m, L20, L4, m, ok, m, m},
{m, m, L2, m, m, m, L8, m, L8, m, m, m, m, L4, m, ok, m, m},
{m, m, L5, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m},
{m, m, L5, m, m, m, m, m, m, m, m, m, L20, m, m, ok, m, m},
{m, m, m, m, m, m, L8, m, m, m, m, m, m, m, m, ok, m, m},
{m, m, m, m, m, m, L10, m, m, m, m, m, m, m, m, ok, m, m},
{m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, ok, m},
{m, m, m, m, m, m, L10, m, m, m, m, m, m, m, m, ok, m, m},
{m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, ok, m, m},
{m, m, L2, m, m, m, L8, m, m, L8, m, m, m, L4, m, ok, m, m},
{m, m, m, L14, m, m, m, m, m, m, m, m, m, m, m, m, m, m},
{m, m, m, m, L14, m, m, m, m, m, m, m, m, m, m, m, m, m},
{m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, ok, m, m},
{m, m, L15, m, m, m, m, m, m, m, m, L17, L16, L4, L18, ok, m, m},
{m, m, L22, m, m, m, m, m, L23, L23, m, L17, L17, m, L18, m, m, m},
{m, m, L17, m, m, m, m, m, m, m, m, L17, L17, m, L18, m, m, m},
{m, m, m, m, m, m, m, m, m, m, m, m, m, m, m, ok, m, m},
{m, m, m, m, m, m, L10, m, m, m, m, m, m, m, m, ok, m, m},
{m, m, L21, m, m, m, m, m, L23, L23, m, m, m, m, m, m, m, m},
{m, m, L21, m, m, m, m, m, m, m, m, m, m, m, m, ok, m, m},
{m, m, L22, m, m, m, m, m, m, m, m, L17, L17, m, L18, ok, m, m},
{m, m, L24, m, m, m, m, m, m, m, m, m, m, m, m, m, m, m},
{m, m, L24, m, m, m, m, m, m, m, m, m, m, m, m, ok, m, m}};

resultados edos(edo_automata edo);
bandera automata(cadena cad, edo_automata &edo);
bandera Reservada(cadena cad);
bandera logicos(char aux);
bandera relacionales(char aux);
bandera aritmeticos(char aux);
bandera delimitador(char aux);
entradas dicc(char letra2);

void analiza(cadena cad);


char *aplin;
int apid;
int i;
int cont=0;
int id=0,ent=0,arit=0,rel=0,rea=0,exp=0,reserva=0,err=0,delim=0;
int encontrado,x=0,salir;
char tablaid[50][50];

void main()
{
clrscr();
textbackground(BLUE);
textcolor(YELLOW);
cadena linea;
cadena cad;
char lex[max],resp;
int u;
do{
clrscr();
textbackground(BLUE);
textcolor(YELLOW);
printf("tnnntCadena a Analizart Analisisnnt");
i=0;
for(u=0; linea[u]!=''; u++)
linea[u]='';

for(u=0; lex[u]!=''; u++)
lex[u]='';

gets(linea);
while((linea[i]!='')&&(linea[i]!=';'))
{
lex[i]= (linea[i]);
i++;
}
lex[i]='';
aplin=lex;
while(*aplin!='x0' && *aplin!=';' && *aplin!='')
{
i=0;
if(logicos(*aplin)==verdadero || relacionales(*aplin)==verdadero || aritmeticos(*aplin)==verdadero || *aplin=='t' || *aplin=='x0' || delimitador(*aplin)==verdadero || *aplin==' ')
{
if(logicos(*aplin)==verdadero)
{
printf(" %s .... es un operador logicon",&*aplin);

}
if(relacionales(*aplin)==verdadero)
{
printf(" %s .... es un operador relacionaln",&*aplin);

}
if(delimitador(*aplin)==verdadero)
{
printf(" %s ... es delimitadorn",&*aplin);

}
if(aritmeticos(*aplin)==verdadero)
{
printf(" %s ... es un operador aritmeticon",&*aplin);

}
*aplin++;
}
else
{
salir=0;encontrado=0;
do{
cad[i]=*aplin;
*aplin++;
i++;
}while(relacionales(*aplin)==falso && aritmeticos(*aplin)==falso && *aplin!='x0' && delimitador(*aplin)==falso && *aplin!='' && *aplin!=' ');
cad[i]='';
x=0;
analiza(cad);
if(relacionales(*aplin)==verdadero)
{
printf(" %s ... es un operador relacionaln",&*aplin);

if(*aplin!='x0')
*aplin++;
}
if(delimitador(*aplin)==verdadero)
{
printf(" %s ... es un delimitadorn",&*aplin);

if(*aplin!='x0')
*aplin++;
}
if(aritmeticos(*aplin)==verdadero)
{
printf(" %s ... es un operador aritmeticon",&*aplin);

if(*aplin!='x0')
*aplin++;
}
}
for(int j=0; cad[j]!=''; j++)
cad[j]='';
}


printf("nnnnnnnn Otra l¡nea [s/n]:nt");
resp=getch();

}while(resp!='n');
getch();
}

bandera Reservada(cadena cad)
{
cadena lista[]={"asm","auto","bool","break","case","catch","cdcl","char","class","const","const_cast", "continue" ,"default" , "delete",
"do", "double", "dynamic_cast","else", "enum","explicit","export","extern","false","float","for", "friend",
"goto","if","inline","int","long","mutable","namespace","new","operator","printf","private","protected",
"public","register","reinterpret_cast","return","scanf","short","signed","sizeof","static","static_cast","struct","switch",
"template","this","throw","true","try","typedef","typeid","typename","union","unsigned","using","virtual",
"void","volatile","wchart","while"};
for(i=0; i<77; i++)
if (strcmp(lista[i],cad)==0)
return verdadero;
return falso;
}
bandera logicos(char aux)
{
if(aux=='&' || aux=='|')
{
return verdadero;
}
return falso;
}

bandera relacionales(char aux)
{
if(aux=='<' || aux=='>'||aux=='!' || aux==char(34) || aux==char(39) )
{
return verdadero;
}
return falso;
}

bandera delimitador(char aux)
{
if(aux==',' || aux==';' || aux=='[' || aux==']' || aux=='(' || aux==')' || aux==':' || aux=='{' || aux=='}')
{
return verdadero;
}
return falso;
}

bandera aritmeticos(char aux)
{
if(aux=='+'|| aux=='-' || aux=='*' || aux=='/' || aux=='=' || aux=='#')
{
return verdadero;
}
return falso;
}

entradas dicc(char letra2)
{
switch(letra2)
{
case 'g':case 'i':case 'j':case 'k':case 'l':case 'm':
case 'n':case 'o':case 'p':case 'q':case 'r':case 's':
case 't':case 'u':case 'v':case 'w':case 'x':case 'y':
case 'z':case 'G':case 'I':case 'J':case 'K':case 'L':
case 'M':case 'N':case 'O':case 'P':case 'Q':case 'R':
case 'S':case 'T':case 'U':case 'V':case 'W':case 'X':
case 'Y':case 'Z':
return letra;

case '_':
return guionBajo;

case '0':case '1':case '2':case '3':case '4':case '5':
case '6':case '7':case '8':case '9':
return digito;
case '&':
return amperson;
case '|':
return or;
case '%':case '/':case '*':
return aritmetico;
case '=':
return igual;
case '<':case '>':
return relacional;
case '-':
return menos;
case '+':
return mas;
case '!':
return negacion;
case 'a':case 'b':case 'c':case 'd':case 'f':
case 'A':case 'B':case 'C':case 'D':case 'F':
return letraHexa;
case 'e':case 'E':
return e;
case '.':
return punto;
case 'h':case 'H':
return h;
case '':
return FDC;
default:
return otros;
}
}

resultados edos(edo_automata edo)
{
switch(edo)
{
case L1:
return identificador;
case L2:case L15:
return entero;
case L3:case L6:case L7:case L8:case L11:
return Oparitmetico;
case L5:
return real;
case L9:case L10:
return Oprelacional;
case L14:case L19:
return logico;
case L18:
return hexadecimal;
case L21:case L22:case L24:
return exponencial;
}
return entero;
}

bandera automata(cadena cad, edo_automata &edo)
{
int i=0;
edo_automata edo_anterior;
edo=L0;
entradas ent;
do{
ent=dicc(cad[i]);
edo_anterior=edo;
edo=transicion[edo][ent];
if (edo==m)
return falso;
i++;
}while(edo!=ok);
edo=edo_anterior;
return verdadero;
}

void analiza(cadena cad)
{
edo_automata edo;
resultados res;
if(Reservada(cad)==verdadero)
{

reserva++;
printf(" %s ... es una palabra reservadan",&*cad);
}
else
{
int encon=0;
if(automata(cad,edo)==verdadero)
{
res=edos(edo);
switch(res)
{
case identificador:
for(int k=0; k<apid; k++)
{
if(strcmp(cad,tablaid[k])==0)
{

printf(" %s ... es un identificadorn",&*cad);
k=apid;
encon=1;
}
}
if (encon==0)
{
strcpy(tablaid[apid],cad);

printf(" %s ... es un identificadorn",&*cad);
apid++;
}
break;

case entero:

printf(" %s ... es numero enteron",&*cad);
ent++;
break;

case Oparitmetico:

printf(" %s ... es un operador aritmeticon",&*cad);
arit++;
break;

case real:

printf(" %s ... es un numero realn",&*cad);
rea++;
break;

case Oprelacional:

printf(" %s ... es un operador relacionaln",&*cad);
rel++;
break;

case exponencial:
exp++;

printf(" %s ... es un numero exponencialn",&*cad);
break;

case hexadecimal:

printf(" %s ... es un numero hexadecimaln",&*cad);
break;
}
}
else
{
textcolor(RED);
err++;
printf(" %s ... es una cadena no validan",&*cad);
}
}
}

AnGeLuChA84
16 de Abril del 2006

Es mas facil k me manden un msj a mi correo y ya les contesto y les mando el analizador lexico y proximamente tambien voy a tener el sintactico solo tiempo al tiempo :D

mi correo es
[email protected]

Juan Carlos
16 de Abril del 2006

Hola.

Te agradeceria mucho si me pudieras enviar el analizador lexico te lo agradeceria mucho...

Adios
[email protected]