SDK Multiplataforma en C logo
EspañolEnglish
SDK Multiplataforma en C

Expresiones regulares

❮ Anterior
Siguiente ❯

#Cabecera

#include <core/regex.h>


#Funciones

RegEx*regex_create (...)
voidregex_destroy (...)
bool_tregex_match (...)
bool_tregex_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.
  • Listado 1: Uso de expresiones regulares.
     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);
    
    Resultado de (Listado 1).
    1
    2
    3
    4
    5
    
    YES: file01.txt
    NO:  image01.png
    NO:  sun01.jpg
    YES: films.txt
    NO:  document.pdf
    
    Listado 2: Búsqueda de un patrón dentro de una cadena.
    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);
    
    Resultado de (Listado 2).
    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.
  • Listado 3:
    "hello" --> {"hello"}
    
  • Un punto '.' equivale a "cualquier carácter", excepto el salto de línea.
  • Listado 4:
    "h.llo" --> {"hello", "htllo", "hällo", "h5llo", ...}
    
  • 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.
  • Listado 5:
    "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) (áâãäåæçèéêëìíîïðñòóôõö÷øùú)
    
  • 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.
  • Listado 6:
    "[*.?]"  --> {"*", ".", "?"}
    "[]a]"   --> {"]", "a"}
    "[a-]"   --> {"a", "-"}
    "file-1" --> {"file-1"}
    
  • Dentro de los corchetes pueden utilizarse las clases POSIX (Tabla 1). Solo incluyen caracteres ASCII. La forma [[:^alpha:]] niega cualquiera de ellas.
  • Listado 7:
    "[[:alpha:]]+"         --> {"a", "Hello", "XYZ", ...}
    "[[:digit:][:upper:]]" --> {"0", "9", "A", "Z", ...}
    
    Tabla 1: Clases POSIX.
    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.
  • Listado 8:
    "hello|bye"  --> {"hello", "bye"}
    "h(e|a)llo"  --> {"hello", "hallo"}
    "red|blue|"  --> {"red", "blue", ""}
    
  • 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 '(?:...)'.
  • Listado 9:
    "(hello)*"   --> {"", "hello", "hellohello", "hellohellohello", ... }
    "(he*llo)ZZ" --> {"hlloZZ", "helloZZ", "heelloZZ", "heeelloZZ", ... }
    
  • Los cuantificadores (Tabla 2) establecen cuántas veces puede aparecer el elemento anterior.
  • Tabla 2: Cuantificadores.
    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).
    Listado 10:
    "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.
  • Listado 11:
    "^ERROR"  "ERROR: disk"  --> pos=0, len=5
    "^ERROR"  "disk ERROR"   --> FALSE
    "\.txt$"  "doc.txt"      --> pos=3, len=4
    
  • El backslash introduce secuencias de escape (Tabla 3).
  • Tabla 3: Secuencias de escape.
    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.
    Listado 12:
    "\(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).

Listado 13:
"[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).

Figura 1: Construcción de autómatas finitos para filtrar expresiones regulares.
❮ Anterior
Siguiente ❯

#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 NULL.

errpos

Posición (en caracteres, empezando en 0) donde se detecta el error. UINT32_MAX si el patrón es válido. Puede ser NULL.

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 NULL tras la destrucción.


#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 NULL.

len

Longitud (en caracteres) de la subcadena. Puede ser NULL.

Retorna

TRUE si se ha encontrado una subcadena.

Observaciones

Ver Comparar y buscar.

❮ Anterior
Siguiente ❯