Expresiones regulares en C: ¿ejemplos?

9 minutos de lectura

avatar de usuario
Dervin Thunk

Busco algunos ejemplos simples y mejores prácticas sobre cómo usar expresiones regulares en ANSI C. man regex.h no proporciona tanta ayuda.

  • No hay soporte incorporado para expresiones regulares en ANSI C. ¿Qué biblioteca de expresiones regulares está usando?

    – José

    6 de julio de 2009 a las 1:59

  • Rob Pike escribió una pequeña función de búsqueda de cadenas de expresión regular que aceptaba un subconjunto muy útil de expresiones regulares para el libro La práctica de la programación que él y Brian Kernighan coautor Vea esta discusión, Un comparador de expresiones regulares, por el Dr. Kernighan cs.princeton.edu/courses/archive/spr09/cos333/beautiful.html

    – Richard Cámaras

    14 de diciembre de 2014 a las 23:18


avatar de usuario
diego campos

Este es un ejemplo del uso de REG_EXTENDED. Esta expresión regular

"^(-)?([0-9]+)((,|.)([0-9]+))?\n$"

Le permite capturar números decimales en el sistema español e internacional. 🙂

#include <regex.h>
#include <stdlib.h>
#include <stdio.h>
regex_t regex;
int reti;
char msgbuf[100];

int main(int argc, char const *argv[])
{
    while(1){
        fgets( msgbuf, 100, stdin );
        reti = regcomp(&regex, "^(-)?([0-9]+)((,|.)([0-9]+))?\n$", REG_EXTENDED);
        if (reti) {
            fprintf(stderr, "Could not compile regex\n");
            exit(1);
        }

        /* Execute regular expression */
        printf("%s\n", msgbuf);
        reti = regexec(&regex, msgbuf, 0, NULL, 0);
        if (!reti) {
            puts("Match");
        }
        else if (reti == REG_NOMATCH) {
            puts("No match");
        }
        else {
            regerror(reti, &regex, msgbuf, sizeof(msgbuf));
            fprintf(stderr, "Regex match failed: %s\n", msgbuf);
            exit(1);
        }

        /* Free memory allocated to the pattern buffer by regcomp() */
        regfree(&regex);
    }

}

  • no crees que es mejor mantener regcomp fuera del bucle?. a menos que deba inicializarse cada vez que se use.

    – milevyo

    6 ago 2021 a las 20:08


avatar de usuario
Laurence Gonsalves

Las expresiones regulares en realidad no son parte de ANSI C. Parece que podría estar hablando de la biblioteca de expresiones regulares POSIX, que viene con la mayoría (¿todos?) *Nixes. Aquí hay un ejemplo del uso de expresiones regulares POSIX en C (basado en este):

#include <regex.h>        
regex_t regex;
int reti;
char msgbuf[100];

/* Compile regular expression */
reti = regcomp(&regex, "^a[[:alnum:]]", 0);
if (reti) {
    fprintf(stderr, "Could not compile regex\n");
    exit(1);
}

/* Execute regular expression */
reti = regexec(&regex, "abc", 0, NULL, 0);
if (!reti) {
    puts("Match");
}
else if (reti == REG_NOMATCH) {
    puts("No match");
}
else {
    regerror(reti, &regex, msgbuf, sizeof(msgbuf));
    fprintf(stderr, "Regex match failed: %s\n", msgbuf);
    exit(1);
}

/* Free memory allocated to the pattern buffer by regcomp() */
regfree(&regex);

