Provided by: manpages-fr-dev_4.21.0-2_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 <tvi‐
       gnaud@mandriva.com>, François Micaux, Alain Portal <aportal@univ-montp2.fr>, Jean-Philippe  Guérard  <fe‐
       vrier@tigreraye.org>,  Jean-Luc Coulon (f5ibh) <jean-luc.coulon@wanadoo.fr>, Julien Cristau <jcristau@de‐
       bian.org>,  Thomas  Huriaux  <thomas.huriaux@gmail.com>,   Nicolas   François   <nicolas.francois@centra‐
       liens.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  <fhan‐
       trais@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 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 à de‐
       bian-l10n-french@lists.debian.org.

Pages du manuel de Linux 6.03                    5 février 2023                                         regex(3)