Universidad Autnoma Metropolitana Unidad Iztapalapa ___________________________________ COMPILADORES

Profr. Gilberto Chvez

Tarea #4
Diseo del Analizador Lexicogrfico.

Flores Vicente Flor Nallely

Fecha de Entrega Lunes, Junio 27 del 2011.

La codificacin del siguiente diseo fue implementada y compilada con:

Procesador: 2xIntel (R) Core(TM)2 Duo CPU T6600 @ 2.20 Ghz. Memoria RAM : 3 Gb Sistema Operativo: Ubuntu 10.04.2 LTS Kernel : Linux 2.6.32-32-generic (i686) Compilador: GNU C Compiler Version 4.4.3 (Ubuntu 4.4.3-4 Ubuntu5)

Gramtica Tipo 3 del Analizador Lexicogrfico Galex = {V,T,P,S} alex = {Todos los smbolos del teclado} V= {<uami>, <Funciones_Archivo>, <Init.c> , <Carga_Buffer> <Funciones_Smbolos>,
,

<Carga_Buffer1>,<Carga_Buffer2>,<ALEX>, <delimitadores>, <variables>,<nmeros>,<operadores>,<cadena>,<EOF>, <blanco>, <salto_linea> , <tab> , <llave>, <letra>, <smbolos_desconocidos>, <vaco>, <letra>, <num>,<guin_bajo>, <comilla>, <fin_comilla>}

T = {Todos los conjuntos de palabras, nmeros y/o caracteres que sean reconocidos por ALEX} P = <uami> S
<uami.c>

<uami>

<Funciones_Archivo> <Init.c> <Carga_Buffer>+<Funciones_Smbolos>

<Funciones_Archivo>

(Valida_Archivo)(Cambia_Nombre)(Cambia_Nombre2)(Crea_Copia)

<Init.c>

Inicia_Tabla

