Guia Introduccion Flex Bison

GUA DE ESTUDIO INTRODUCCIN AL USO DE

FLEX BISON

PARA LA RESOLUCIN DE TAREA ESPECIAL

Sintaxis y Semntica de Lenguajes Dpto. de Ing. en Sistemas

SSIINNTTAAXXIISS YY SSEEMMNNTTIICCAA DDEE LLEENNGGUUAAJJEESS Departamento de Ingeniera en Sistemas

Universidad Tecnolgica Nacional - Facultad Regional Mendoza

Sintaxis y Semntica de Lenguajes: resolucin problemas de ingeniera 2

NDICE

1. INTRODUCCIN ......................................................................................................... 3

2. EL PROBLEMA ........................................................................................................... 4

3. FLEX ............................................................................................................................ 5

3.1 Qu es Flex? ....................................................................................................................... 5

3.2 Cmo se estructura un programa Flex? ..................................................................... 6 3.2.1 Definiciones ..................................................................................................................... 6 3.2.2 Reglas ............................................................................................................................... 8 3.2.3 Cdigo de Usuario ............................................................................................................ 9

3.3 Ejemplo de cdigo Flex ..................................................................................................... 9

4. BISON ........................................................................................................................ 11

4.1 Qu es BISON? ................................................................................................................ 11

4.2 Cmo se estructura un programa BISON? .............................................................. 12 4.2.1 Declaraciones ................................................................................................................. 12 4.2.2 Reglas de Produccin de la Gramtica ........................................................................... 14 4.2.3 Cdigo C adicional ......................................................................................................... 17

4.3 Ejemplo de cdigo Bison ................................................................................................ 19

5. INTEGRACIN FLEX + BISON ................................................................................. 20

6. INSTALACIN DE LAS HERRAMIENTA ................................................................. 22

7. PASOS PARA COMPILAR NUESTRO CDIGO FLEX + BISON ............................ 23




1. INTRODUCCIN

La presente Gua de Estudio, pretende orientar al alumno en el desarrollo de la Tarea Especial planteada por la ctedra. La misma constituye una gua sobre los

contenidos terico-prcticos que el alumno debe comprender para poder abordar el

problema (Qu debo saber?) y sobre el uso de las herramientas que debe manejar

para poder resolverlo (Cmo?). No obstante, no debe esperarse de esta gua un

tratamiento detallado de todos los contenidos necesarios para la resolucin del

problema. La misma pretende slo organizar aspectos bsicos para facilitar al alumno

al abordaje inicial del problema.

Importante: El propsito de esta Gua, no es reemplazar la bibliografa y documentos sugeridos para resolver la Tarea Especial. NO ES UN RESMEN DE

CONTENIDOS, NI UN TUTORIAL SOBRE FLEX o BISON. Su objetivo es orientar para

el estudio e indicar los primeros pasos a dar en la bsqueda de la solucin.

Se recomienda al alumno leer de manera completa la Gua antes de comenzar a

trabajar.




2. EL PROBLEMA

Con independencia del tema o caso escogido, la Tarea Especial consiste en desarrollar, para un lenguaje de programacin en particular1 (o un conjunto de

estructuras de programacin en un lenguaje particular) un Analizador Lxico

(Scanner) y un Analizador Sintctico (Parser) e integrarlos conformando un

compilador para dicho Lenguaje. Para resolver este problema debern utilizarse

conjuntamente dos herramientas: Flex y Bison, para generar analizadores Lxicos y

Sintcticos respectivamente.

Nota: Otras herramientas que podran utilizarse para desarrollar Parsers y Scanners son Lex, Yacc, etc.

1 En adelante y de modo simblico, nos referiremos a este lenguaje particular como Lenguaje XX.

Herramientas

9 Analizador Lxico (SCANNER) FLEX

9 Analizador Sintctico (PARSER) BISON




3. FLEX

3.1 QU ES FLEX?

Flex es un generador de analizadores lxicos de propsito general.

Esta herramienta trabaja sobre un conjunto de expresiones regulares, que recibe

como entrada. A partir de ellas, Flex genera un programa en C/C++ que implementa

