Provided by: manpages-fr-dev_2.64.1-1_all bug

NOM

       regcomp,   regexec,  regerror,  regfree  -  Fonctions  POSIX  pour  les
       expressions rationnelles (« regex »)

SYNOPSIS

       #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);

DESCRIPTION

   Compilation dexpressions rationnelles POSIX
       regcomp() est utilisée pour compiler une  expression  rationnelle  sous
       une forme utilisable par la suite pour des recherches avec regexec().

       On fournit à regcomp() les arguments preg, un pointeur vers une zone de
       stockage du motif, regex, un pointeur vers une chaîne terminée  par  un
       caractère   nul,   et  cflags,  les  attributs  indiquant  le  type  de
       compilation.

       Toutes les recherches  d’expressions  rationnelles  sont  effectuées  à
       travers  la  zone  de  motif  compilé,  ainsi  regexec()  doit toujours
       recevoir l’adresse d’un motif initialisé par regcomp().

       cflags peut être un  OU  binaire  entre  une  ou  plusieurs  constantes
       symboliques suivantes :

       REG_EXTENDED
              Utiliser  la syntaxe d’expression rationnelle étendue POSIX pour
              interpréter regex. Sinon, la syntaxe d’expression rationnelle de
              base POSIX est utilisée.

       REG_ICASE
              Ne   pas   différencier   les  majuscules  des  minuscules.  Les
              recherches regexec() suivantes  utilisant  le  tampon  de  motif
              n’effectueront pas la différenciation.

       REG_NOSUB
              Ne   pas  utiliser  les  correspondances  de  sous-chaînes.  Les
              paramètres nmatch et pmatch de  regexec()  sont  ignorés  si  le
              tampon de motif est compilé avec cet attribut.

       REG_NEWLINE
              L’opérateur  "n’importe-quel-caractère"  ne s’identifie pas avec
              le saut de ligne.

              Une liste d’exceptions ([^...]) ne  contenant  pas  de  saut  de
              ligne ne s’identifie pas avec un saut de ligne.

              L’opérateur  début-de-ligne (^) s’identifie avec une chaîne vide
              suivant immédiatement un  saut  de  ligne,  même  si  l’attribut
              eflags de regexec() contient REG_NOTBOL.

              L’opérateur  fin-de-ligne  ($)  s’identifie avec une chaîne vide
              précédant immédiatement un saut de  ligne,  même  si  l’attribut
              eflags contient REG_NOTEOL.

   Correspondance dexpressions rationnelles POSIX
       regexec()  est  utilisée  pour  mettre  en  correspondance  une  chaîne
       terminée par un caractère nul, avec le tampon de motif précompilé preg.
       nmatch  et pmatch fournissent des informations concernant l’emplacement
       des  correspondances.  eflags  peut  être  un  OU  binaire  entre   les
       constantes REG_NOTBOL ou REG_NOTEOL qui modifient le comportement de la
       mise en correspondance décrite ci-dessous.

       REG_NOTBOL
              L’opérateur   début-de-ligne   échoue   toujours   (mais   voyez
              l’attribut  de  compilation REG_NEWLINE ci-dessus). Cet attribut
              peut être utilisé quand différentes portions d’une  chaîne  sont
              transmises  à  regexec()  et  que  le  début  de  la  chaîne  ne
              correspond pas à un début de ligne.

       REG_NOTEOL
              L’opérateur fin-de-ligne échoue toujours (mais voyez  l’attribut
              de compilation REG_NEWLINE ci-dessus)

   DÉCALAGE DOCTETS
       À  moins  que  l’attribut  REG_NOSUB  n’ait  été  utilisé  lors  de  la
       compilation du motif, il est possible d’obtenir  des  informations  sur
       les correspondances de sous-chaînes. pmatch doit être dimensionnée pour
       contenir au moins nmatch éléments. Ils sont remplis par regexec()  avec
       les  adresses  des  sous-chaînes  mises  en  correspondance.  Tous  les
       éléments inutilisés de structure contiendront la valeur -1.

       La structure regmatch_t du type pmatch est définie dans regex.h.

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

       Chaque élément rm_so différent de -1 indique le point de départ  de  la
       sous-chaîne  suivante  la  plus longue qui soit mise en correspondance.
       L’élément rm_eo indique le décalage de la fin de la sous-chaîne.

   Retours derreurs POSIX
       regerror() est utilisé pour transformer les codes d’erreur renvoyés par
       regcomp() et par regexec() en libellés.

       regerror() reçoit le code errcode, le tampon de motif preg, un pointeur
       sur une chaîne de caractères errbuf, et la longueur maximale  de  cette
       chaîne  errbuf_size. Cette fonction renvoie la taille errbuf nécessaire
       pour contenir le libellé d’erreur terminé  par  un  caractère  nul.  Si
       errbuf  et  errbuf_size  son  non  nuls,  errbuf  est  rempli  avec les
       errbuf_size - 1 premiers caractères du libellé  d’erreur,  suivis  d’un
       caractère nul.

   Libération des tampons de motifs POSIX
       En  fournissant  à  regfree()  un  tampon  de motif précompilé preg, il
       libérera la mémoire  allouée  au  tampon  durant  la  compilation  avec
       regcomp().

