Provided by: manpages-fr-dev_4.19.0-7_all bug

NOM

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

BIBLIOTHÈQUE

       Bibliothèque C standard (libc, -lc)

SYNOPSIS

       #include <regex.h>

       int regcomp(regex_t *restrict preg, const char *restrict regex,
                   int cflags);
       int regexec(const regex_t *restrict preg, const char *restrict string,
                   size_t nmatch, regmatch_t pmatch[restrict .nmatch],
                   int eflags);

       size_t regerror(int errcode, const regex_t *restrict preg,
                   char errbuf[restrict .errbuf_size], size_t errbuf_size);
       void regfree(regex_t *preg);

DESCRIPTION

   Compilation d'expressions 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 un tampon de stockage du
       motif, regex, un pointeur vers une chaîne terminée par un caractère NULL, et  cflags,  les
       attributs indiquant le type de compilation.

       Toutes  les  recherches d'expressions rationnelles sont effectuées au moyen d'un tampon de
       motif compilé, ainsi regexec() doit toujours recevoir l'adresse d'un motif initialisé  par
       regcomp().

       cflags est le 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  signaler la position des correspondances de chaînes. Les paramètres nmatch
              et pmatch de regexec() ne sont pas pris en compte si le tampon de motif est compilé
              avec cet attribut.

       REG_NEWLINE
              Les  opérateurs  «\  n'importe-quel-caractère\  » ne s'identifient pas à un saut de
              ligne.

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

              L'opérateur  «\  début-de-ligne\  »  (^) s'identifie à la chaîne vide immédiatement
              après un saut de ligne, même si l'attribut eflags de regexec() contient REG_NOTBOL.

              L'opérateur  «\  fin-de-ligne\  »  ($)  s'identifie  à  la  chaîne  vide  précédant
              immédiatement un saut de ligne, même si l'attribut eflags contient REG_NOTEOL.

   Correspondance d'expressions rationnelles POSIX
       regexec()  est utilisée pour mettre en correspondance une chaîne terminée par un caractère
       NULL, avec  le  tampon  de  motif  précompilé  preg.  nmatch  et  pmatch  fournissent  des
       informations  concernant l'emplacement des correspondances. eflags est un OU binaire entre
       zéro ou plusieurs des drapeaux suivants :

       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 peut pas être interprété comme 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).

       REG_TARTEND
              Utiliser pmatch[0] sur la chaîne en entrée commençant à l'octet pmatch[0].rm_so  et
              finissant  avant  l'octet  pmatch[0].rm_eo.  Cela  permet de faire correspondre les
              octets de valeur NULL intégrés et évite un strlen(3) sur de grandes  chaînes.  Cela
              n'utilise  pas  nmatch  en  entrée et ne change pas le traitement de REG_NEWLINE ou
              REG_NOTBOL. Ce drapeau est une extension BSD et n'est pas présent dans POSIX.

   Décalage d'octets
       À 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 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. Les positions de la sous-expression
       débutant à la ième parenthèse sont stockées  dans  pmatch[i].  Les  adresses  de  mise  en
       correspondance  de l'expression complète sont stockées dans pmatch[0]. (Remarquez que pour
       obtenir les positions de correspondance de la sous-expression N,  nmatch  doit  valoir  au
       moins N+1.) Tous les éléments de structure inutilisés 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,  qui  est  l'emplacement du premier caractère après le texte qui
       correspond.

   Retours d'erreurs 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 NULL. Si errbuf et errbuf_size ne sont pas nuls,  errbuf  est  rempli  avec  les
       errbuf_size  -  1  premiers  caractères du libellé d'erreur, suivis d'un caractère NULL de
       terminaison (« \0 »).

   Libération des tampons de motifs POSIX
       En fournissant à regfree() un tampon de motif précompilé, preg 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 ou 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 d'expressions rationnelles a besoin d'un tampon de taille supérieure
              à 64 Ko. Cela 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.