Alternativamente, es posible que desee consultar PCRE, una biblioteca para expresiones regulares compatibles con Perl en C. La sintaxis de Perl es más o menos la misma sintaxis utilizada en Java, Python y otros lenguajes. La sintaxis POSIX es la sintaxis utilizada por grep, sed, vietc.

  • A menos que necesite evitar la dependencia que segundo PCRE, tiene algunas mejoras de sintaxis agradables y es muy estable. Al menos con algunas versiones anteriores de Linux, la biblioteca de expresiones regulares “incorporada” no es demasiado difícil de bloquear dadas ciertas cadenas de entrada y ciertas expresiones regulares que “casi” coinciden o involucran una gran cantidad de caracteres especiales.

    – bdk

    6 de julio de 2009 a las 2:16

  • @Laurence ¿Cuál es el significado de pasar 0 a regcomp? regcomp solo toma cuatro valores enteros 1, 2, 4 y 8 para representar 4 modos diferentes.

    – lixiang

    21 de septiembre de 2013 a las 7:40


  • @lixiang El último parámetro para regcomp, cflags, es una máscara de bits. Desde pubs.opengroup.org/onlinepubs/009695399/functions/regcomp.html : “El argumento cflags es el OR inclusivo bit a bit de cero o más de los siguientes indicadores…”. Si hace O-juntos cero, obtendrá 0. Veo que la página de manual de Linux para regcomp dice “cflags puede ser bit a bit, o de uno o más de los siguientes”, lo que parece engañoso.

    – Laurence Gonsalves

    22 de septiembre de 2013 a las 18:11

  • Puede extraer texto de grupos coincidentes con algo como: regmatch_t matches[MAX_MATCHES]; if (regexec(&exp, sz, MAX_MATCHES, matches, 0) == 0) { memcpy(buff, sz + matches[1].rm_so, matches[1].rm_eo - matches[1].rm_so); printf("group1: %s\n", buff); } tenga en cuenta que las coincidencias de grupo comienzan en 1, el grupo 0 es la cadena completa. Agregue controles de error para fuera de los límites, etc.

    – Burns BA

    7 de febrero de 2016 a las 7:42


  • En cuanto a si regfree es necesario después de un fallido regcompaunque en realidad está bastante poco especificado, esto sugiere que no debería hacerse: redhat.com/archives/libvir-list/2013-septiembre/msg00276.html

    – Daniel Jour

    17/06/2016 a las 19:50

avatar de usuario
LUser

Si bien la respuesta anterior es buena, recomiendo usar PCRE2. Esto significa que puede usar literalmente todos los ejemplos de expresiones regulares que existen ahora y no tener que traducir de alguna expresión regular antigua.

Ya hice una respuesta para esto, pero creo que también puede ayudar aquí …

Regex en C para buscar números de tarjetas de crédito

// YOU MUST SPECIFY THE UNIT WIDTH BEFORE THE INCLUDE OF THE pcre.h

#define PCRE2_CODE_UNIT_WIDTH 8
#include <stdio.h>
#include <string.h>
#include <pcre2.h>
#include <stdbool.h>

int main(){

bool Debug = true;
bool Found = false;
pcre2_code *re;
PCRE2_SPTR pattern;
PCRE2_SPTR subject;
int errornumber;
int i;
int rc;
PCRE2_SIZE erroroffset;
PCRE2_SIZE *ovector;
size_t subject_length;
pcre2_match_data *match_data;


char * RegexStr = "(?:\\D|^)(5[1-5][0-9]{2}(?:\\ |\\-|)[0-9]{4}(?:\\ |\\-|)[0-9]{4}(?:\\ |\\-|)[0-9]{4})(?:\\D|$)";
char * source = "5111 2222 3333 4444";

pattern = (PCRE2_SPTR)RegexStr;// <<<<< This is where you pass your REGEX 
subject = (PCRE2_SPTR)source;// <<<<< This is where you pass your bufer that will be checked. 
subject_length = strlen((char *)subject);




  re = pcre2_compile(
  pattern,               /* the pattern */
  PCRE2_ZERO_TERMINATED, /* indicates pattern is zero-terminated */
  0,                     /* default options */
  &errornumber,          /* for error number */
  &erroroffset,          /* for error offset */
  NULL);                 /* use default compile context */

/* Compilation failed: print the error message and exit. */
if (re == NULL)
  {
  PCRE2_UCHAR buffer[256];
  pcre2_get_error_message(errornumber, buffer, sizeof(buffer));
  printf("PCRE2 compilation failed at offset %d: %s\n", (int)erroroffset,buffer);
  return 1;
  }


match_data = pcre2_match_data_create_from_pattern(re, NULL);

rc = pcre2_match(
  re,
  subject,              /* the subject string */
  subject_length,       /* the length of the subject */
  0,                    /* start at offset 0 in the subject */
  0,                    /* default options */
  match_data,           /* block for storing the result */
  NULL);

if (rc < 0)
  {
  switch(rc)
    {
    case PCRE2_ERROR_NOMATCH: //printf("No match\n"); //
    pcre2_match_data_free(match_data);
    pcre2_code_free(re);
    Found = 0;
    return Found;
    //  break;
    /*
    Handle other special cases if you like
    */
    default: printf("Matching error %d\n", rc); //break;
    }
  pcre2_match_data_free(match_data);   /* Release memory used for the match */
  pcre2_code_free(re);
  Found = 0;                /* data and the compiled pattern. */
  return Found;
  }


if (Debug){
ovector = pcre2_get_ovector_pointer(match_data);
printf("Match succeeded at offset %d\n", (int)ovector[0]);

if (rc == 0)
  printf("ovector was not big enough for all the captured substrings\n");


if (ovector[0] > ovector[1])
  {
  printf("\\K was used in an assertion to set the match start after its end.\n"
    "From end to start the match was: %.*s\n", (int)(ovector[0] - ovector[1]),
      (char *)(subject + ovector[1]));
  printf("Run abandoned\n");
  pcre2_match_data_free(match_data);
  pcre2_code_free(re);
  return 0;
}

for (i = 0; i < rc; i++)
  {
  PCRE2_SPTR substring_start = subject + ovector[2*i];
  size_t substring_length = ovector[2*i+1] - ovector[2*i];
  printf("%2d: %.*s\n", i, (int)substring_length, (char *)substring_start);
  }
}

else{
  if(rc > 0){
    Found = true;

    } 
} 
pcre2_match_data_free(match_data);
pcre2_code_free(re);
return Found;

}

