Provided by: manpages-es_1.55-10_all bug

NOMBRE

       regcomp,  regexec,  regerror,  regfree  -  funciones  para  expresiones
       regulares POSIX

SINOPSIS

       #include <sys/types.h>
       #include <regex.h>

       int regcomp(regex_t *preg, const char *regex, int cflags);
       int regexec(const regex_t *preg, const  char  *string,  size_t  nmatch,
                   regmatch_t pmatch[], int eflags);
       size_t regerror(int  errcode, const regex_t *preg, char *errbuf, size_t
                       errbuf_size);
       void regfree(regex_t *preg);

COMPILACIÓN DE EXPRESIONES REGULARES POSIX

       regcomp se utiliza para compilar una expresión regular  en  un  formato
       apropiado para ser usado por regexec en búsquedas posteriores.

       A  regcomp  se  le  pasan como parámetros preg, un puntero a un área de
       almacenamiento temporal de patrones, regex, un  puntero  a  una  cadena
       terminada  en  un  carácter  nulo  y  cflags,  banderas utilizadas para
       determinar el tipo de compilación.

       Toda búsqueda con expresiones regulares se debe  realizar  mediante  un
       buffer  de patrones compilados, por tanto, a regexec siempre se le debe
       proporcionar  la  dirección  de  un  buffer  de  patrones  inicializado
       mediante regcomp.

       cflags  debe  ser  un  O-lógico  a  nivel  de  bits de una o más de las
       siguientes opciones:

       REG_EXTENDED
              Utilizar el tipo de sintaxis 'Expresión Regular Extendida POSIX'
              cuando  se  interprete  regex.   Si no se activa esta opción, se
              utiliza el tipo de sintaxis 'Expresión Regular Básica POSIX'.

       REG_ICASE
              No distinguir entre  mayúsculas  y  minúsculas.  Las  siguientes
              búsquedas   regexec   que   usen  este  buffer  de  patrones  no
              distinguirán entre mayúsculas y minúsculas.

       REG_NOSUB
              No se necesita soporte para obtener las posiciones de subcadenas
              coincidentes.  Los  parámetros  nmatch  y  pmatch  de regexec se
              ignoran si el buffer de patrones proporcionado  se  compiló  con
              esta opción.

       REG_NEWLINE
              Los  operadores  "coincidir con cualquier carácter" no coinciden
              con un carácter "nueva línea".

              Una lista  de  no-coincidencia  ([^...])   que  no  contenga  un
              carácter "nueva línea" no coincidirá con una "nueva línea".

              Un  operador  "coincidir al principio de línea" (^) coincide con
              la cadena vacía inmediatamente posterior a  un  carácter  "nueva
              línea",  sin  tener en cuenta si eflags, la bandera de ejecución
              de regexec, contiene REG_NOTBOL o no.

              Un operador "coincidir al final de línea" ($)  coincide  con  la
              cadena  vacía  inmediatamente  anterior  a  un  carácter  "nueva
              línea", sin tener en cuenta si eflags contiene REG_NOTEOL o no.

