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