Flex, versión 2.5 - Patrones

Los patrones en la entrada se escriben utilizando un conjunto extendido de expresiones regulares. Estas son:

`x' empareja el caracter `x' `.' cualquier caracter (byte) excepto una línea nueva `[xyz]' una "clase de caracteres"; en este caso, el patrón empareja una `x', una `y', o una `z' `[abj-oZ]' una "clase de caracteres" con un rango; empareja una `a', una `b', cualquier letra desde la `j' hasta la `o', o una `Z' `[^A-Z]' una "clase de caracteres negada", es decir, cualquier caracter menos los que aparecen en la clase. En este caso, cualquier caracter EXCEPTO una letra mayúscula. `[^A-Z\n]' cualquier caracter EXCEPTO una letra mayúscula o una línea nueva `r*' cero o más r's, donde r es cualquier expresión regular `r+' una o más r's `r?' cero o una r (es decir, "una r opcional") `r{2,5}' donde sea de dos a cinco r's `r{2,}' dos o más r's `r{4}' exactamente 4 r's `{nombre}' la expansión de la definición de "nombre" (ver más abajo) `"[xyz]\"foo"' la cadena literal: [xyz]"foo `\x' si x es una `a', `b', `f', `n', `r', `t', o `v', entonces la interpretación ANSI-C de \x. En otro caso, un literal `x' (usado para indicar operadores tales como `*') `\0' un caracter NUL (código ASCII 0) `\123' el caracter con valor octal 123 `\x2a' el caracter con valor hexadecimal 2a `(r)' empareja una R; los paréntesis se utilizan para anular la precedencia (ver más abajo)

`rs' la expresión regular r seguida por la expresión regular s; se denomina "concatenación"

`r|s' bien una r o una s

`r/s' una r pero sólo si va seguida por una s. El texto emparejado por s se incluye cuando se determina si esta regla es el "emparejamiento más largo", pero se devuelve entonces a la entrada antes que se ejecute la acción. Así que la acción sólo ve el texto emparejado por r. Este tipo de patrones se llama "de contexto posterior". (Hay algunas combinaciones de r/s que flex no puede emparejar correctamente. See section Deficiencias / Errores∞, las notas a cerca del "contexto posterior peligroso".) `^r' una r, pero sólo al comienzo de una línea (es decir, justo al comienzo del análisis, o a la derecha después de que se haya analizado una línea nueva). `r$' una r, pero sólo al final de una línea (es decir, justo antes de una línea nueva). Equivalente a "r/\n". Fíjese que la noción de flex de una "línea nueva" es exáctamente lo que el compilador de C utilizado para compilar flex interprete como `\n'; en particular, en algunos sistemas DOS debe filtrar los \r's de la entrada used mismo, o explícitamente usar r/\r\n para "r$". `<s>r' una r, pero sólo en la condición de arranque s (See section Condiciones de arranque∞, para una discusión sobre las condiciones de arranque) `<s1,s2,s3>r' lo mismo, pero en cualquiera de las condiciones de arranque s1, s2, o s3 `<*>r' una r en cualquier condición de arranque, incluso una exclusiva. `<<EOF>>' un fin-de-fichero `<s1,s2><<EOF>>' un fin-de-fichero en una condición de arranque s1 ó s2

Fíjese que dentro de una clase de caracteres, todos los operadores de expresiones regulares pierden su significado especial excepto el caracter de escape (`\') y los operadores de clase de caracteres, `-', `]', y, al principio de la clase, `^'.

Las expresiones regulares en el listado anterior están agrupadas de acuerdo a la precedencia, desde la precedencia más alta en la cabeza a la más baja al final. Aquellas agrupadas conjuntamente tienen la misma precedencia. Por ejemplo,

foo|bar*

es lo mismo que

(foo)|(ba(r*))

ya que el operador `*' tiene mayor precedencia que la concatenación, y la concatenación más alta que el operador `|'. Este patrón por lo tanto empareja bien la cadena "foo" o la cadena "ba" seguida de cero o más r's. Para emparejar "foo" o, cero o más "bar"'s, use:

foo|(bar)*

y para emparejar cero o más "foo"'s o "bar"'s:

(foo|bar)*

Además de caracteres y rangos de caracteres, las clases de caracteres pueden también contener expresiones de clases de caracteres. Son expresiones encerradas entre los delimitadores `[:' y `:]' (que también deben aparecer entre el `[' y el `]' de la clase de caracteres; además pueden darse otros elementos dentro de la clase de caracteres). Las expresiones válidas son:

[:alnum:] [:alpha:] [:blank:]
[:cntrl:] [:digit:] [:graph:]
[:lower:] [:print:] [:punct:]
[:space:] [:upper:] [:xdigit:]

Todas estas expresiones designan un conjunto de caracteres equivalentes a la correspondiente función estándar `isXXX' de C. Por ejemplo, `[:alnum:]' designa aquellos caracteres para los cuales `isalnum()' devuelve verdadero --es decir, cualquier caracter alfabético o numérico. Algunos sistemas no ofrecen `isblank()', así que flex define `[:blank:]' como un espacio en blanco o un tabulador.

Por ejemplo, las siguientes clases de caracteres son todas equivalentes:

:alnum:
[[:alpha:][:digit:]]
[[:alpha:]0-9]
[a-zA-Z0-9]

Si su escáner ignora la distinción entre mayúsculas y minúsculas (la bandera `-i'), entonces `[:upper:]' y `[:lower:]' son equivalentes a `[:alpha:]'.

Algunas notas sobre los patrones:

• Una clase de caracteres negada tal como el ejemplo "[^A-Z]" anterior emparejará una línea nueva a menos que "\n" (o una secuencia de escape equivalente) sea uno de los caracteres presentes explícitamente en la clase de caracteres negada (p.ej., "[^A-Z\n]"). Esto es diferente a cómo muchas de las otras herramientas de expresiones regulares tratan las clases de caracteres negadas, pero desafortunadamente la inconsistencia está fervientemente enrraizada históricamente. Emparejar líneas nuevas significa que un patrón como [^"]* puede emparejar la entrada completa a menos que haya otra comilla en la entrada.
• Una regla puede tener lo más una instancia del contexto posterior (el operador `/' o el operador `$'). La condición de arranque, los patrones `^', y "<<EOF>>" pueden aparecer solamente al principio de un patrón, y, al igual que con `/' y `$', no pueden agruparse dentro de paréntesis. Un `^' que no aparezca al principio de una regla o un `$' que no aparezca al final de una regla pierde sus propiedades especiales y es tratado como un caracter normal. Lo siguiente no está permitido: foo/bar$

<sc1>foo<sc2>bar
Fíjese que la primera regla se puede escribir como "foo/bar\n". En el siguiente ejemplo un `$' o un `^' es tratado como un caracter normal: foo|(bar$)
foo|^bar
Si lo que se desea es un "foo" o un "bar" seguido de una línea nueva, puede usarse lo siguiente (la acción especial `|' se explica en la section Acciones∞.): foo |
bar$ /* la acción va aquí */
Un truco parecido funcionará para emparejar un "foo" o, un "bar" al principio de una línea.