<Carga_Buffer> (<Carga_Buffer1><Carga_Buffer2>*(<ALEX>+(<Carga_Buffer1>*<ALEX>*<Carga_Buffer2>*))+

<Carga_Buffer1>

Carga_Buffer1

<Carga_Buffer2>

Carga_Buffer2

<ALEX>

(<delimitadores>|<variables>|<nmeros>|<operadores>|<cadena>)*|<EOF>

<delimitadores> (<blanco> | <salto_linea> | <tab> | <llave>(<letra>|<nmeros>|<smbolos_desconocidos>|<delimitadores>|<vaco>)*<salto_linea>)+

<variables>

<letra>(<letra>|<num>|<guin_bajo>)*

<nmeros>

<num><num>*

<operadores>

( < | > | = | ! )( = | <vaco>) | + | - | * | / | % | / | |( |) | &(&)

<cadena> <comilla> (<numero>|<letra>|<smbolos_desconocidos>|<delimitadores>|<operadores>)*<fin_comilla>

<EOF>

\0

<blanco>

\b

<salto_linea>

\n

<tab>

\t

<llave>

<letra>

{a, b, c, z, A, B, C, .., Z}

<nmeros>

{0, 1, 2, 3, 5, 6, 7, 8, 9}

<vaco>

<comilla>

<fin_comilla>

<guin_bajo>

<Simbolos_desconocidos -> {Todos aquellos que no pudieron ser reconocidos por ALEX}

Cdigo Fuente del Programa. global.h #include<stdio.h> #include<ctype.h> #include<stdlib.h> #include<string.h> #define NINGUNO -1 #define EOS '\0' #define ERROR 0 #define CORRECTO 1 #define MAX_PALABRA 999 #define MAX_SIMBOLOS 100 #define Tam_Buffer 50 /*Tamao del buffer*/

/*Definicin de las funciones en tabla_simbolos.c*/ int busca (char *s); char *almacena (char *s); int inserta (char *s, int tok); void put_token (int i , int new_token); int get_token (int i); char *get_system (int i); void imprime_simbolos (); void inicializa_tabla(); /*Definida en init.c*/ void funciones_archivo(char *s); int valida_archivo (char *s);

char buffer1[Tam_Buffer]; char buffer2 [Tam_Buffer]; char nombre1[40]; char nombre2[40];

int num_linea, n, x, aux, tokenval, i, j;

FILE *archivo, *archivo_tuplas;

/*Apuntador a nuestro archivo fuente*/

/*Definicin de la Estructura*/ struct entry { char *lexptr; /*Valor*/ int token; /*tipo*/ };

typedef struct entry tipo_tabla;

/*Ficheros Lexicograficos*/ /*Palabras Reservadas*/

#define PROGRAMA #define COMIENZA #define TERMINA #define HECHO

256 257 258 259

#define ASIGNACION 260 #define ID 261 262 263

#define NUM_ENT #define CADENA #define SI 264

#define ENTONCES #define OTRO #define MIENTRAS #define HAZ #define IMPRIME #define DUMP #define HALT #define REPITE #define HASTA #define PARA #define A #define LEE #define DIV #define MOD #define ESCRIBE 268 266

265

267

269 270 271 272 273 274

275 276 277 278 279

/*Fichas de tipos*/

#define REL_OP #define LT #define LE #define EQ 301 302 303

300

#define GE #define GT #define SUMA #define RESTA #define NE #define MULT #define OR #define AND #define MUL_OP #define ADD_OP

304 305 306 307 308 309 310 311 312 313

uami.c #include "global.h" int main (int argc, char* argv[]) { char *nom_fte; if (argc<2) printf("Error. Ingrese archivo fuente.\n"); else { if(valida_archivo(argv[1])== ERROR) printf("Error. Archivo fuente no vlido\n"); else { if ((archivo = fopen(argv[1], "rb"))==NULL) printf ("Error al abrir el archivo\n"); else { cambia_nombre(argv[1]); cambia_nombre2(argv[1]); crea_copia(argv[1]); archivo_tuplas = fopen(nombre1, "w");

inicializa_tabla();

do{ carga_buffer();

}while ( feof(archivo) == 0); } } fclose(archivo_tuplas); fclose(archivo); if(x==259) { printf("Numero de lneas: %d\n", num_linea); imprime_simbolos(); return 0; } } }

funciones_archivo.c

#include "global.h"

void cambia_nombre(char *s) { int tam, i; tam = strlen(s)-4;

for(i=0; i<tam; i++) nombre1[i] = *s++; strcat(nombre1, ".tpl"); }

void cambia_nombre2(char *s) { int tam, i; tam = strlen(s)-4; for(i=0; i<tam; i++) nombre2[i] = *s++; strcat(nombre2, ".err"); }

void crea_copia(char *s) { unsigned long tam_entrada,i; unsigned char c;

FILE *archivo_copia, *archivo_original; archivo_original = fopen(s, "rb"); archivo_copia = fopen(nombre2, "wb");

fseek(archivo_original,0,SEEK_END); tam_entrada = ftell(archivo_original); fseek(archivo_original,0,SEEK_SET);

for (i=0;i<tam_entrada;i++) { fscanf(archivo_original,"%c",&c); fprintf(archivo_copia,"%c",c); }

fclose(archivo_original); fclose(archivo_copia); }

int valida_archivo (char *s) { int tam_cadena; tam_cadena = strlen(s)-4; if (s[tam_cadena] == '.' && s[tam_cadena+1] == 'f' && s[tam_cadena+2] == 't' && s[tam_cadena+3] == 'e') return CORRECTO;

return ERROR; }

init.c

#include "global.h" tipo_tabla palabras_reservadas[] ={

"programa",

PROGRAMA,

"si", "entonces", "otro", "haz", "mientras", "comienza", "termina", "escribe", "imprime", "lee", "halt", "dump", "div", "mod", "repite", "hasta", "para", "a", "", 0, };

SI, ENTONCES, OTRO, HAZ, MIENTRAS, COMIENZA, TERMINA, ESCRIBE, IMPRIME, LEE, HALT, DUMP, DIV, MOD, REPITE, HASTA, PARA, A, CADENA, 0