un Scanner para reconocer el lenguaje regular descripto por dichas expresiones.

Luego, al compilar dicho cdigo en C/C++ se obtiene un programa ejecutable. El

aplicativo ejecutable busca concordancias entre un fichero de entrada (cdigo fuente

en el lenguaje que se esta analizando Lenguaje XX) y las expresiones regulares

que se definieron; y ejecuta acciones asociadas en consecuencia. La Figura 1,

esquematiza el proceso de generacin de un Scanner con Flex.

Figura 1

CODIGO FUENTE FLEX (miscanner.l) (Conjunto de expresiones regulares asociadas a una G3)

COMPILADOR FLEX

CODIGO FUENTE EN C - lex.yy.c (Programa que implementa el reconocimiento de cadenas y ejecuta

acciones en consecuencia)

COMPILADOR C (gcc)

PROGRAMA EJECUTABLE

(SCANNER)

Cdigo Fuente Lenguaje XX

Resultados del Anlisis

3.2 CMO SE ESTRUCTURA UN PROGRAMA FLEX?

Cmo se dijo previamente, Flex recibe como entrada un conjunto de expresiones regulares que describen los componentes lxicos de un lenguaje (Lenguaje XX). Esta

entrada (miscanner.l), debe proporcionarse en un archivo de texto que se ajuste a la

siguiente sintaxis:

Figura 2

Como se observa en la Figura 2, un archivo de entrada en Flex est compuesto por

tres secciones, separadas por una lnea %%: La seccin de definiciones, la seccin de

reglas y la seccin de cdigo de usuario.

3.2.1 Definiciones La seccin de Definiciones est constituida por una secuencia de parejas de la

forma nombre-definicin, conocidas como definiciones de nombre.

Figura 3

% {declaraciones en C %} definiciones

%%

reglas

%%

cdigo de usuario

Definiciones de nombre Pareja: nombre-definicin

%%

nombre definicin

nombre definicin...

donde:

nombre: nombre del token

definicin: expresin regular (patrn)




Cada definicin de nombre, permite asociar un nombre a una expresin regular.

El nombre, identifica un token que se est definiendo para el Lenguaje XX.

La expresin regular describe el patrn al que debern ajustarse las palabras o

Lexemas que concuerden con dicho token.

Luego, cada vez que se haga referencia al token utilizando {nombre}, la definicin se

expandir a su expresin regular asociada.

Ejemplo:

DIGITO [0-9]

ID [a-z][a-z0-9]*

