Provided by: manpages-fr-dev_4.23.1-1_all 
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 chaîne,
size_t nmatch, regmatch_t pmatch[_Nullable restrict .nmatch],
int eflags);
size_t regerror(int errcode, const regex_t *_Nullable restrict preg,
char errbuf[_Nullable restrict .errbuf_size],
size_t errbuf_size);
void regfree(regex_t *preg);
typedef struct {
size_t re_nsub;
} regex_t;
typedef struct {
regoff_t rm_so;
regoff_t rm_eo;
} regmatch_t;
typedef /* ... */ regoff_t;
DESCRIPTION
Compilation
regcomp() est utilisée pour compiler une expression rationnelle sous une forme utilisable
par la suite pour des recherches avec regexec().
En cas de succès, le tampon de motif dans *preg est initialisé. regex est une chaîne
terminée par NULL. La locale doit être la même lors de l'exécution de regexec().
Après la réussite de regcomp(), preg->re_nsub contient le nombre de sous-expressions dans
regex. Ainsi, une valeur de preg->re_nsub + 1 passée comme nmatch à regexec() est
suffisante pour capturer toutes les correspondances.
cflags est le OU binaire entre zéro ou plus des 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 capitales des minuscules. Les recherches regexec()
suivantes utilisant le tampon de motif seront insensibles à la casse.
REG_NOSUB
Ne rapporter que les réussites complètes. regexec() utilisera seulement pmatch pour
REG_STARTEND, ignorant nmatch.
REG_NEWLINE
Les opérateurs «correspondent pas à un saut de ligne.
Une liste de non correspondance ([^...]) ne contenant pas de saut de ligne ne
correspond pas à un saut de ligne.
L'opérateur « correspondance-à-début-de-ligne » (^) correspond à la chaîne vide
immédiatement après un saut de ligne, même si eflags, le drapeau d'exécution de
regexec(), contient REG_NOTBOL.
L'opérateur « correspondance-à-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
regexec() est utilisée pour mettre en correspondance une chaîne terminée par NULL avec le
tampon de motif précompilé *preg qui doit avoir été initialisé par regexec(). eflags est
un OU binaire entre zéro ou plus des drapeaux suivants :
REG_NOTBOL
L'opérateur « correpondance-à-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 doit pas être interprété comme un début de ligne.
REG_NOTEOL
L'opérateur « correspondance-à-fin-de-ligne » échoue toujours (mais voyez
l'attribut de compilation REG_NEWLINE ci-dessus).
REG_TARTEND
Établir une correspondance [chaîne + pmatch[0].rm_so, chaîne + pmatch[0].rm_eo) à
la place de [chaîne, chaîne + strlen(chaîne)). Cela permet les correspondances
d'octets NULL incorporés et évite un strlen(3) sur les chaînes à longueur connue.
Si des correspondances quelconques sont renvoyées (REG_NOSUB n'a pas été passé à
regcomp(), la correspondance a réussi et nmatch > 0), comme d'habitude elles
écrasent pmatch et la localisation des correspondances demeure relative à chaîne
(pas à chaîne + pmatch[0].rm_so). Ce drapeau est une extension BSD, absente dans
POSIX.
Emplacement des correspondances
À moins que REG_NOSUB n'ait été passé à regcomp(), il est possible d'obtenir la
localisation des correspondances dans chaîne : regexec() renseigne les éléments nmatch de
pmatch avec les résultats suivants : pmatch[0] correspond à la correspondance complète,
pmatch[1] à la première sous-expression, etc. S'il y a plus de correspondances que nmatch,
elles sont abandonnées ; s'il y en a moins, les éléments non utilisés de pmatch sont
remplis de -1.
Chaque correspondance valable renvoyée (non -1) correspond à la plage [chaîne + rm_so,
chaîne + rm_eo).
regoff_t est un type d'entier signé capable de contenir la plus grande valeur qui peut
être stockée dans un type ptrdiff_t ou dans un type ssize_t.
Rapport d'erreurs
regerror() est utilisé pour transformer les codes d'erreur renvoyés par regcomp() et par
regexec() en chaînes de message d'erreur.
Si preg n'est pas un pointeur NULL, errcode doit être la dernière erreur renvoyée par une
opération sur preg.
Si errbuf_size est différent de 0, jusqu'à errbuf_size octets sont copiés dans errbuf ; la
chaîne d'erreur est toujours terminée par NULL et tronquée pour tenir dans l'espace
alloué.
Libération
regfree() désinitialise le tampon de motif dans *preg, libérant toute la mémoire
associée ; *preg doit avoir été initialisé par 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.
regerror() renvoie la taille du tampon requise pour contenir la chaîne.
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 illégale 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 collation invalide.
REG_ECTYPE
Nom de classe de caractères inconnu.
REG_EEND
Erreur non spécifique. Elle n'est pas définie par POSIX.
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.
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).
┌─────────────────────────────────────────────────┬──────────────────────┬────────────────┐
│Interface │ Attribut │ Valeur │
├─────────────────────────────────────────────────┼──────────────────────┼────────────────┤
│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-2008.
HISTORIQUE
POSIX.1-2001.
Avant POSIX.1-2008, regoff_t était requis pour pouvoir stocker la plus grande valeur qui
pouvait être contenue dans le type off_t ou dans le type ssize_ttype.
AVERTISSEMENTS
re_nsub n'est requis pour être initialisé si REG_NOSUB n'a pas été spécifié, mais toutes
les implémentations connues l'initialisent de toutes façons.
À la fois regex_t et regmatch_t peuvent avoir (et ont) plus de membres dans n'importe quel
ordre. Il faut toujours les référencer par leur nom.
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(®ex, re, REG_NEWLINE))
exit(EXIT_FAILURE);
printf("String = \"%s\"\n", str);
printf("Matches:\n");
for (unsigned int i = 0; ; i++) {
if (regexec(®ex, 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⟩.