void inicializa_tabla(){

tipo_tabla *p; for(p = palabras_reservadas; p->token; p++)

inserta(p->lexptr , p->token); }

lxico.c #include "global.h"

int aux =0; int h, q;

int analizador_lexico_grafico(char buffer[], int k, int *n)

{ int p, h, q,b; char buffer_lex [40]; char buffer_comentario[40];

if(isspace(buffer[*n]) || buffer[*n]=='{') { while(isspace(buffer[*n]) || buffer[*n]=='{') { if (buffer[*n]=='\n') { num_linea++; aux = 0; } if (buffer[*n]== '{') { /*Tira espacios en blanco*/

do{ *n = *n+1; }while (buffer[*n] != '\n' && *n < Tam_Buffer);

p = *n - 1; if(*n == Tam_Buffer && k == 1 && buffer[p] != '\n') { aux = -1; do{ aux++;

}while(buffer2[aux] != '\n' && aux<Tam_Buffer); } p = *n - 1; if(*n == Tam_Buffer && k == 2 && buffer[p] != '\n') { aux =-1; do{ aux++; }while(buffer1[aux] != '\n' && aux<Tam_Buffer); aux = aux+1; }

num_linea++; } *n = *n+1;

} p = 0; }

if (buffer[*n]== EOF) { tokenval = HECHO; return HECHO; /*Si se ha terminado de leer el archivo*/ }

if (isdigit(buffer[*n])) /*buffer[n] es un nmero entero*/ { while(isdigit(buffer[*n])) { *n = *n+1; }

if(k==1 && *n == Tam_Buffer) { aux = 0; if (isdigit(buffer2[aux])) { while(isdigit(buffer2[aux]) && aux<Tam_Buffer) { aux++; }

} }

if(k==2 && *n == Tam_Buffer ) { aux = 0; if (isdigit(buffer1[aux])) { while(isdigit(buffer1[aux]) && aux<Tam_Buffer) { aux++; } } } return NUM_ENT; }

if(isalpha(buffer[*n])) /*buffer[n] es una letra*/ { p = b = 0; while((isalnum(buffer[*n]) || buffer[*n] == '_')&& *n<Tam_Buffer) /*buffer[n] es alfanumrico*/ { buffer_lex[b] = buffer[*n]; /*Inserta en el buffer el caracter, concatenando la palabra*/ *n = *n+1;

b = b+1; if(b>=Tam_Buffer) error("Error al Compilar"); }

if(*n == Tam_Buffer && k == 1 && isalnum(buffer2[0])) { aux = 0;

while((isalnum(buffer2[aux]) || buffer2[aux] == '_')&& aux <Tam_Buffer) /*buffer[n] es alfanumrico*/ { buffer_lex[b] = buffer2[aux]; /*Inserta en el buffer el caracter, concatenando la palabra*/ aux++; b = b+1; if(b>=Tam_Buffer) error("Error al Compilar"); } }

if(*n == Tam_Buffer && k == 2 && isalnum(buffer1[0])) { aux = 0;

while((isalnum(buffer1[aux]) || buffer1[aux] == '_')&& aux <Tam_Buffer) /*buffer[n] es alfanumrico*/ { buffer_lex[b] = buffer1[aux]; /*Inserta en el buffer el caracter,

concatenando la palabra*/ aux++; b = b+1; if(b>=Tam_Buffer) error("Error al Compilar"); } }

buffer_lex[b]= EOS; /*Marca fin de palabra*/ p = busca (buffer_lex); /*Verifica si la palabra no se encuentra en la tabla de smbolos*/ if (p == 0) /*Si p no es una palabra reservada*/ p = inserta(buffer_lex, ID); tokenval = p; n--; n++; return get_token(p); }

if(buffer[*n] == '<' || buffer[*n]== '!' || buffer[*n] == '>' || buffer[*n] == '=' || buffer[*n] == '|' || buffer[*n] == '&' || buffer[*n] == '+' || buffer[*n] == '-' || buffer[*n] == '*' || buffer[*n] == '/' || buffer[*n] == '%') { int c = *n; *n=*n+2; return op_arit(buffer, c, &n);

if(buffer [*n] == '"') { p,b = 0; buffer_comentario[b] = buffer[*n]; *n = *n+1; b=b+1;

while(buffer[*n] != '"' && *n<Tam_Buffer) { buffer_comentario[b] = buffer[*n]; *n=*n+1; b=b+1; } buffer_comentario[b] = buffer[*n];

h = *n-1; if(*n == Tam_Buffer && k == 1 && buffer[h] != '"') { aux = 0; while(buffer2[aux] != '"' && aux<Tam_Buffer) { buffer_comentario[b] = buffer2[aux]; aux++; b++; } buffer_comentario[b] = buffer2[aux];

} h = *n-1; if(*n == Tam_Buffer && k == 2 && buffer[h] != '"') { aux = 0; while(buffer1[aux] != '"' && aux<Tam_Buffer) { buffer_comentario[b] = buffer1[aux]; aux++; b++; } buffer_comentario[b] = buffer1[aux]; } buffer_comentario[b+1]= EOS; tokenval = inserta(buffer_comentario, CADENA); *n = *n+1; p=b=0; return CADENA; }

*n=*n+1; q = *n-1; tokenval = NINGUNO; return (toascii(buffer[q])); }

int op_arit (char buffer[], int c, int *n)

int edo;

if ( buffer[c] == '<') edo = 0; else if (buffer[c] == '!') edo = 1; else if (buffer[c] == '>') edo = 2; else if (buffer[c] == '=') edo = 3; else if (buffer[c] == '|') edo =4; else if (buffer[c] == '&') edo =5; else if (buffer[c] == '+'){ tokenval = SUMA; *n = *n-1; return ADD_OP;} else if (buffer[c] == '-'){ tokenval = RESTA; *n = *n-1; return MUL_OP;} else if (buffer[c] == '/'){ tokenval = DIV; *n=*n-1; return MUL_OP;} else if ( buffer[c] == '%'){ tokenval = MOD; *n=*n-1; return MUL_OP;} else if (buffer[c] == '*'){ tokenval = MULT; *n = *n-1;

return MUL_OP;}

switch(edo) { case 0: if (buffer[c+1] == '='){ tokenval = LE; return REL_OP;} else { tokenval = LT; *n = *n -1; return REL_OP; } case 1: if ( buffer[c+1] == '=') { tokenval = NE; return REL_OP; } else { tokenval = NINGUNO; *n = *n -1; return (toascii(buffer[c]));} case 2: if (buffer[c+1] == '='){ tokenval = GE; return REL_OP; } else { tokenval = GT; *n = *n -1;

return REL_OP; } case 3: if (buffer[c+1] == '=') { tokenval = EQ; return REL_OP; } else { tokenval = NINGUNO; *n = *n -1; return ASIGNACION; } case 4: if (buffer[c+1] == '|') { tokenval = OR; return ADD_OP; } else { tokenval = NINGUNO; *n = *n -1; return (toascii(buffer[c])); } case 5: if (buffer[c+1]) { tokenval = AND; return MUL_OP;} else { tokenval = NINGUNO; *n = *n -1; return (toascii(buffer[c])); } } }

