Prácticas Compiladores YACC Este material no es obligatorio para la práctica. Grupos de Kostadin Koruchev.

Transcripción

1 Prácticas Compiladores YACC Este material no es obligatorio para la práctica. Grupos de Kostadin Koruchev. A quien se refiere: A los alumnos que por una u otra razón no han podido asistir en clase. Esto son los ejercicios que se han hecho en clase. Los ejemplos están ampliados en respeto con lo que se dio en clase. Contenido: Los ejercicios que se hicieron en clase con explicaciones y unos 4-5 problemas más. Como utilizarlo: En clase los ejercicios se dan uno tras otro y no se proporciona la solución antes de que los alumnos resuelven el problema. Esto es claramente imposible con un material en papel. El grado de manejo de la práctica depende del esfuerzo de cada alumno. Por tanto una simple lectura del material no ofrece mucho manejo de yacc. El procedimiento correcto es el siguiente: Leer con cuidado el material. Cuando hay que escribir un programa, intentar de escribirlo utilizando el material de referencia proporcionado en clase y la información en info yacc. Ocultar el resto de este manual con una hoja. Después de resolver el problema, comparar con la solución que se proporciona. Los puntos donde hay que parar de leer y hacer el ejercicio están marcados con ***************************** El final de la sección, donde se proporciona la solución del problema, se da con 1 Práctica 1. Introducción a yacc Yacc es una herramienta para construcción de analizadores sintácticos de lenguajes del tipo LR(1) (LALR). 1.1 Concepto: Consideramos el lenguaje: -> S S -> ( B ) B -> ( B ) (1) D D -> b D NIL 1

2 Construimos la tabla SLR de análisis: ( b ) D B $ S D->NIL D->NIL D->NIL 4 4 D->bD 5 B->D B->(B) S->(B) 10 ACCEPT Observación: 1. La tabla se construye utilizando un algoritmo bien conocido y no es necesario hacerla a mano. 2. Las decisiones(acciones) en el lenguaje pueden hacerse sólo al reducir una regla. Es preciso entonces al hacer la reducción, incluir las acciones. En yacc esto se escribe así: 1.2 Formato fichero entrada yacc S : ( B ) { acción; } donde acción representa sentencias en C, S - símbolo no terminal, (B) - la sentencia que se reduce a S. Con muchas reglas del mismo símbolo no terminal: B : ( B ) d D Yacc construye la tabla de análisis y ejecuta el trozo de programa {acción; }, antes de reducir los símbolos. También maneja la pila del autómata LR (de símbolos y estados). Los símbolos terminales con un carácter pueden sustituirse con el código (ASCII) del mismo, si esto es que devuelve del analizador morfológico. Al encontrar un error sintáctico, el analizador llama a yyerror(). El código de yacc se incluye en manera parecida de lex entre. Problema: 2

3 Escribir el lenguaje (1) en formato yacc. Compilar con yacc. ***************************** S : ( B ) { printf(" S->(B)\n");} B : ( B ) { printf(" B->(B)\n");} D { printf(" B->D\n");} D : b D { printf(" D-> b D\n");} /* NIL */ { printf(" D->NIL\n");} 1.3 yyerror(); main(); yylex(); El usuario tiene que proporcionar las funciones yyerror(), main() y yylex(). El funcionamiento de yylex() es el mismo que proporciona lex. yyerror() sirve para escribir los errores en stderr. main() invoca yyparse(). yyparse() es la función que se genera a partir de las definiciones de la gramática y las acciones. Es decir, todo entre y es yyparse(). Devuelve un entero igual a 0 si el análisis ha terminado con exito y 1 si el análisis ha terminado con error. /* ANALIZADOR MORFOLOGICO */ int yylex() { char ch=getchar(); if (ch== ( ch== b ch== ) ) return ch; return 0; } /* manejo de errores y main -- omitidos en los demas ejemplos */ void yyerror(a) { printf(a);} int main() { return yyparse();} 1.4 Valor semántico Como podemos ver el analizador se llama con yyparse(), y el analizador morfológico yylex() lo mismo como si está generado con lex. Atributos: Con cada símbolo yacc asocia un atributo sintetizado. El atributo de la regla que va a reducirse se calcula a partir de los atributos de la parte derecha. El tipo del valor semántico es YYSTYPE, que el usuario tiene que definir. Los valores se refieren como $1 para el primer símbolo a 3