COINCIDENCIAS EN LAS EXPRESIONES REGULARES POSIX

       regexec se utiliza para comprobar si una cadena string, terminada en un
       carácter  nulo,  coincide  con alguno de los patrones precompilados del
       buffer preg.  nmatch y pmatch se utilizan para informar respecto  a  la
       localización  de cualquier coincidencia.  eflags puede ser REG_NOTBOL o
       REG_NOTEOL  o  un  O-lógico  de  ambos  valores,  lo  que   cambia   el
       comportamiento   en   las   coincidencias   tal   como  se  describe  a
       continuación.

       REG_NOTBOL
              El operador "coincidir al principio de línea" siempre  falla  en
              las coincidencias (pero vea la opción de compilación REG_NEWLINE
              más arriba).  Esta bandera se puede  utilizar  cuando  se  pasan
              diferentes porciones de una cadena a regexec y el comienzo de la
              cadena no se debe interpretar como el principio de una línea.

       REG_NOTEOL
              El operador "coincidir al final de línea" siempre  falla  en  la
              coincidencias (pero vea la opción de compilación REG_NEWLINE más
              arriba).

   DESPLAZAMIENTOS DE BYTES
       A menos que se especificara REG_NOSUB en la compilación del  buffer  de
       patrones,   es   posible  obtener  información  sobre  la  posición  de
       subcadenas coincidentes.  pmatch debe  tener  un  tamaño  de  al  menos
       nmatch  elementos.   Estos  se  rellenan  al  ejecutar  regexec con las
       posiciones de cadenas coincidentes. Cualquier elemento de la estructura
       no utilizado contendrá el valor -1.

       La  estructura  regmatch_t,  que  es  el  tipo  de pmatch, se define en
       regex.h.

              typedef struct
              {
                regoff_t rm_so;
                regoff_t rm_eo;
              } regmatch_t;

       Cada elemento rm_so que no es -1 indica el principio  de  la  siguiente
       mayor  subcadena  coincidente dentro de la cadena. El elemento relativo
       rm_eo indica el final de la coincidencia.

INFORMES DE ERROR POSIX

       regerror se utiliza para convertir los  códigos  de  error  que  pueden
       devolver tanto regcomp como regexec en cadenas de mensaje de error.

       A  regerror  se  le  pasa  el  código  de  error, errcode, el buffer de
       patrones preg, un puntero  al  buffer  de  una  cadena  de  caracteres,
       errbuf,  y el tamaño del buffer de la cadena, errbuf_size.  Devuelve el
       tamaño de errbuf necesario para contener la cadena con  el  mensaje  de
       error  terminada  en un carácter nulo. Si tanto errbuf como errbuf_size
       no son cero, errbuf  se  rellena  con  los  primeros  errbuf_size  -  1
       caracteres del mensaje de error y un carácter nulo terminador.

LIBERACIÓN DE BUFFERS DE PATRONES POSIX

       Si  a  regfree  se  le  pasa un buffer de patrones precompilados, preg,
       liberará la memoria  del buffer de patrones reservada por el proceso de
       compilación, regcomp.

VALOR DEVUELTO

       regcomp  devuelve  cero  si  la  compilación tiene éxito y un código de
       error si falla.

       regexec devuelve cero si hay coincidencia  y  REG_NOMATCH  en  caso  de
       fallo.

ERRORES

       regcomp puede devolver los siguientes errores:

       REG_BADRPT
              Uso  incorrecto  de operadores de repetición, como el uso de `*'
              como primer carácter.

       REG_BADBR
              Uso incorrecto del operador de referencia inversa.

       REG_EBRACE
              Existe una llave de un operador de intervalo no emparejada.

       REG_EBRACK
              Existe un corchete de un operador de lista no emparejado.

       REG_ERANGE
              Uso incorrecto de un operador de rango; por ejemplo,  el  límite
              superior del rango ocurre antes que el límite inferior.

       REG_ECTYPE
              Nombre de clase de caracteres desconocido.

       REG_ECOLLATE
              Elemento de comparación inválido.

       REG_EPAREN
              Existe un paréntesis de un operador de grupo no emparejado.

       REG_ESUBREG
              Referencia inversa incorrecta a una subexpresión.

       REG_EEND
              Error indefinido. No definido por POSIX.2.

       REG_EESCAPE
              Barra invertida (\) al final.

       REG_BADPAT
              Uso incorrecto de operadores de patrón tales como grupo o lista.

       REG_ESIZE
              La  expresión  regular  compilada necesita un buffer de patrones
              mayor que 64Kb. No definido por POSIX.2.

       REG_ESPACE
              Las rutinas de expresiones regulares se ejecutaron fuera de  sus
              límites de memoria.

CONFORME A

       POSIX.2

VÉASE TAMBIÉN

       regex(7), El manual de expresiones regulares de GNU