PDF de programación - flex es 2.5

Flex, versión 2.5

Un generador de analizadores léxicos rápidos.
Edición 2.5, Abril 1995

Vern Paxson

Copyright c 1990 The Regents of the University of California. All rights reserved.
This code is derived from software contributed to Berkeley by Vern Paxson.
The United States Government has rights in this work pursuant to contract no. DE-AC03-
76SF00098 between the United States Department of Energy and the University of California.
Redistribution and use in source and binary forms with or without modification are permitted
provided that: (1) source distributions retain this entire copyright notice and comment, and (2)
distributions including binaries display the following acknowledgement: “This product includes
software developed by the University of California, Berkeley and its contributors” in the doc-
umentation or other materials provided with the distribution and in all advertising materials
mentioning features or use of this software. Neither the name of the University nor the names of
its contributors may be used to endorse or promote products derived from this software without
specific prior written permission.
THIS SOFTWARE IS PROVIDED “AS IS” AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

Capítulo 1: Introducción

1

1 Introducción

Este manual describe flex, una herramienta para la generación de programas que reali-
zan concordancia de patrones en texto. El manual incluye a la vez secciones de tutorial y de
referencia:

Descripción

una breve introducción a la herramienta

Algunos Ejemplos Simples
Formato del Fichero de Entrada
Patrones

las expresiones regulares extendidas que utiliza flex

Cómo se Empareja la Entrada

las reglas para determinar lo que ha concordado

Acciones

cómo especificar qué hacer cuando concuerde un patrón

El Escáner Generado

detalles respecto al escáner que produce flex; cómo controlar la fuente de entrada

Condiciones de Arranque

la introdución de contexto en sus escáneres, y conseguir "mini-escáneres"

Múltiples Buffers de Entrada

cómo manipular varias fuentes de entrada; cómo analizar cadenas en lugar de fiche-
ros.

Reglas de Fin-de-Fichero

reglas especiales para reconocer el final de la entrada

Macros Misceláneas

un sumario de macros disponibles para las acciones

Valores Disponibles para el Usuario

un sumario de valores disponibles para las acciones

Interfaz con Yacc

conectando escáneres de flex junto con analizadores de yacc

Opciones

opciones de línea de comando de flex, y la directiva "%option"

Consideraciones de Rendimiento

cómo hacer que sus analizadores vayan tan rápido como sea posible

Generando Escáneres en C++

la facilidad (experimental) para generar analizadores léxicos como clases de C++

Incompatibilidades con Lex y POSIX

cómo flex difiere del lex de AT&T y del lex estándar de POSIX

Diagnósticos

esos mensajes de error producidos por flex (o por los escáneres que este genera) cuyo
significado podría no ser evidente

Ficheros

los ficheros usados por flex

Deficiencias / Errores

problemas de flex conocidos

Ver También

otra documentación, herramientas relacionadas

Autor

incluye información de contacto

Capítulo 2: Descripción

2

2 Descripción

flex es una herramienta para generar escáneres: programas que reconocen patrones léxicos
en un texto. flex lee los ficheros de entrada dados, o la entrada estándar si no se le ha indicado
ningún nombre de fichero, con la descripción de un escáner a generar. La descripción se encuentra
en forma de parejas de expresiones regulares y código C, denominadas reglas. flex genera como
salida un fichero fuente en C, ‘lex.yy.c’, que define una rutina ‘yylex()’. Este fichero se
compila y se enlaza con la librería ‘-lfl’ para producir un ejecutable. Cuando se arranca el
fichero ejecutable, este analiza su entrada en busca de casos de las expresiones regulares. Siempre
que encuentra uno, ejecuta el código C correspondiente.

Capítulo 3: Algunos ejemplos simples

3

3 Algunos ejemplos simples

En primer lugar veremos algunos ejemplos simples para una toma de contacto con el uso de
flex. La siguiente entrada de flex especifica un escáner que siempre que encuentre la cadena
"username" la reemplazará por el nombre de entrada al sistema del usuario:

%%
username

printf( "%s", getlogin() );

Por defecto, cualquier texto que no reconozca el analizador léxico de flex se copia a la salida,
así que el efecto neto de este escáner es copiar su fichero de entrada a la salida con cada aparición
de "username" expandida. En esta entrada, hay solamente una regla. "username" es el patrón
y el "printf" es la acción. El "%%" marca el comienzo de las reglas.

Aquí hay otro ejemplo simple:

int num_lineas = 0, num_caracteres = 0;

++num_lineas; ++num_caracteres;
++num_caracteres;

%%
\n
.

%%
main()

{
yylex();
printf( "# de líneas = %d, # de caracteres. = %d\n",

num_lineas, num_caracteres );

}

