regcomp, regexec, regerror, regfree - Fonctions POSIX pour les expressions
rationnelles (« regex »)
Bibliothèque C standard (
libc,
-lc)
#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);
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.
- 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 à la chaîne vide
précédant immédiatement un saut de ligne, même
si l'attribut eflags contient REG_NOTEOL.
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.
À 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.
regerror() est utilisé pour transformer les codes d'erreur
renvoyés par
regcomp() et par
regexec() en
libellés.
regerror() is passed the error code,
errcode, the pattern buffer,
preg, a pointer to a character string buffer,
errbuf, and the
size of the string buffer,
errbuf_size. It returns the size of the
errbuf required to contain the null-terminated error message string. If
both
errbuf and
errbuf_size are nonzero,
errbuf is filled
in with the first
errbuf_size - 1 characters of the error message and a
terminating null byte ('\0').
Supplying
regfree() with a precompiled pattern buffer,
preg, will
free the memory allocated to the pattern buffer by the compiling process,
regcomp().
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.
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
- Invalid use of repetition operators such as using '*' as
the first character.
- 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.
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 |
POSIX.1-2001, POSIX.1-2008.
#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);
}
grep(1),
regex(7)
La section
Regular Expressions du manuel de la glibc
La traduction française de cette page de manuel a été
créée par Christophe Blaess
<
https://www.blaess.fr/christophe/>, Stéphan Rafin
<
[email protected]>, Thierry Vignaud
<
[email protected]>, François Micaux, Alain Portal
<
[email protected]>, Jean-Philippe Guérard
<
[email protected]>, Jean-Luc Coulon (f5ibh)
<
[email protected]>, Julien Cristau
<
[email protected]>, Thomas Huriaux <
[email protected]>,
Nicolas François <
[email protected]>, Florentin
Duneau <
[email protected]>, Simon Paillard
<
[email protected]>, Denis Barbier
<
[email protected]>, David Prévot <
[email protected]>,
Frédéric Hantrais <
[email protected]> et bubu
<
[email protected]>
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 à
[email protected]