VALEUR RENVOYÉE

       regcomp()  renvoie  zéro si la compilation réussit, ou un code d’erreur
       en cas d’échec.

       regexec() renvoie zéro si la correspondance réussit, et REG_NOMATCH  si
       elle échoue.

ERREURS

       Les erreurs suivantes peuvent être déclenchées par regcomp() :

       REG_BADBR
              Utilisation illégale de l’opérateur de référence inverse.

       REG_BADPAT
              Utilisation illégale d’un opérateur du type groupe ou liste.

       REG_BADRPT
              Utilisation   invalide  d’opérateurs  de  répétition,  comme  un
              caractère « * » en première place.

       REG_EBRACE
              Accolade manquante.

       REG_EBRACK
              Crochet manquant.

       REG_ECOLLATE
              Élément de classement invalide.

       REG_ECTYPE
              Nom de classe de caractère inconnu.

       REG_EEND
              Erreur non spécifique. Elle n’est pas définie par POSIX.2.

       REG_EESCAPE
              Barre oblique inverse de fin.

       REG_EPAREN
              Parenthèse manquante.

       REG_ERANGE
              Utilisation illégale de l’opérateur d’intervalle.  Par  exemple,
              la  fin de l’intervalle est inférieure au début de l’intervalle.

       REG_ESIZE
              La compilation aurait besoin d’un tampon de taille supérieure  à
              64 Ko. Ce n’est pas défini par POSIX.2.

       REG_ESPACE
              Les routines regex ont épuisé la mémoire.

       REG_ESUBREG
              Référence inverse illégale vers une sous-expression.

CONFORMITÉ

       POSIX.1-2001.

VOIR AUSSI

       grep(1), regex(7), Manuel GNU pour les expressions rationnelles

TRADUCTION

       Cette  page  de  manuel  a  été  traduite et mise à jour par Christophe
       Blaess <http://www.blaess.fr/christophe/> entre 1996 et 2003, puis  par
       Alain  Portal  <aportal AT univ-montp2 DOT fr> jusqu’en 2006, et mise à
       disposition sur http://manpagesfr.free.fr/.

       Les mises à jour et corrections de la version présente dans Debian sont
       directement         gérées         par         Nicolas         François
       <nicolas.francois@centraliens.net>   et   l’équipe    francophone    de
       traduction de Debian.

       Veuillez   signaler   toute   erreur   de   traduction  en  écrivant  à
       <debian-l10n-french@lists.debian.org> ou par un rapport de bogue sur le
       paquet manpages-fr.

       Vous  pouvez  toujours avoir accès à la version anglaise de ce document
       en utilisant la commande « man -L C <section> <page_de_man> ».