CARACTER (\\[^\n]|[^"\\\n])

%%

Dadas estas definiciones de nombre, nuestro Scanner asociar cualquier nmero

dgito (0,1,2,,9) al token DIGITO, cualquier secuencia de una letra seguida cero o

ms letras o dgitos al token ID, y cualquier carcter ASCII empatar con el token

CARCTER.

El nombre es un identificador que puede comenzar con una letra o guin bajo,

seguido por cero o ms letras, dgitos, _, o - (guin).

La definicin comienza en el primer carcter que no sea un espacio en blanco

siguiendo al nombre y continuando hasta el final de la lnea. La sintaxis para escribir

expresiones regulares en Flex puede consultarse en la seccin 07. Patterns de Vern

Paxon (1995) Flex 2.5. Universidad de California2.

2 Tutorial de Flex provisto con la instalacin de Flex ver.2.5.4a




3.2.2 Reglas La seccin de Reglas contiene una serie de declaraciones de la forma: patrn-

accin donde el patrn debe estar sin sangrar y la accin debe comenzar en la misma lnea.

Figura 4

El patrn es una expresin regular que busca concordancias en el fichero de entrada

del Lenguaje XX; y la accin es cdigo escrito en C que se ejecutar cuando una

declaracin en el archivo de entrada en Lenguaje XX concuerde con el patrn asociado.

Ejemplo

%%

{DIGITO}+ {printf(Nmero: %s, yytext);}

\"{CARACTER}*\" {printf("Cadena: %s",yytext);}

En la primera regla del ejemplo, el patrn empareja con cualquier secuencia de 1 o ms

dgitos; y la accin indica que se imprima el contenido de la variable yytext.

En la segunda regla, el patrn emparejar con una cadena conformada por 0 o ms

caracteres, aceptando como CARCTER a aquellos que se definieron en la seccin de

definiciones de nombre.

%%

patrn1 {accin1}

patrn2 {accin2}

...

donde:

patrn: expresin regular

accin: cdigo C con las acciones a ejecutar cuando se encuentra concordancia del patrn con el texto de entrada.




Variables yytext y yyleng

Cuando se halla concordancia entre una declaracin en el archivo de entrada en

Lenguaje XX y un patrn, entonces el texto de entrada queda apuntado por el puntero

global a char yytext; y la longitud de esta cadena se guarda en la variable global yylen.

Luego, se ejecuta la accin asociada al patrn emparejado.

Para ms informacin sobre la forma de describir las reglas patrn-accin Ver las

secciones 0.8 How the input is matched y 09. Actions de: Vern Paxon (1995) Flex 2.5.

Universidad de California.

3.2.3 Cdigo de Usuario La seccin de Cdigo de Usuario es opcional y puede incluir funciones en C que llaman

al Scanner o son llamadas por l (por ejemplo: desde las acciones incluidas en la seccin

de reglas). El cdigo que aqu se incluya se copia literalmente en el archivo lex.yy.c

generado por Flex al compilar las declaraciones incluidas en miscanner.l (Ver Figura 1).

3.3 EJEMPLO DE CDIGO FLEX

El siguiente ejemplo en Flex, describe un Scanner que aceptar constantes enteras,

identificadores, operadores de adicin (+), operadores de asignacin (:=) y parntesis

como componentes lxicos de un lenguaje algebraico.

%{

#include

#include "instrucciones.tab.h"

%}

separador ([ \t])+

letra [a-zA-Z]

digito [0-9]

identificador {letra}({letra}|{digito})*

constEntera {digito}({digito})*

%%




{separador} {/* omitir */}

{constEntera} {return (CONSTENTERA);}

":=" {return (OPAS);}

"+" {return (MAS);}

{identificador} {return (IDENTIFICADOR);}

"(" {return (APAR);}

")" {return (CPAR);}

\n {return (NL);}

. ECHO;

%%




4. BISON

4.1 QU ES BISON?

Bison es un generador de analizadores sintcticos de propsito general, que convierte una descripcin gramatical para una gramtica independiente del contexto

LALR(1) en un programa en C que analice esa gramtica (Parser).

Un fuente de Bison (normalmente un fichero con extensin .y) describe una

gramtica independiente del contexto (G2). El ejecutable que se genera indica si un

fichero de entrada dado pertenece o no al lenguaje descripto por esa gramtica

(Lenguaje XX). La Figura 5 esquematiza el proceso de construccin de un Parser

con Bison.

Figura 5

CODIGO FUENTE BISON (miparser.y) (Conjunto de reglas gramaticales G2)

COMPILADOR BISON

CODIGO FUENTE EN C (miparser.tab.c) (Programa que implementa el reconocimiento de las estructuras sintcticas y ejecuta acciones en consecuencia implementa la semntica del Lenguaje)

COMPILADOR C (gcc)

PROGRAMA EJECUTABLE

(PARSER)

Cdigo Fuente Lenguaje XX

Resultados del Anlisis




4.2 CMO SE ESTRUCTURA UN PROGRAMA BISON?

Como dijimos, Bison recibe como entrada un conjunto de reglas de produccin que describen una gramtica independiente del contexto (G2). Dicha gramtica define las

categoras sintcticas del lenguaje que se est definiendo (Lenguaje XX). Esta entrada

(miparser.y), debe proporcionarse en un archivo de texto, ajustndose a la siguiente

estructura:

Figura 6

Como se observa en la Figura 6, un archivo de entrada en Bison est compuesto por

tres secciones, separadas por una lnea %%: La primera seccin incluye declaraciones

en lenguaje C y declaraciones Bison. La segunda incluye las reglas de produccin

propiamente dichas. Finalmente, la tercera seccin incluye cdigo en C adicional. Las

dos primeras secciones son obligatorias aunque pueden ir vacas.

4.2.1 Declaraciones Las declaraciones en C pueden definir tipos y variables utilizadas luego en las

acciones3. Pueden tambin incluir comandos del preprocesador, tales como la directiva

de inclusin #include para incluir archivos de cabecera que realicen cualquiera de estas

cosas.

3 En general, cuando la presente gua utiliza el trmino acciones, referencia al cdigo C que deber ejecutarse como accin semntica vinculada al reconocimiento de un Token (en Flex) o de una categora sintctica (en Bison).

% {declaraciones en C %} Declaraciones Bison

%%

Reglas de produccin de la gramtica

%%

Cdigo C adicional




Ejemplo

%{

#define YYSTYPE int

#include

char *cadena;

int errores = 0;

%}

Las declaraciones de Bison enuncian los nombres de los smbolos terminales y no terminales de la gramtica. Tambin se puede describir aqu la precedencia de

operadores y los tipos de datos de algunos smbolos (Valores Semnticos).

Todos los nombres de tokens se deben declarar. Los smbolos no terminales deben

ser declarados si necesita especificar el tipo de dato a utilizar para los valores

semnticos.

Figura 7

La forma bsica de declarar un nombre de token (smbolo terminal) es:

%token nombre1 nombre2 nombre3...

De forma alternativa, puede utilizar %left, %right, o %nonassoc en lugar de

%token, si desea especificar precedencia y asociatividad.

Smbolos terminales tokens (que obtenemos del Analizador Lxico). Por convencin se escriben en maysculas.

Smbolos no terminales: se definen luego en las reglas de produccin. Por convencin se escriben en minsculas.




Ejemplo

%%

/* Declaraciones de BISON */

%token ENTERO -> token declarado

%token DIGITO

%token INICIO_PROGRAMA

%token FIN_PROGRAMA

%left '-' '+ -> token de caracter

%left '*' '/'

En este ejemplo, el Analizador Lxico (Scanner) reconocer previamente los tokens

declarados: ENTERO, DIGITO, INICIO_PROGRAMA y FIN_PROGRAMA y se los

proporcionar al Parser que estamos definiendo. En las declaraciones Bison, slo se

est indicando que el Parser deber aceptar esos tokens.

Los operadores aritmticos se estn definiendo en este ejemplo como smbolos

terminales de la gramtica (token de carcter) en dnde el producto y la divisin tienen

mayor prioridad que la resta y la adicin (La precedencia es inversa al orden de las

lneas en la declaracin. Los operadores incluidos en la ltima lnea declarada tienen

mayor precedencia que los declarados en lneas anteriores.). La asociatividad se est

definiendo, mediante la declaracin %left, de izquierda a derecha.

4.2.2 Reglas de Produccin de la Gramtica

Las reglas gramaticales son las producciones de la gramtica. Adems se puede

asociar a cada regla, un conjunto de acciones, cdigo en C, que se ejecutan cuando el

Parser encuentra concordancias con la regla correspondiente.




Una regla gramatical de Bison tiene la siguiente forma general:

Figura 8

La primera regla de produccin definida constituye el axioma de la gramtica.

Si para una regla no se definen componentes del lado derecho de la regla de

produccin, se entiende que la gramtica acepta la cadena vaca ().

Ejemplo

%%

/* Gramtica */

programa: INICIO_PROGRAMA exps FIN_PROGRAMA

exps: exp exps

| exp

;

exp: ENTERO { $$ = $1;}

| exp exp '+' { $$ = $1 + $2;}

| exp exp '-' { $$ = $1 - $2;}

| exp exp '*' { $$ = $1 * $2;}

| exp exp '/' { $$ = $1 / $2; }

resultado: componentes-regla1 {sentencias en C}

| componentes-regla2 {sentencias en C}

...

;

donde:

resultado: no terminal a la izquierda de la produccin.

componentes-regla: secuencia de terminales y no terminales que definen una regla.

sentencias en C: acciones que se ejecutan cuando hay correspondencia con una regla (Es opcional usarlo Asignan valor semntico a la regla).




;

En este ejemplo, el axioma de la gramtica es el no terminal programa. Un

programa se define como un conjunto de expresiones agrupadas entre los tokens

INICIO_PROGRAMA y FIN_PROGRAMA. Se debe tener presente que estos tokens

debern ser previamente reconocidos por el Analizador Lxico y proporcionados al

Parser. Un conjunto de expresiones (exps), se define luego mediante una regla

recursiva a derecha como una expresin (exp) seguida de un conjunto de expresiones

(exps) simplemente como una expresin (exp). Finalmente se define una expresin

(exp) como un ENTERO como una expresin binaria de suma, resta, producto o

cociente en notacin postfija. De esta forma, el ejemplo define la gramtica de un

lenguaje de expresiones algebraicas en notacin postfija (o polaca inversa).

Asociado a cada derivacin de exp, se enuncia una accin (cdigo en C) que define

la semntica asociada a dicha produccin. Es decir, la accin que debe ejecutarse

cuando el Parser utiliza dicha produccin en el reconocimiento de una entrada.

La variable $$ guarda el valor asociado al no terminal que se est definiendo. La

variable $1 guarda el valor asociado al primer componente del lado derecho de la

produccin, la variable $2 guarda el valor asociado al segundo componente del lado

derecho y as sucesivamente. Se debe recordar que Bison genera un Parser LALR(1)

que construye el rbol de anlisis sintctico desde las hojas hacia la raz (Bottom-Up)

mediante operaciones de desplazamiento-reduccin (Shift-Reduce).

As, en nuestro ejemplo, para la entrada 5 + 3, las derivaciones seran:




Figura 9

4.2.3 Cdigo C adicional Se incluyen en esta seccin declaraciones o funciones en C que adicionalmente se

requieran (Por ejemplo: aquellas que son llamadas desde las acciones semnticas

definidas en las reglas de produccin de la gramtica).

Como mnimo debe incluirse la funcin main() para lanzar la ejecucin del

Analizador. Esta funcin debe invocar a la funcin yyparse() en la cul se implementa

el Parser propiamente dicho.

Otras funciones que pueden incluirse son yyerror() para el tratamiento de errores

sintcticos; y yywrap() en donde se incluye el cdigo que desee ejecutarse al finalizar

el proceso de Anlisis.




La funcin yyparse()

El cdigo fuente Bison se convierte, al compilarlo, en una funcin en C llamada

yyparse. Esta funcin, implementa el Analizador; es decir: lee tokens, ejecuta acciones,

y por ltimo retorna cuando se complet el anlisis del cdigo fuente en Lenguaje XX o

cuando se encontr un Error de tipo sintctico del que no puede recuperarse. El valor

devuelto por yyparse es 0 si el anlisis tuvo xito 1 si el anlisis fall.

La funcin yyerror()

Esta funcin es llamada por yyparse() cuando se detecta un error de sintaxis. Si se

define esta funcin, se esta definiendo qu acciones debe ejecutar el Parser cuando se

produce un error sintctico.

Ejemplo

%%

int main(char** argv) {

yyin = fopen(argv[0],"rt");

yyparse();

}

yyerror (char *s) {

printf ("%s\n", s);

++errores;

}

int yywrap() { return 1; }

La variable yyin es un puntero global al archivo de entrada (Cdigo fuente en

Lenguaje XX). Por defecto yyin siempre est asociada a stdin (dispositivo de entrada

estndar, tpicamente el teclado). En el ejemplo, yyin se asocia al archivo de texto

provisto como primer argumento en la llamada a main().




Cuando la funcin yyparse() detecta un error sintctico, llama a yyerror()

pasando como argumento la cadena con el mensaje de error. En el ejemplo se muestra

en pantalla dicho mensaje y se incrementa en uno un contador de errores.

4.3 EJEMPLO DE CDIGO BISON

El siguiente ejemplo en Bison, describe un Parser que aceptar una lista de

instrucciones de asignacin. En cada instruccin una expresin algebraica de adicin

se asigna a un identificador.

%{ #include %} %token IDENTIFICADOR OPAS CONSTENTERA NL MAS APAR CPAR %start instrucciones %% instrucciones : instrucciones instruccion | instruccion

; instruccion : IDENTIFICADOR OPAS expresion NL ; expresion : termino

| expresion MAS termino ; termino : IDENTIFICADOR

| CONSTENTERA | APAR expresion CPAR ;

%% int yyerror (char *s) {

printf ("%s\n", s); } main() { yyparse(); }




5. INTEGRACIN FLEX + BISON

Utilizando Bison junto a Flex, se pueden construir compiladores de lenguajes.

El programa Flex, una vez compilado, implementa la funcin yylex() encargada de

implementar el Scanner. Esta funcin, es llamada luego (cuando se compila el

programa Bison), por la funcin yyparse() para obtener los tokens.

Veamos a continuacin el ejemplo completo de integracin Flex + Bison.

Ejemplo Completo

Cdigo Fuente del Analizador Lxico (Scanner) en Flex

%{ #include /* y.tab.h contiene las definiciones de todos los %tokens que aparecen el fuente Bison. De esta forma se vinculan Flex y Bison*/ #include "y.tab.h" %} separador ([ \t])+ letra [a-zA-Z] digito [0-9] identificador {letra}({letra}|{digito})* constEntera {digito}({digito})* %% {separador} {/* omitir */} /*se indica al Parser el reconocimiento de cada token*/ {constEntera} {return (CONSTENTERA);} ":=" {return (OPAS);} "+" {return (MAS);} {identificador} {return (IDENTIFICADOR);} "(" {return (APAR);} ")" {return (CPAR);} \n {return (NL);} . ECHO; %%




Cdigo Fuente del Analizador Sintctico (Parser) en Bison %{ /* Fichero instrucciones.y */ #include %} /* Se declaran los tokens que reconocer el Scanner*/ %token IDENTIFICADOR OPAS CONSTENTERA NL MAS APAR CPAR /* Se indica que el axioma es instrucciones - esta lnea podra obviarse*/ %start instrucciones %% /* Se define el conjunto de reglas de produccin de la gramtica*/ instrucciones : instrucciones instruccion | instruccion

; instruccion : IDENTIFICADOR OPAS expresion NL ; expresion : termino

| expresion MAS termino ; termino : IDENTIFICADOR

| CONSTENTERA | APAR expresion CPAR ;

%% int yyerror (char *s) /* Llamada por yyparse ante un error */ {

printf ("%s\n", s); /* Esta implementacin por defecto valdr */ /* Si no se crea esta funcin, habr que enlazar con ly en el momento de compilar para usar una implementacin por defecto */

} main() { /* Acciones a ejecutar antes del anlisis */ yyparse(); /* Acciones a ejecutar despus del anlisis */ }




6. INSTALACIN DE LAS HERRAMIENTA

En esta seccin se enuncian brevemente los pasos a seguir para instalar Flex y Bison en nuestra computadora.

1. Ejecutar el programa de instalacin de Flex

2. Ejecutar el programa de instalacin de Bison

3. Agregar en la variable de entorno Path, la ruta a las carpetas donde se encuentran

los programas ejecutables de Flex , Bison y gcc

Path = %SystemRoot%\system32; C:\Archivos de programa\GnuWin32\bin;C:\Dev-Cpp\bin

Importante: Se supone que se ha instalado previamente Dev C++ simplemente el compilador gcc "GNU Compiler Collection".




7. PASOS PARA COMPILAR NUESTRO CDIGO FLEX + BISON

Una vez instaladas las herramientas y escrito el cdigo fuente del Scanner en Flex y el Parser en Bison para el Lenguaje XX, se deber compilar de acuerdo a los siguientes

pasos:

1. Compilar el cdigo fuente Bison

bison d fuente.y

2. Compilar el cdigo fuente Flex

flex fuente.l

3. Compilar el cdigo C generado para obtener el ejecutable

gcc o fuente fuente.tab.c lex.yy.c -lm

Importante: Puede utilizarse cualquier procesador de textos para escribir los archivos de cdigo Flex y Bison (fuente.l y fuente.y). Una sugerencia es utilizar el

editor de GoldParser.

Documents

Guia Introduccion Flex Bison