Expresiones regulares
#Cabecera
#include <core/regex.h>
#Funciones
| RegEx* | regex_create (...) |
| void | regex_destroy (...) |
| bool_t | regex_match (...) |
| bool_t | regex_search (...) |
Las expresiones regulares definen un patrón de texto que puede utilizarse para buscar o comparar cadenas. NAppGUI sigue la sintaxis de las expresiones regulares extendidas de POSIX (ERE), la que utilizan grep -E o awk, con las extensiones más habituales de Perl que soporta RE2. Los patrones pueden probarse en regex101.com seleccionando la variante Golang.
- Utiliza regex_create para crear una expresión regular.
- Utiliza regex_match para comprobar si una cadena completa cumple con el patrón.
- Utiliza regex_search para encontrar la primera subcadena que cumple con el patrón.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
RegEx *regex = regex_create(".*\\.txt", NULL, NULL); const char_t *str[] = { "file01.txt", "image01.png", "sun01.jpg", "films.txt", "document.pdf"}; uint32_t i, n = sizeof(str) / sizeof(char_t*); for (i = 0; i < n; ++i) { if (regex_match(regex, str[i]) == TRUE) bstd_printf("YES: %s\n", str[i]); else bstd_printf("NO: %s\n", str[i]); } regex_destroy(®ex); |
1 2 3 4 5 |
YES: file01.txt NO: image01.png NO: sun01.jpg YES: films.txt NO: document.pdf |
1 2 3 4 5 6 7 |
RegEx *regex = regex_create("[0-9]+\\.[0-9]+", NULL, NULL); uint32_t pos, len; if (regex_search(regex, "NAppGUI version 1.7", &pos, &len) == TRUE) bstd_printf("Found at %d, length %d\n", pos, len); regex_destroy(®ex); |
1 |
Found at 16, length 3 |
#1. Definir patrones
Podemos construir una expresión regular a partir de una cadena de texto, siguiendo estas reglas:
- Un patrón cadena se corresponde únicamente con esa misma cadena. Los caracteres
. [ ] ( ) | * + ? { } ^ $y el backslash tienen un significado especial y deben escaparse para utilizarlos como caracteres. - Un punto
'.'equivale a "cualquier carácter", excepto el salto de línea. - Los corchetes
'[aeiou]'definen una clase de caracteres: uno cualquiera de los caracteres que contienen. Un guión entre dos caracteres establece un rango, utilizando el código Unicode de ambos extremos. Un circunflejo al principio'[^aeiou]'niega la clase. - Dentro de los corchetes, los caracteres especiales pierden su significado. Un
']'al principio y un guión al principio o al final son caracteres normales. Fuera de los corchetes, el guión siempre es un carácter normal. - Dentro de los corchetes pueden utilizarse las clases POSIX (Tabla 1). Solo incluyen caracteres ASCII. La forma
[[:^alpha:]]niega cualquiera de ellas.
"hello" --> {"hello"}
|
"h.llo" --> {"hello", "htllo", "hällo", "h5llo", ...}
|
"h[aeiou]llo" --> {"hallo", "hello", "hillo", "hollo", "hullo"}
"[A-Z]ello" --> {"Aello", "Bello", "Cello", ..., "Zello"}
"[^0-9]" --> {"a", "b", "-", "ñ", ...}
'[A-Z]': (65-90) (ABCDEFGHIJKLMNOPQRSTUVWXYZ)
'[0-9]': (48-57) (0123456789)
'[á-ú]': (225-250) (áâãäåæçèéêëìíîïðñòóôõö÷øùú)
|
"[*.?]" --> {"*", ".", "?"}
"[]a]" --> {"]", "a"}
"[a-]" --> {"a", "-"}
"file-1" --> {"file-1"}
|
"[[:alpha:]]+" --> {"a", "Hello", "XYZ", ...}
"[[:digit:][:upper:]]" --> {"0", "9", "A", "Z", ...}
|
| Clase | Caracteres |
[:alnum:] |
Letras y dígitos. |
[:alpha:] |
Letras. |
[:ascii:] |
Caracteres ASCII. |
[:blank:] |
Espacio y tabulador. |
[:cntrl:] |
Caracteres de control. |
[:digit:] |
Dígitos. |
[:graph:] |
Caracteres visibles. |
[:lower:] |
Letras minúsculas. |
[:print:] |
Caracteres visibles y espacio. |
[:punct:] |
Signos de puntuación. |
[:space:] |
Espacios en blanco. |
[:upper:] |
Letras mayúsculas. |
[:word:] |
Letras, dígitos y guión bajo. |
[:xdigit:] |
Dígitos hexadecimales. |
Al igual que los objetos String, los patrones se expresan en UTF-8, por tanto, puede utilizarse todo el conjunto Unicode para crear expresiones regulares.
- La barra vertical
'|'separa alternativas. Tiene la menor prioridad. - Los paréntesis
'(he*llo)'permiten agrupar una expresión regular, de tal forma que se comporte como un único carácter. También se acepta la forma'(?:...)'. - Los cuantificadores (Tabla 2) establecen cuántas veces puede aparecer el elemento anterior.
"hello|bye" --> {"hello", "bye"}
"h(e|a)llo" --> {"hello", "hallo"}
"red|blue|" --> {"red", "blue", ""}
|
"(hello)*" --> {"", "hello", "hellohello", "hellohellohello", ... }
"(he*llo)ZZ" --> {"hlloZZ", "helloZZ", "heelloZZ", "heeelloZZ", ... }
|
| Cuantificador | Repeticiones |
* |
Cero o más veces. |
+ |
Una o más veces. |
? |
Cero o una vez. |
{m} |
Exactamente m veces. |
{m,} |
Al menos m veces. |
{m,n} |
Entre m y n veces (máximo 1000). |
"he*llo" --> {"hllo", "hello", "heello", "heeello", ...}
"FILE_[0-9]*.PNG" --> {"FILE_.PNG", "FILE_0.PNG", "FILE_01.PNG", ...}
"colou?r" --> {"color", "colour"}
"[a-z]+" --> {"a", "b", "ab", "hello", ...}
"[0-9]{2,4}" --> {"12", "123", "1234"}
|
Se acepta un cuantificador seguido de '?' (no voraz en otros motores), pero se comporta como el normal. Ver Comparar y buscar.
- El circunflejo
'^'y el dólar'$'marcan el principio y el final de la cadena. Son útiles con regex_search. - El backslash introduce secuencias de escape (Tabla 3).
"^ERROR" "ERROR: disk" --> pos=0, len=5 "^ERROR" "disk ERROR" --> FALSE "\.txt$" "doc.txt" --> pos=3, len=4 |
| Secuencia | Significado |
\. \* \( \[ ... |
El propio carácter especial. |
\t \n \r \f \v \a |
Caracteres de control. |
\xhh \x{hhhh} |
Carácter Unicode a partir de su código hexadecimal. |
\d \D |
Dígito [0-9] y su negación. |
\w \W |
Carácter de palabra [0-9A-Za-z_] y su negación. |
\s \S |
Espacio en blanco (espacio, tabulador, salto de línea, retorno de carro, salto de página) y su negación. |
\A \z |
Principio y final de la cadena. |
"\(he\*\-llo\)" --> {"(he*-llo)"}
"\d{1,3}[dwmy]" --> {"7d", "30w", "365y", ...}
|
Recuerda que para expresiones insertadas como constantes en código C, el carácter backslash se representa con doble barra "\\(he\\*\\-llo\\)".
#2. Comparar y buscar
regex_match comprueba si la cadena completa cumple con el patrón. regex_search encuentra una subcadena que cumple con el patrón y devuelve su posición y longitud, en caracteres. Cuando hay varias coincidencias posibles, devuelve la que empieza más a la izquierda y, desde ahí, la más larga (criterio POSIX).
"[0-9]+" "abc123def" --> pos=3, len=3 ("123")
"a|ab" "xab" --> pos=1, len=2 ("ab")
"x*" "bxx" --> pos=0, len=0 ("")
"^ERR" "disk ERR" --> FALSE
"txt$" "a.txt" --> pos=2, len=3 ("txt")
|
Motores como Perl, Python o JavaScript devuelven la primera alternativa que coincide. Con alternativas o cuantificadores, la longitud de la coincidencia puede ser distinta. En"a|ab", ellos devuelven"a"y NAppGUI devuelve"ab".
Algunas características de otros motores no están soportadas. La mayoría requieren backtracking y son incompatibles con los autómatas finitos, que garantizan un tiempo lineal respecto a la longitud de la cadena.
- Referencias hacia atrás, lookahead y lookbehind.
- Grupos de captura. Todos los grupos son de no captura.
- Modificadores (sin distinción de mayúsculas, multilínea), límites de palabra y clases de propiedades Unicode.
#3. Lenguajes regulares y autómatas
Los lenguajes regulares son aquellos que se definen de forma recursiva utilizando tres operaciones básicas sobre el conjunto de carácteres (o símbolos) disponibles. Se pueden describir mediante las expresiones regulares comentadas anteriormente.
- Cada carácter 'a' es un lenguaje regular 'A'.
- La unión de dos lenguajes regulares, es un lenguaje regular A∪B.
- La concatenación de dos lenguajes regulares, es un lenguaje regular A·B.
- La clausura de un lenguaje regular, es un lenguaje regular A*. Aquí es donde entra en juego la recursión.
En este contexto los símbolos son todos los carácteres Unicode. Pero pueden definirse lenguajes basados en otros alfabetos, incluido el binario {0, 1}.
Para reconocer si una cadena pertenece o no a un determinado lenguaje regular, es necesario construir un Autómata Finito basándonos en las reglas reflejadas en (Figura 1).
#regex_create ()
Crea una expresión regular a partir de un patrón.
RegEx* regex_create(const char_t *pattern, rerror_t *error, uint32_t *errpos);
| pattern | Patrón de búsqueda. |
| error | Código de error si el patrón no es válido. Puede ser |
| errpos | Posición (en caracteres, empezando en 0) donde se detecta el error. |
Retorna
Expresión regular (autómata) o NULL si el patrón no es válido.
Observaciones
Ver Definir patrones.
#regex_destroy ()
Destruye una expresión regular.
void regex_destroy(RegEx **regex);
| regex | Expresión regular. Será puesto a |
#regex_match ()
Comprueba si una cadena completa cumple el patrón de búsqueda.
bool_t regex_match(const RegEx *regex, const char_t *str);
| regex | Expresión regular. |
| str | Cadena a evaluar. |
Retorna
TRUE si la cadena es aceptada por la expresión regular.
#regex_search ()
Encuentra la primera subcadena que cumple el patrón de búsqueda.
bool_t regex_search(const RegEx *regex, const char_t *str, uint32_t *pos, uint32_t *len);
| regex | Expresión regular. |
| str | Cadena donde buscar. |
| pos | Posición (en caracteres, empezando en 0) de la subcadena. Puede ser |
| len | Longitud (en caracteres) de la subcadena. Puede ser |
Retorna
TRUE si se ha encontrado una subcadena.
Observaciones
Ver Comparar y buscar.


