Provided by: manpages-fr-dev_4.13-4_all bug

NOM

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

SYNOPSIS

       #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 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 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 is the bitwise-or of zero or more of the following:

       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
              L'opérateur  «\  n'importe-quel-caractère\  »  ne  s'identifie  pas avec le saut de
              ligne.

              A nonmatching list ([^...]) not containing a newline does not match a newline.

              Match-beginning-of-line operator (^)  matches the empty string immediately after  a
              newline,  regardless  of whether eflags, the execution flags of regexec(), contains
              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 d'expressions rationnelles POSIX
       regexec()   is  used  to  match  a  null-terminated string against the precompiled pattern
       buffer, preg. nmatch and pmatch are used to provide information regarding the location  of
       any matches. eflags is the bitwise-or of zero or more of the following flags:

       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).

       REG_STARTEND
              Use  pmatch[0]  on  the  input  string, starting at byte pmatch[0].rm_so and ending
              before byte pmatch[0].rm_eo. This allows matching embedded NUL bytes and  avoids  a
              strlen(3)   on  large strings. It does not use nmatch on input, and does not change
              REG_NOTBOL or REG_NEWLINE processing. This flag is a BSD extension, not present  in
              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  ie  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  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  de
       terminaison (« \0 »).

   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
              Compiled regular expression requires a pattern buffer larger than  64 kB.  This  is
              not defined by 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        │
       └─────────────────────┴──────────────────────┴────────────────┘

CONFORMITÉ

       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("#%d:\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)

       The glibc manual section, Regular Expressions

COLOPHON

       Cette  page  fait partie de la publication 5.10 du projet man-pages Linux. Une description
       du projet et des instructions pour signaler des anomalies et la dernière version de  cette
       page peuvent être trouvées à l'adresse https://www.kernel.org/doc/man-pages/.

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>  et  Frédéric  Hantrais
       <fhantrais@gmail.com>

       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 ⟨⟩.