regex(3) Library Functions Manual regex(3) NOM regcomp, regexec, regerror, regfree - Fonctions POSIX pour les expressions rationnelles (<< regex >>) BIBLIOTHEQUE Bibliotheque C standard (libc, -lc) SYNOPSIS #include int regcomp(regex_t *restrict preg, const char *restrict regex, int cflags); int regexec(const regex_t *restrict preg, const char *restrict chaine, 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 utilisee pour compiler une expression rationnelle sous une forme utilisable par la suite pour des recherches avec regexec(). En cas de succes, le tampon de motif dans *preg est initialise. regex est une chaine terminee par NULL. La locale doit etre la meme lors de l'execution de regexec(). Apres la reussite de regcomp(), preg->re_nsub contient le nombre de sous-expressions dans regex. Ainsi, une valeur de preg->re_nsub + 1 passee comme nmatch a regexec() est suffisante pour capturer toutes les correspondances. cflags est le OU binaire entre zero ou plus des constantes symboliques suivantes : REG_EXTENDED Utiliser la syntaxe d'expression rationnelle etendue POSIX pour interpreter regex. Sinon, la syntaxe d'expression rationnelle de base POSIX est utilisee. REG_ICASE Ne pas differencier les capitales des minuscules. Les recherches regexec() suivantes utilisant le tampon de motif seront insensibles a la casse. REG_NOSUB Ne rapporter que les reussites completes. regexec() utilisera seulement pmatch pour REG_STARTEND, ignorant nmatch. REG_NEWLINE Les operateurs <> ne correspondent pas a un saut de ligne. Une liste de non correspondance ([^...]) ne contenant pas de saut de ligne ne correspond pas a un saut de ligne. L'operateur << correspondance-a-debut-de-ligne >> (^) correspond a la chaine vide immediatement apres un saut de ligne, meme si eflags, le drapeau d'execution de regexec(), contient REG_NOTBOL. L'operateur << correspondance-a-fin-de-ligne >> ($) s'identifie a la chaine vide precedant immediatement un saut de ligne, meme si l'attribut eflags contient REG_NOTEOL. Correspondance regexec() est utilisee pour mettre en correspondance une chaine terminee par NULL avec le tampon de motif precompile *preg qui doit avoir ete initialise par regexec(). eflags est un OU binaire entre zero ou plus des drapeaux suivants : REG_NOTBOL L'operateur << correpondance-a-debut-de-ligne >> echoue toujours (mais voyez l'attribut de compilation REG_NEWLINE ci-dessus). Cet attribut peut etre utilise quand differentes portions d'une chaine sont transmises a regexec() et que le debut de la chaine ne doit pas etre interprete comme un debut de ligne. REG_NOTEOL L'operateur << correspondance-a-fin-de-ligne >> echoue toujours (mais voyez l'attribut de compilation REG_NEWLINE ci-dessus). REG_TARTEND Etablir une correspondance [chaine + pmatch[0].rm_so, chaine + pmatch[0].rm_eo) a la place de [chaine, chaine + strlen(chaine)). Cela permet les correspondances d'octets NULL incorpores et evite un strlen(3) sur les chaines a longueur connue. Si des correspondances quelconques sont renvoyees (REG_NOSUB n'a pas ete passe a regcomp(), la correspondance a reussi et nmatch > 0), comme d'habitude elles ecrasent pmatch et la localisation des correspondances demeure relative a chaine (pas a chaine + pmatch[0].rm_so). Ce drapeau est une extension BSD, absente dans POSIX. Emplacement des correspondances A moins que REG_NOSUB n'ait ete passe a regcomp(), il est possible d'obtenir la localisation des correspondances dans chaine : regexec() renseigne les elements nmatch de pmatch avec les resultats suivants : pmatch[0] correspond a la correspondance complete, pmatch[1] a la premiere sous-expression, etc. S'il y a plus de correspondances que nmatch, elles sont abandonnees ; s'il y en a moins, les elements non utilises de pmatch sont remplis de -1. Chaque correspondance valable renvoyee (non -1) correspond a la plage [chaine + rm_so, chaine + rm_eo). regoff_t est un type d'entier signe capable de contenir la plus grande valeur qui peut etre stockee dans un type ptrdiff_t ou dans un type ssize_t. Rapport d'erreurs regerror() est utilise pour transformer les codes d'erreur renvoyes par regcomp() et par regexec() en chaines de message d'erreur. Si preg n'est pas un pointeur NULL, errcode doit etre la derniere erreur renvoyee par une operation sur preg. Si errbuf_size est different de 0, jusqu'a errbuf_size octets sont copies dans errbuf ; la chaine d'erreur est toujours terminee par NULL et tronquee pour tenir dans l'espace alloue. Liberation regfree() desinitialise le tampon de motif dans *preg, liberant toute la memoire associee ; *preg doit avoir ete initialise par regcomp(). VALEUR RENVOYEE regcomp() renvoie zero si la compilation reussit, ou un code d'erreur en cas d'echec. regexec() renvoie zero si la correspondance reussit ou REG_NOMATCH si elle echoue. regerror() renvoie la taille du tampon requise pour contenir la chaine. ERREURS Les erreurs suivantes peuvent etre declenchees par regcomp() : REG_BADBR Utilisation illegale de l'operateur de reference inverse. REG_BADPAT Utilisation illegale d'un operateur du type groupe ou liste. REG_BADRPT Utilisation illegale d'operateurs de repetition, comme un caractere << * >> en premiere place. REG_EBRACE Accolade manquante. REG_EBRACK Crochet manquant. REG_ECOLLATE Element de collation invalide. REG_ECTYPE Nom de classe de caracteres inconnu. REG_EEND Erreur non specifique. Elle n'est pas definie par POSIX. REG_EESCAPE Barre oblique inverse de fin. REG_EPAREN Parenthese manquante. REG_ERANGE Utilisation illegale de l'operateur d'intervalle. Par exemple, la fin de l'intervalle est inferieure au debut de l'intervalle. REG_ESIZE La compilation d'expressions rationnelles a besoin d'un tampon de taille superieure a 64 Ko. Cela n'est pas defini par POSIX. REG_ESPACE Les routines regex ont epuise la memoire. REG_ESUBREG Reference inverse illegale vers une sous-expression. ATTRIBUTS Pour une explication des termes utilises dans cette section, consulter attributes(7). +--------------------------+--------------------------+----------------+ |Interface | Attribut | Valeur | +--------------------------+--------------------------+----------------+ |regcomp(), regexec() | Securite des threads | MT-Safe locale | +--------------------------+--------------------------+----------------+ |regerror() | Securite des threads | MT-Safe env | +--------------------------+--------------------------+----------------+ |regfree() | Securite des threads | MT-Safe | +--------------------------+--------------------------+----------------+ STANDARDS POSIX.1-2008. HISTORIQUE POSIX.1-2001. Avant POSIX.1-2008, regoff_t etait requis pour pouvoir stocker la plus grande valeur qui pouvait etre contenue dans le type off_t ou dans le type ssize_ttype. AVERTISSEMENTS re_nsub n'est requis pour etre initialise si REG_NOSUB n'a pas ete specifie, mais toutes les implementations connues l'initialisent de toutes facons. A la fois regex_t et regmatch_t peuvent avoir (et ont) plus de membres dans n'importe quel ordre. Il faut toujours les referencer par leur nom. EXEMPLES #include #include #include #include #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 francaise de cette page de manuel a ete creee par Christophe Blaess , Stephan Rafin , Thierry Vignaud , Francois Micaux, Alain Portal , Jean-Philippe Guerard , Jean-Luc Coulon (f5ibh) , Julien Cristau , Thomas Huriaux , Nicolas Francois , Florentin Duneau , Simon Paillard , Denis Barbier , David Prevot , Frederic Hantrais , bubu et Jean-Pierre Giraud Cette traduction est une documentation libre ; veuillez vous reporter a la GNU General Public License version 3 concernant les conditions de copie et de distribution. Il n'y a aucune RESPONSABILITE LEGALE. Si vous decouvrez un bogue dans la traduction de cette page de manuel, veuillez envoyer un message a . Pages du manuel de Linux 6.06 31 octobre 2023 regex(3)