funciones_simbolos.c

#include "global.h"

int ultima_entrada = 0;

tipo_tabla tabla_simbolos[MAX_SIMBOLOS]; /*Arreglo de estructuras*/

int busca (char *s) { int p; for (p=1; p<ultima_entrada; p++) {

if(strcmp(tabla_simbolos[p].lexptr, s) == 0) { return p; } } return 0; }

char *almacena (char *s) { static char palabras [MAX_PALABRA];

int primer_palabra; static int ultima_palabra = -1; primer_palabra = ++ultima_palabra; ultima_palabra = ultima_palabra + strlen(s); /*Suma a ultima palabra el numero de caracteres de s*/

if(ultima_palabra >= MAX_PALABRA) error ("Desbordamiento de la Palabra\n"); strcpy(&palabras[primer_palabra],s); return(&palabras[primer_palabra]); }

int inserta (char *s, int tok) /*Inserta el valor y tipo de la palabra reservada en la tabla de smbolos*/ { if(++ultima_entrada >= MAX_SIMBOLOS) error ("Desbordamiento de la Tabla de Smbolos"); tabla_simbolos[ultima_entrada].token = tok; tabla_simbolos[ultima_entrada].lexptr = almacena(s); return ultima_entrada; }

void put_token (int i , int new_token) { tabla_simbolos[i].token = new_token; }