ATTRIBUTS

       Pour une explication des termes utilisés dans cette section, consulter attributes(7).

       ┌─────────────────────────────────────────────────┬──────────────────────┬────────────────┐
       │InterfaceAttributValeur         │
       ├─────────────────────────────────────────────────┼──────────────────────┼────────────────┤
       │regcomp(), regexec()                             │ Sécurité des threads │ MT-Safe locale │
       ├─────────────────────────────────────────────────┼──────────────────────┼────────────────┤
       │regerror()                                       │ Sécurité des threads │ MT-Safe env    │
       ├─────────────────────────────────────────────────┼──────────────────────┼────────────────┤
       │regfree()                                        │ Sécurité des threads │ MT-Safe        │
       └─────────────────────────────────────────────────┴──────────────────────┴────────────────┘

STANDARDS

       POSIX.1-2001, POSIX.1-2008.

EXEMPLES

       #include <stdint.h>
       #include <stdio.h>
       #include <stdlib.h>
       #include <regex.h>

       #define ARRAY_SIZE(arr) (sizeof((arr)) / sizeof((arr)[0]))

       static const char *const str =
               "1) John Driverhacker;\n2) John Doe;\n3) John Foo;\n";
       static const char *const re = "John.*o";

       int main(void)
       {
           static const char *s = str;
           regex_t     regex;
           regmatch_t  pmatch[1];
           regoff_t    off, len;

          if (regcomp(&regex, re, REG_NEWLINE))
               exit(EXIT_FAILURE);

           printf("String = \"%s\"\n", str);
           printf("Matches:\n");

          for (int i = 0; ; i++) {
               if (regexec(&regex, s, ARRAY_SIZE(pmatch), pmatch, 0))
                   break;

               off = pmatch[0].rm_so + (s - str);
               len = pmatch[0].rm_eo - pmatch[0].rm_so;
               printf("#%zu:\n", i);
               printf("offset = %jd; length = %jd\n", (intmax_t) off,
                       (intmax_t) len);
               printf("substring = \"%.*s\"\n", len, s + pmatch[0].rm_so);

               s += pmatch[0].rm_eo;
           }

           exit(EXIT_SUCCESS);
       }

VOIR AUSSI

       grep(1), regex(7)

       La section Regular Expressions du manuel de la glibc

TRADUCTION

       La traduction française de cette  page  de  manuel  a  été  créée  par  Christophe  Blaess
       <https://www.blaess.fr/christophe/>,  Stéphan  Rafin  <stephan.rafin@laposte.net>, Thierry
       Vignaud <tvignaud@mandriva.com>, François Micaux, Alain  Portal  <aportal@univ-montp2.fr>,
       Jean-Philippe    Guérard   <fevrier@tigreraye.org>,   Jean-Luc   Coulon   (f5ibh)   <jean-
       luc.coulon@wanadoo.fr>,   Julien    Cristau    <jcristau@debian.org>,    Thomas    Huriaux
       <thomas.huriaux@gmail.com>, Nicolas François <nicolas.francois@centraliens.net>, Florentin
       Duneau <fduneau@gmail.com>, Simon Paillard <simon.paillard@resel.enst-bretagne.fr>,  Denis
       Barbier   <barbier@debian.org>,   David   Prévot  <david@tilapin.org>,  Frédéric  Hantrais
       <fhantrais@gmail.com>,   bubu   <bubub@no-log.org>   et    Jean-Pierre    Giraud    <jean-
       pierregiraud@neuf.fr>

       Cette  traduction  est  une  documentation libre ; veuillez vous reporter à la GNU General
       Public  License  version 3  ⟨https://www.gnu.org/licenses/gpl-3.0.html⟩   concernant   les
       conditions de copie et de distribution. Il n'y a aucune RESPONSABILITÉ LÉGALE.

       Si vous découvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un
       message à ⟨debian-l10n-french@lists.debian.org⟩.