Tarea N 2 Compiladores

Relacionar la sintaxis con las gramticas independientes de contexto.

La gramtica independiente de contexto sirve para reconocer de una manera especifica la sintaxis de un lenguaje. La gramtica independiente de contexto se divide en los siguientes componentes: * Un conjunto de componentes lxicos (smbolos terminales). * Un conjunto de smbolos no terminales. * Un conjunto de producciones. * La notacin de uno de los smbolos no terminales como smbolo inicial. Explicar los problemas de ambigedad, asociatividad y precedencia en operadores.

En la ambigedad se debe tener cuidado con estructura de una cadena con respecto a la gramtica, ya que est puede tener ms de un rbol que genere la misma cadena de componentes lxicos. Para saber si existe ambigedad se necesita encontrar una cadena de componentes lxicos que posea ms de un desarrollo en componentes del analizador sintctico, es decir, que tenga ms de un rbol. Para la compilacin es necesario que nuestras gramticas sean no ambiguas y de serlo que posean reglas adicionales para resolver dicha ambigedad. La asociatividad posee una jerarqua, en el caso de trabajar con parntesis se usa la asociatividad por la izquierda y se usa la asociatividad por la derecha cuando se trabaja con el operador asignacin .

Describir en qu consiste la traduccin dirigida por la sintaxis.

Aqu se presenta la definicin dirigida por la sintaxis para especificar las traducciones para las construcciones de lenguajes de programacin. Esta especifica la traduccin de una construccin en funcin de atributos asociados con sus componentes sintcticos. Para especificar la traduccin, se introduce tambin una notacin ms orientada a procedimientos, denominada esquema de traduccin. La definicin dirigida por la sintaxis utiliza gramtica independiente del contexto para especificar la estructura sintctica de entrada. A cada smbolo se le asocian un conjunto de atributos y a cada produccin, reglas semnticas para calcular valores de los atributos asociados con los smbolos de dichas producciones. La traduccin bsicamente es una transformacin de la entrada en una salida mediante un numero de pasos. La salida de una entrada r cualquiera, se realiza de la forma: 1- Se construye un rbol de anlisis sintctico para la entrada r. 2- Luego para un cierto nodo n del rbol de anlisis sintctico que esta etiquetado por X, se escribe X.a para indicar el valor del atributo a de Xen el nodo n. El valor de X.a en n se calcula pro la regla semntica para el atributo a en la prod. X. Describa el Anlisis sintctico y su relacin con los contenidos del curso.

El anlisis sintctico determina si una cadena de componentes lxicos, proveniente del analizador lxico, puede ser generada por una gramtica. Si el analizador sintctico pude construir un rbol se podr garantizar que la traduccin es correcta. Para cualquier gramtica, se puede construir un analizador sintctico. La mayora de estos mtodos de anlisis son de dos clases los mtodos descendente y ascendente,esto hace referencia en la sentido en que construyen los nodos del rbol de anlisis sintctico. En el primero la construccin se inicia en la raz de rbol y avanza hacia las hojas. En el segundo la construccin se inicia en las hojas y avanza hacia la raz. La diferencia entre uno y otro es que en el primero se pueden construir manualmente analizadores ms eficiente con mayor facilidad mientras que en el segundo se puede manejar una mayor cantidad de gramticas y esquemas de traduccin. En relacin con la materia de este y otros cursos vemos la aparicin de rboles y tambin que es posible llevar el mtodo descenderte a forma de autmatas. Puesto que siguiendo los pasos para la bsqueda del algoritmo descendente, nos permite trabajar con grafos puesto que estos tambin son algoritmos. Describa el Anlisis lxico y su relacin con los contenidos del curso.

El analizador lxico lee y convierte una cadena de entrada en componentes lxicos los cuales son ledos por analizador sintctico. Ms especficamente el analizador lxico puede reducir el cdigo de entrada, eliminado los espacios en blando como los

comentarios, reduciendo as la cadena de componentes lxicos. Con respecto del curso podemos pensarlo como una pila. Explicar el concepto de Mquinas de pila y su relacin con las tablas de smbolos.

Las maquinas de pila se encuentran en la parte inicial de un compilador y son una representacin intermedia del programa fuente. Estas se usan para almacenar datos temporales y evaluar expresiones tales como adicin y sustraccin. La tabla de smbolos son estructuras de datos que almacenan toda la informacin de los identificadores del lenguaje fuente. Esta tabla le proporciona informacin a la maquina de pila. Copiar los programas dados en las pginas 74 a la 79

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

#include <stdio.h> #include <ctype.h> #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; int numlinea; struct entrada{ char *aplex; int complex; }; struct entrada tablasimb[];

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

#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); 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) erro("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; } } }

/**************** analizsint.c ******************************

#include "global.h" int preanalisis; analsint() { preanalisis=analex(); while(preanalisis!=FIN){ expr();parea(';'); } } expr() {int t; termino(); while(1) switch (preanalisis){ case '+': case '-': t= preanalisis; parea (preanalisis); termino();emite (t, NINGUNO); continue; default: return;

} } 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; } } 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"); } } parea(t) int t; { if(preanalisis==t ) preanalisis = analex(); else error("error de sintaxis"); }

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

#include "global.h" emite (t, tval) int t, tval; { 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); } }

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

#include "global.h" #define MAXLEX 999 #define MAXSIMB 100 char 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=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.c ******************************

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

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

#include "global.h" error(m) char *m; { fprintf(stderr, "linea %d: %s\n", numlinea,m); exit(1); }

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

#include "global.h" main() { inic(); analsint(); exit(0); }