4 reducir, $2 para el segundo símbolo etc. El valor del atributo del padre se refiere como $$: S : ( B ) -- regla $$ $1 $2 $3 -- atributos correspondientes (valores semánticos). Problema: Escribir un parser del lenguaje (1) que imprime el número de los b -s en la cadena. ***************************** %{ #define YYSTYPE int %} S : ( B ) { $$=$2; printf("número de b-s: %d\n",$$);} B : ( B ) { $$=$2; /* el mismo número de b como en el B */ } D { $$=$1; } D : b D { $$=$2+1; /* un b mas */} /*NIL*/ { $$=0; /* hay 0 b-s */ }... main & yyerror 1.5 Tipo del valor semántico El valor de los símbolos terminales no se puede calcular a partir de otros valores y hay que devolverlo desde el analizador morfológico. Esto se hace a través de una variable global llamada yylval, del tipo YYSTYPE. En yacc el atributo se refiere en la manera habitual ($1, $2...). Ejemplo: El lenguaje es: S-> (B) B-> (B) D D-> D NIL Problema: Calcular la suma de los dígitos en S. 4

5 Definimos el valor semántico del 0-9 como 0-9 y pasamos el token b como antes. ***************************** %{ #define YYSTYPE int %} S : ( B ) { $$=$2; printf("suma de digitos: %d\n",$$); } B : ( B ) { $$=$2;} D { $$=$1;} D : b D { $$=$2+$1;} /* NIL */ { $$=0;} // $ /* ANALIZADOR MORFOLOGICO */ int yylex() { char ch=getchar(); if (isdigit(ch)) { yylval=ch- 0 ; return b ; } if (ch== ( ch== ) ) return ch; return 0; } void yyerror() { printf("error\n");} int main() { return yyparse();} Problema: Calcular la suma de los dígitos en S y el numero de paréntesis en S. ******************************************* Como valor semántico necesitamos dos números. Entonces YYSTYPE es una estructura con dos miembros int. Una posible solución: %{ typedef struct cnts_t { int sum,par; } cnts_t; #define YYSTYPE cnts_t %} S : ( B ) { $$=$2; $$.par++; printf("suma de digitos: %d\n",$$.sum); printf("num. parentesis: %d\n",$$.par); 5

6 } B : ( B ) { $$=$2; $$.par++; } D { $$=$1; $$.par=0;} D : b D { $$.sum=$2.sum+$1.sum;} /* NIL */ { $$.sum=0; } // $ /* ANALIZADOR MORFOLOGICO */ int yylex() { char ch=getchar(); if (isdigit(ch)) { yylval.sum=ch- 0 ; return b ; } if (ch== ( ch== ) ) return ch; return 0; } void yyerror() { printf("error\n");} int main() { return yyparse();} 1.6 Tokens, operadores, asociación, precedencia Tokens. Generación fichero header para lex. Hay que definir los terminales del lenguaje como tokens, que el analizador utiliza. Esto se consigue en la parte de declaraciones con la directiva token. Los valores literales ( char ) no necesitan definición. A partir de estos tokens yacc puede definir los valores de los tokens de lex (con yacc -d) Operadores Tal como las operaciones aritméticas son frecuentes yacc incluye mejoras que permiten escribir más cómodo reglas de este tipo. Es decir, a lugar de escribir el lenguaje en forma SLR: exp : exp + mult exp - mult mult : mult / prim mult * prim prim : const ( exp ) En yacc uno puede escribir en forma LARL: 6

7 exp : exp + exp exp - exp exp / exp exp * exp ( exp ) const. El problema de este lenguaje es el conflicto shift/reduce al no saber en que orden reducimos /+. Por eso se definen asociación y prioridad de los operadores. La asociación se define con %left y %right: Asociación %left - significa que se interpreta como (5-5)-5 y %right - que se interpreta como 5-(5-5). Precedencia La precedencia se define con el orden de las declaraciones de los operadores. El orden habitual sería: %left - + %left * / con significado, que la precedencia de - y + es igual y es menor que la precedencia de * y /. Ejercicio: Menos unario tiene mayor precedencia que la resta. Por otro lado se expresa con el mismo símbolo. Ver en info bison como se realiza menos unario. 1.7 Ejemplos Intérprete Problema: Hacer calculadora con operaciones + / y (). Cada sentencia de la calculadora empieza con output seguida de una expresión numérica y termina con punto-coma. Todos los números son enteros. Todos los demás símbolos se pueden ignorar. *************************************** Construimos la gramática: prog : output exp ; prog exp : exp + exp exp - exp 7

8 exp / exp exp * exp ( exp ) const Escribimos la gramática en formato yacc (calc.y): %{ #define YYSTYPE int %} %token output %token cnst %left - + %left * / prog : OUTSTM prog OUTSTM : output exp ; { printf("%d\n",$2); } exp : exp + exp { $$=$1+$3;} exp - exp { $$=$1-$3;} exp / exp { $$=$1/$3;} exp * exp { $$=$1*$3;} ( exp ) { $$=$2;} cnst { $$=$1;} Escribimos analizador léxico (calc.lex): %{ #define YYSTYPE int extern YYSTYPE yylval; #include "y.tab.h" %} output { return output; } [;+/*()-] { return yytext[0]; } [0-9]+ { yylval=atoi(yytext); return cnst; }. ; \n ; 8

9 Compilamos y ejecutamos. De paso generamos el header y salida para depurar. yacc -d -v calc.y ; lex calc.lex ; gcc y.tab.c lex.yy.c -lfl ;./a.out Cálculos con maquina de pila Problema: Definimos una maquina de pila con operaciones: push,print,mul,add,sub,div con la siguiente semántica: int st[1000],sp=0; static pop() { return st[--sp];} void push(int a) { st[sp++]=a; } void mul() { int b=pop(); push(pop()*b);} void div() { int b=pop(); push(pop()/b);} void add() { int b=pop(); push(pop()+b);} void sub() { int b=pop(); push(pop()-b);} void print() { printf("%d\n",pop());} Escribir un compilador del lenguaje anterior (de la calculadora) y esta máquina de pila: ***************************************** Como se trata de máquina de pila no es necesario propagar información al padre. Por eso: Lex como de arriba. Yacc: %token output %token cnst %left - + %left * / prog : OUTSTM prog OUTSTM : output exp ; { printf("print();\n"); } exp : exp + exp { printf("add();\n");} exp - exp { printf("sub();\n");} exp / exp { printf("div();\n");} exp * exp { printf("mul();\n");} 9

10 ( exp ) { } cnst { printf("push(%d);\n",$1); } int main() { int r; printf("main(){\n"); r=yyparse(); printf("}\n"); return r; } Emulación de máquina de pila Ejercicio: Cambiar por add() pop ax bx add ax,bx push ax y ver la salida Máquina con registros Problema: Hay que generar código para expresión aritmética (sólo +, y ()) para una máquina con número de registros infinito (cuádruplas). Por ejemplo: (2 + 3) (5 + 6) genera: 2 -> r1 3 -> r2 r1 + r2 -> r3 5 -> r4 6 -> r5 r4 + r5 -> r6 r3 - r6 -> r7 El lenguaje es: %left

11 exp : num exp + exp exp - exp ( exp ) ; ***************************************** Está claro que el número del registró del resultado es solo un número consecutivo de la producción que reducimos. Por otra parte está claro que el número de los registros en la parte izquierda son los hijos de la producción que se reduce. Por tanto hay que pasar solo el número del registro. %{ int reg=0; #include <stdio.h> %} %left + - exp : n { $$=reg++; printf("%d -> r%d\n",$1,$$); } exp + exp { $$=reg++; printf("r%d + r%d -> r%d\n",$1,$3,$$); } exp - exp { $$=reg++; printf("r%d - r%d -> r%d\n",$1,$3,$$); } ( exp ) { $$=$2;} ; yyerror(a) { printf((char *)a); } main() { yyparse(); } Pregunta: Por qué lo que genera la máquina son cuádruplas y no triples, si no participan mas que 3 registros? Problema (para casa): Está claro que con la notación de arriba si un regisrtro aparece en la parte izquierda de la salida ya no aparecerá nunca más. Hacer reutilización de su número, es decir utilizar un número mínimo de registros sin cambios en la gramática. Problema (para casa): Si un programa tiene N números y 2K paréntesis en la expresión, cuántos registros L necesita sin reutilización? Cuántos registros M máximo necesita con reutilización? Si los paréntesis están aleatoriamente distribuidos y utilizamos reutilización, cuántos registros Q promedio necesita? Respuestas: L = 2N, M = K + 3, Q = log 2 (K + 1)

12 2 Práctica 2. Conflictos del lenguaje, tratamiento de errores, depuración 2.1 Depuración Hay varias maneras de depurar un programa escrito en yacc. Una de las maneras es de incluir printf() en las acciones donde suponemos que hay error. Sin embargo está manera está limitada a la parte que controlamos, es decir sólo al reducir reglas. Para depurar la gramática y el autómata, se hace lo siguiente: 1. Se compila con bandera -v yacc -v Se compila el código C con YYDEBUG definido gcc -DYYDEBUG En el código C hay que ejecutar yydebug=1; en el principio de la sección que vamos a depurar y yydebug=0; cuando ya no necesitamos la depuración. Problema: En el intérprete de la calculadora incluir antes de la llamada de yyparse() yydebug=1 y ejecutar la calculadora con opciones de depuración. Analizar la salida. Está claro que la salida es enorme. Por tanto, es normal que yydebug=1 se incluye en las acciones justo antes de la parte que vamos a depurar y se pone a 0 justo después. Problema: En el intérprete de la calculadora, incluir un símbolo de la gramática : que alterna el estado de depuración. Por defecto, el estado de depuración está activo. Probar con las entradas: : output 5+6; output 5*6+20/5; : output 3/2;: output 5++; y output 5++; *************************************... OUTSTM : output exp ; { printf("%d\n",$2); } 12

13 : { yydebug=1-yydebug;}... main() {... #ifdef YYDEBUG yydebug=1; #endif... } El cambio de *.lex no se muestra Tratamiento de errores Si yacc reduce el axioma, es decir agota la pila, yyparse() termina. Si yyparse() ha estado en estado de error, el resultado es diferente de 0 y si toda la entrada se ha procesado sin error, yyparse() termina con resultado 0. Si yyparse() encuentra símbolo que no puede interpretar, hace lo siguiente: 1. Llama al yyerror() y escribe el mensaje de error. 2. Entra en estado de tratamiento de errores. 3. Elimina la pila, hasta que se agota la misma o se encuentre en un estado antes del símbolo especial error. Si se agota la pila yyparse() devuelve Si se encuentra un estado con el símbolo especial error, yyparse pide la entrada de yylex() hasta que se encuentra un símbolo que puede seguir error en la sentencia que se reduce. 5. Al reducir la sentencia, el usuario es responsable de eliminar el estado de error con el macro yyerrok y limpiar el símbolo look-ahead del autómata SLR con el macro yyclearin si es necesario. Si no existe ningún símbolo error en la gramática el comportamiento es muy duro yyparse sale con error. Como consecuencia practica, al añadir las sentencias que manejan el error, hay que convertir el lenguaje en algo que acepta todas las cadenas de terminales posibles. Problema: Añadir en el interprete de la calculadora tratamiento de errores, que tratan los errores en una expresión. Probar con las entradas : 13

14 output 5+6; output ++6; output 3+4; output ++6; output ++6; 5+6; 2+1; output 3+4; Eliminar yyerrok y probar. Eliminar yyclearin y probar. *******************************... OUTSTM : output exp ; { printf("%d\n",$2); } : { yydebug=1-yydebug;} output error ; { yyerrok; yyclearin; }... - Problema: Añadir sentencias que capturan el error 2+1;. Añadir sentencia que captura la falta de ;. En general los símbolos error tienen que estar antes de los delimitadores del lenguaje. Sustituyen el elemento donde se espera el error (en el caso de la calculadora el exp). También tienen que estar cerca del axioma para capturar todos los errores, lejos del axioma para acotar el impacto del error lo máximo posible. Está claro que se busca un compromiso en este punto. Los símbolos de tratamiento de errores no tienen que alterar el lenguaje sin errores y no tienen que cambiar el lenguaje con una entrada sin errores y si es posible, no tienen que introducir conflictos Formato de mensajes de errores Un compilador es un programa de línea de comando y comunica con su entorno (editor de texto, depurador etc), utilizando el fichero de salida y stderr. Si el formato de error es el siguiente: <nombre fichero>:<linea del error> [:<columna>]:< texto del error>, la mayoría de los entornos trabajan automáticamente con el texto, por ejemplo posicionando el cursos sobre el error. Ejemplo: Mensaje de error generado por gcc. 14

15 petdot.c:12: parse error before "b". Problema: Hacer la calculadora con este formato de error y fichero de entrada como argumento de la linea de comando. Probar ejecutándolo bajo un entorno de programación. 2.3 Solución de conflictos: Los conflictos se producen si el lenguaje no es del tipo LALR. Existen dos tipos de conflictos posibles en los parser LALR: shift/reduce y reduce/reduce. Los conflictos se resuelven analizando el fichero de salida y.output generado por yacc -v..., que es un fichero de texto con la definición del autómata. Entender porque ocurre el conflicto en la mayoría de los casos es suficiente para su arreglo Reduce/reduce: Significa que en un estado hay dos reglas candidatas a reducir. Por defecto yacc reduce la primera producción declarada. Los conflictos reduce/reduce normalmente son indicios por errores graves en el lenguaje. El lenguaje debería corregirse eliminando el conflicto. Para ver el conflicto con más detalle, normalmente necesarios para resolverlo, es preciso producir la salida fácilmente legible por el programador yacc -v Shift/reduce: Los conflictos shift/reduce se producen, cuando el parser puede reducir a un símbolo no terminal y en el mismo símbolo de entrada puede seguir leyendo y acumulando la entrada. La acción de yacc por defecto es shift. El ejemplo clásico es: stm -> if (expr) stm1 ; else stm2; if (expr) stm1 ; Al encontrar ; después de stm1, podemos seguir leyendo o podemos reducir la ultima regla. Normalmente los conflictos shift/reduce son reales, por ejemplo el conflicto de arriba significa simplemente que no hay semántica clara en ifs enlazados. Se pueden resolver cambiando el lenguaje o si la respuesta por defecto de yacc es correcta utilizando está respuesta. Es normal que se arreglen moviendo el símbolo que produce el error más lejos posible del axioma. Problema: El lenguaje es: 15

16 %token in var out num %left - %left * prog: ins ; outs ; ; ins: in var in var ; ins outs: out exp out exp ; outs ; exp: num var exp - exp exp * exp ; yyerror(a) { fprintf(stderr,a); } main() { yyparse(); } El lenguaje tiene un conflicto shift/reduce, porque al encontrar ; en ins no se puede decir qué tiene que hacer el analizador. Hay que mover el símbolo ; hacia abajo (borrándolo de arriba). Cambiar el lenguaje en manera adecuada. ***************************************... prog: ins outs ; ins : in var ; in var ; ins... Problema: Cambiar el lenguaje de manera que elimina el conflicto al EOF. 2.5 Elección de tipo de valor semántico El valor semántico casi siempre es una estructura. Contiene todo que se utiliza para generar la acción adecuada. También contiene todo que hay 16

17 que propagar hacia el padre, porque con análisis abajo-arriba el hijo no puede saber cual es el padre en el momento de su reducción. Problema en casa: El árbol sintáctico es el máximo que puede devolver un analizador sintáctico. Añadir las acciones semánticas apropiadas en la calculadora para que se genera un árbol sintáctico. Utilizar que no hay más que 3 hijos en cada producción. Ejercicio: Analizar la analogía de los requisitos de la práctica y la máquina que genera cuádruplas. Para el enunciado de la Práctica 3: (1) Definir en que reducción hay que imprimir la salida (en el padre o en el hijo). (2) Definir que hay que propagar hacia el padre. (3) Definir que hay que utilizar en la propia producción. (4) Definir YYSTYPE. (5) Intentar de escribir toda la acción, necesaria para cumplir los requisitos de salida, en una sola funcion con número variable de argumentos. 3 Resumen: Construcción de un analizador sintáctico Pasos: 1. Entender la definición del lenguaje. Definir las lexemas. 2. Escribir el lenguaje en forma aceptable para yacc (todos los símbolos identificadores validos de C o caracteres simples entre comillas simples). Normalmente esta tarea es editar la definición. 3. Sacar todos los símbolos terminales ejecutando yacc -d y utilizando la salida de errores definir los tokens y generar el fichero.h. 4. A partir del header, generado por yacc -d..., escribir el analizador léxico, no olvidando los símbolos de sólo un carácter. 5. Resolver los conflictos en el lenguaje: precedencia y asociación. correspondencia exacta a la definición original. trasformación a un lenguaje SLR. si no se puede utilizar el orden correcto de las sentencias en yacc. 6. Probar el parser. 7. Escribir acciones que sirven para comprobar el analizador. 8. Definir el tipo semántico adecuado para el problema. 9. Comprobar el analizador estadísticamente. Ejercicio: Siguiendo estos pasos escribir la Práctica 3. 4 Información adicional: Linux: info bison. POSIX, IBM Redbooks WWW. 17