Instale PCRE usando:

wget https://ftp.pcre.org/pub/pcre/pcre2-10.31.zip
make 
sudo make install 
sudo ldconfig

Compilar usando:

gcc foo.c -lpcre2-8 -o foo

Revisa mi respuesta para más detalles.

avatar de usuario
apaderno

man regex.h informa que no hay una entrada manual para regex.h, pero man 3 regex le da una página que explica las funciones POSIX para la coincidencia de patrones.
Las mismas funciones se describen en La biblioteca GNU C: coincidencia de expresiones regulareslo que explica que la biblioteca GNU C admite tanto la interfaz POSIX.2 como la interfaz que ha tenido la biblioteca GNU C durante muchos años.

Por ejemplo, para un programa hipotético que imprima cuál de las cadenas pasadas como argumento coincide con el patrón pasado como primer argumento, podría usar un código similar al siguiente.

#include <errno.h>
#include <regex.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void print_regerror (int errcode, size_t length, regex_t *compiled);

int
main (int argc, char *argv[])
{
  regex_t regex;
  int result;

  if (argc < 3)
    {
      // The number of passed arguments is lower than the number of
      // expected arguments.
      fputs ("Missing command line arguments\n", stderr);
      return EXIT_FAILURE;
    }

  result = regcomp (&regex, argv[1], REG_EXTENDED);
  if (result)
    {
      // Any value different from 0 means it was not possible to 
      // compile the regular expression, either for memory problems
      // or problems with the regular expression syntax.
      if (result == REG_ESPACE)
        fprintf (stderr, "%s\n", strerror(ENOMEM));
      else
        fputs ("Syntax error in the regular expression passed as first argument\n", stderr);
      return EXIT_FAILURE;               
    }
  for (int i = 2; i < argc; i++)
    {
      result = regexec (&regex, argv[i], 0, NULL, 0);
      if (!result)
        {
          printf ("'%s' matches the regular expression\n", argv[i]);
        }
      else if (result == REG_NOMATCH)
        {
          printf ("'%s' doesn't the regular expression\n", argv[i]);
        }
      else
        {
          // The function returned an error; print the string 
          // describing it.
          // Get the size of the buffer required for the error message.
          size_t length = regerror (result, &regex, NULL, 0);
          print_regerror (result, length, &regex);       
          return EXIT_FAILURE;
        }
    }

  /* Free the memory allocated from regcomp(). */
  regfree (&regex);
  return EXIT_SUCCESS;
}

void
print_regerror (int errcode, size_t length, regex_t *compiled)
{
  char buffer[length];
  (void) regerror (errcode, compiled, buffer, length);
  fprintf(stderr, "Regex match failed: %s\n", buffer);
}

El último argumento de regcomp() tiene que ser al menos REG_EXTENDEDo las funciones usarán expresiones regulares basicaslo que significa que (por ejemplo) necesitaría usar a\{3\} en vez de a{3} usado desde expresiones regulares extendidasque es probablemente lo que esperas usar.

POSIX.2 también tiene otra función para la coincidencia de comodines: fnmatch(). No permite compilar la expresión regular u obtener las subcadenas que coinciden con una subexpresión, pero es muy específico para verificar cuándo un nombre de archivo coincide con un comodín (por ejemplo, usa el FNM_PATHNAME bandera).

Probablemente no sea lo que quieres, pero una herramienta como re2c puede compilar expresiones regulares POSIX (-ish) a ANSI C. Está escrito como un reemplazo para lexpero este enfoque le permite sacrificar la flexibilidad y la legibilidad por la última pizca de velocidad, si realmente la necesita.

¿Ha sido útil esta solución?

Esta web utiliza cookies propias y de terceros para su correcto funcionamiento y para fines analíticos y para mostrarte publicidad relacionada con sus preferencias en base a un perfil elaborado a partir de tus hábitos de navegación. Al hacer clic en el botón Aceptar, acepta el uso de estas tecnologías y el procesamiento de tus datos para estos propósitos. Configurar y más información
Privacidad