int get_token (int i) { return tabla_simbolos[i].token; }

char *get_system (int i) { return tabla_simbolos[i].lexptr; }

void imprime_simbolos () { if (ultima_entrada) { int i; printf ("\nTABLA SIMBOLOS\nContenido \t Valor \n"); for (i=1; i<=ultima_entrada; i++) printf("%10.60s \t %d\n", get_system(i), get_token(i)); } }

Pruebas.
Para el siguiente archivo.fte programa comienza x = 5 + 5; y = 30; variable1 = 54 - 53 variable2 = 6 * 5 {multiplicacion "variable2 = 30" {otra variable t = x/y; inicio "chalalalalaalal" {otro comentario 45566643 termina Se obtuvo el siguiente conjunto de tuplas: (256 (257 (261 (260 (262 (313 (262 (59 (261 (260 (262 1) 7) 21) -1) -1) 306) 306) -1) 22) -1) -1)

(59 (261 (260 (262 (312 (262 (261 (260 (262 (312 (262 (263 (261 (260 (261 (312 (59 (261 (263 (262 (258 (259

-1) 23) -1) -1) 307) 307) 24) -1) -1) 309) 309) 25) 26) -1) 21) 277) -1) 27) 28) 28) 8) 259)

Para el siguiente Archivo.fte:

{comentarioo grande 13455 variable_compiladores = 89304040 $$$

"palabras reservadas" programa comienza termina si x = 5 x=9%9 termina

{comentarioo grande 13455 variable_compiladores = 89304040 $$$ "palabras reservadas" programa comienza termina si x = 5 x=9%9 termina

podria venir 3455 {comentario "otra cadena" termina "nallely flores vicente"

Se obtuvo el siguiente conjunto de tuplas:

(261 (260 (262 (36

21) -1) -1) -1)

(36 (36 (263 (256 (257 (258 (264 (261 (260 (262 (261 (260 (262 (312 (262 (258 (261 (260 (262 (36 (36 (36 (263 (256 (257 (258 (264

-1) -1) 22) 1) 7) 8) 2) 23) -1) -1) 24) -1) -1) 278) 278) 8) 21) -1) -1) -1) -1) -1) 25) 1) 7) 8) 2)

(261 (260 (262 (261 (260 (262 (312 (262 (258 (261 (261 (262 (263 (258 (263 (259

23) -1) -1) 23) -1) -1) 278) 278) 8) 26) 27) 27) 28) 8) 29) 259)

REFERENCIA BIBLIOGRFICA

http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C/Manejo_de_archivos http://www.google.com/url?sa=t&source=web&cd=4&ved=0CDcQFjAD&url=http%3A%2F% 2Fwww.ual.es%2F~abecerra%2FID%2Farchivos.pdf&ei=PDUITqTiMIbw0gHey83kCw&usg=A FQjCNGrTGwWVZvO8Kl_CuFBbIGN0fw2VA&sig2=yWKuhnSM9QAIik1c6x0YLQ http://www.slideshare.net/javi2401/caracteres-y-cadenas-en-c-presentation http://www.fismat.umich.mx/mn1/manual/node18.html http://www.docstoc.com/docs/4978060/Funciones-en-C-para-manejo-de-cadenas