Este analizador cuenta el número de caracteres y el número de líneas en su entrada (no
produce otra salida que el informe final de la cuenta). La primera línea declara dos variables
globales, "num lineas" y "num caracteres", que son visibles al mismo tiempo dentro de ‘yylex()’
y en la rutina ‘main()’ declarada después del segundo "%%". Hay dos reglas, una que empareja
una línea nueva ("\n") e incrementa la cuenta de líneas y la cuenta de caracteres, y la que
empareja cualquier caracter que no sea una línea nueva (indicado por la expresión regular ".").

Un ejemplo algo más complicado:

/* escáner para un lenguaje de juguete al estilo de Pascal */

%{
/* se necesita esto para la llamada a atof() más abajo */
#include <math.h>
%}

DIGITO
ID

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

%%

{DIGITO}+

{
printf( "Un entero: %s (%d)\n", yytext,

atoi( yytext ) );

}

Capítulo 3: Algunos ejemplos simples

4

{DIGITO}+"."{DIGITO}*

{

printf( "Un real: %s (%g)\n", yytext,

atof( yytext ) );

}

if|then|begin|end|procedure|function

{

printf( "Una palabra clave: %s\n", yytext );
}

{ID}

printf( "Un identificador: %s\n", yytext );

"+"|"-"|"*"|"/"

printf( "Un operador: %s\n", yytext );

"{"[^}\n]*"}"

/* se come una linea de comentarios */

[ \t\n]+

/* se come los espacios en blanco */

printf( "Caracter no reconocido: %s\n", yytext );

.

%%

main( argc, argv )
int argc;
char **argv;

{
++argv, --argc; /* se salta el nombre del programa */
if ( argc > 0 )

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

else

yyin = stdin;

yylex();
}

Esto podría ser los comienzos de un escáner simple para un lenguaje como Pascal. Este

identifica diferentes tipos de tokens e informa a cerca de lo que ha visto.
Los detalles de este ejemplo se explicarán en las secciones siguientes.

Capítulo 4: Formato del fichero de entrada

5

4 Formato del fichero de entrada

El fichero de entrada de flex está compuesto de tres secciones, separadas por una línea donde

aparece únicamente un ‘%%’ en esta:

definiciones
%%
reglas
%%
código de usuario

La sección de definiciones contiene declaraciones de definiciones de nombres sencillas para
simplificar la especificación del escáner, y declaraciones de condiciones de arranque, que se
explicarán en una sección posterior. Las definiciones de nombre tienen la forma:

nombre definición

El "nombre" es una palabra que comienza con una letra o un subrayado (‘_’) seguido por
cero o más letras, dígitos, ‘_’, o ‘-’ (guión). La definición se considera que comienza en el primer
caracter que no sea un espacio en blanco siguiendo al nombre y continuando hasta el final de
la línea. Posteriormente se puede hacer referencia a la definición utilizando "{nombre}", que se
expandirá a "(definición)". Por ejemplo,

DIGITO
ID

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

define "DIGITO" como una expresión regular que empareja un dígito sencillo, e "ID" como
una expresión regular que empareja una letra seguida por cero o más letras o dígitos. Una
referencia posterior a

{DIGITO}+"."{DIGITO}*

es idéntica a

([0-9])+"."([0-9])*

y empareja uno o más dígitos seguido por un ‘.’ seguido por cero o más dígitos.

La sección de reglas en la entrada de flex contiene una serie de reglas de la forma:

patrón

acción

donde el patrón debe estar sin sangrar y la acción debe comenzar en la misma línea.

Ver Capítulo 7 [Acciones], página 10, para una descripción más amplia sobre patrones y

acciones.

Finalmente, la sección de código de usuario simplemente se copia a ‘lex.yy.c’ literalmente.
Esta sección se utiliza para rutinas de complemento que llaman al escáner o son llamadas por
este. La presencia de esta sección es opcional; Si se omite, el segundo ‘%%’ en el fichero de entrada
se podría omitir también.

En las secciones de definiciones y reglas, cualquier texto sangrado o encerrado entre ‘%{’ y
‘%}’ se copia íntegramente a la salida (sin los %{}’s). Los %{}’s deben aparecer sin sangrar en
líneas ocupadas únicamente por estos.

En la sección de reglas, cualquier texto o %{} sangrado que aparezca antes de la primera
regla podría utilizarse para declarar variables que son locales a la rutina de análisis y (después
de las declaraciones) al código que debe ejecutarse siempre que se entra a la rutina de análisis.
Cualquier otro texto sangrado o %{} en la sección de reglas sigue copiándose a la salida, pero
su significado no está bien definido y bien podría causar errores en tiempo de compilación (esta
propiedad se presenta para conformidad con POSIX; para otras características similares) ver
Capítulo 18 [Incompatibilidades con lex y POSIX], página 44)

En la sección de definiciones (pero no en la sección de reglas), un comentario sin sangría (es
decir, una línea comenzando con "/*") también se copia literalmente a la salida hasta el próximo
"*/".

Capítulo 5: Patrones

6

5 Patrones

Los patrones en la entrada se escriben utilizando un conjunto extendido de expresiones re-

gulares. Estas so