Flex, versión 2.5 - Incompatibilidades con lex y POSIX

flex es una reescritura de la herramienta lex del Unix de AT&T (aunque las dos implementaciones no comparten ningún código), con algunas extensiones e incompatibilidades, de las que ambas conciernen a aquellos que desean escribir analizadores aceptables por cualquier implementación. Flex sigue completamente la especificación POSIX de lex, excepto que cuando se utiliza `%pointer' (por defecto), una llamada a `unput()' destruye el contenido de yytext, que va en contra de la especificación POSIX.

En esta sección comentaremos todas las áreas conocidas de incompatibilidades entre flex, lex de AT&T, y la especificación POSIX.

La opción `-l' de flex activa la máxima compatibilidad con la implementación original de lex de AT&T, con el coste de una mayor pérdida de rendimiento en el analizador generado. Indicamos más abajo qué incompatibilidades pueden superarse usando la opción `-l'.

flex es totalmente compatible con lex con las siguientes excepciones:

• La variable interna del analizador de lex sin documentar yylineno no se ofrece a menos que se use `-l' ó `%option yylineno'. yylineno debería gestionarse por buffer, en lugar de por analizador (simple variable global). yylineno no es parte de la especificación POSIX.
• La rutina `input()' no es redefinible, aunque podría invocarse para leer los caracteres que siguen a continuación de lo que haya sido reconocido por una regla. Si `input()' se encuentra con un fin-de-fichero se realiza el procesamiento de `yywrap()' normal. `input()' retorna un fin-de-fichero "real" como EOF. La entrada en su lugar se controla definiendo la macro YY_INPUT. La restricción de flex de que `input()' no puede redefinirse va de acuerdo a la especificación POSIX, que simplemente no especifica ninguna manera de controlar la entrada del analizador que no sea haciendo una asignación inicial a yyin.
• La rutina `unput()' no es redefinible. Esta restricción va de acuerdo a POSIX.
• Los analizadores de flex no son tan reentrantes como los analizadores de lex. En particular, si tiene un analizador interactivo y un gestor de interrupción con long-jumps fuera del analizador, y el analizador a continuación se invoca de nuevo, podría obtener el siguiente mensaje: fatal flex scanner internal error--end of buffer missed

Para volver al analizador, primero utilice yyrestart( yyin );
Vea que esta llamada eliminará cualquier entrada en el buffer; normalmente esto no es un problema con un analizador interactivo. Dese cuenta también de que las clases analizadoras en C++ son reentrantes, así que si usar C++ es una opción para usted, debería utilizarla. See section Generando escáneres en C++∞, para los detalles.

• `output()' no se provee. La salida desde la macro `ECHO' se hace al puntero de fichero yyout (por defecto a stdout). `output()' no es parte de la especificación POSIX.
• lex no acepta condiciones de arranque exclusivas (%x), aunque están en la especificación POSIX.
• Cuando se expanden las definiciones, flex las encierra entre paréntesis. Con lex, lo siguiente: NOMBRE [A-Z][A-Z0-9]*

no reconocerá la cadena "foo" porque cuando la macro se expanda la regla es equivalente a "foo[A-Z][A-Z0-9]*?" y la precedencia es tal que el `?' se asocia con "[A-Z0-9]*". Con flex, la regla se expandirá a "foo([A-Z][A-Z0-9]*)?" y así la cadena "foo" se reconocerá. Fíjese que si la definición comienza con `^' o finaliza con `$' entonces no se expande con paréntesis, para permitir que estos operadores aparezcan en las definiciones sin perder su significado especial. Pero los operadores `<s>, /', y `<<EOF>>' no pueden utilizarse en una definición de flex. El uso de `-l' produce en el comportamiendo de lex el no poner paréntesis alrededor de la definición. La especificación de POSIX dice que la definición debe ser encerrada entre paréntesis.

• Algunas implementaciones de lex permiten que la acción de una regla comience en una línea separada, si el patrón de la regla tiene espacios en blanco al final: %%

foo|bar<espacio aquí>
{ foobar_action(); }
flex no dispone de esta propiedad.

• La opción `%r' de lex (generar un analizador Ratfor) no se ofrece. No es parte de la especificación de POSIX.
• Después de una llamada a `unput()', el contenido de yytext está indefinido hasta que se reconozca el próximo token, a menos que el analizador se haya construido usando `%array'. Este no es el caso de lex o la especificación de POSIX. La opción `-l' elimina esta incompatibilidad.
• La precedencia del operador `{}' (rango numérico) es diferente. lex interpreta "abc{1,3}" como "empareja uno, dos, o tres apariciones de 'abc'", mientras que flex lo interpreta como "empareja 'ab' seguida de una, dos o tres apariciones de 'c'". Lo último va de acuerdo con la especificación de POSIX.
• La precedencia del operador `^' es diferente. lex interpreta "^foo|bar" como "empareja bien 'foo' al principio de una línea, o 'bar' en cualquier lugar", mientras que flex lo interpreta como "empareja 'foo' o 'bar' si vienen al principio de una línea". Lo último va de acuerdo con la especificación de POSIX.
• Las declaraciones especiales del tamaño de las tablas tal como `%a' que reconoce lex no se requieren en los analizadores de flex; flex los ignora.
• El identificador FLEX_SCANNER se #define de manera que los analizadores podrían escribirse para ser procesados con flex o con lex. Los analizadores también incluyen YY_FLEX_MAJOR_VERSION y YY_FLEX_MINOR_VERSION indicando qué versión de flex generó el analizador (por ejemplo, para la versión 2.5, estas definiciones serán 2 y 5 respectivamente).

Las siguientes propiedades de flex no se incluyen en lex o la especificación POSIX:

analizadores en C++
%option
ámbitos de condiciones de arranque
pilas de condiciones de arranque
analizadores interactivos/no-interactivos
yy_scan_string() y sus amigas
yyterminate()
yy_set_interactive()
yy_set_bol()
YY_AT_BOL()
<<EOF>>
<*>
YY_DECL
YY_START
YY_USER_ACTION
YY_USER_INIT
directivas #line
%{}'s alrededor de acciones
varias acciones en una línea

más casi todas las banderas de flex. La última propiedad en la lista se refiere al hecho de que con flex puede poner varias acciones en la misma línea, sepradas con punto y coma, mientras que con lex, lo siguiente

foo handle_foo(); ++num_foos_seen;

se trunca (sorprendentemente) a

foo handle_foo();

flex no trunca la acción. Las acciones que no se encierran en llaves simplemente se terminan al final de la línea.