perkamon - en to fr translation catalogue (208 entries)

note: type: TH
en: 2000-10-15
fr: 15 octobre 2000

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: fnmatch - match filename or pathname
fr: fnmatch - Correspondance de noms de fichiers

note: type: Plain text
en: The B<fnmatch>()  function checks whether the I<string> argument matches the I<pattern> argument, which is a shell wildcard pattern.
fr: La fonction B<fnmatch>() vérifie si l'argument I<string> correspond avec le motif I<pattern>, qui peut contenir des méta-caractères d'un interpréteur de commande.

note: type: Plain text
en: The I<flags> argument modifies the behavior; it is the bitwise OR of zero or more of the following flags:
fr: L'argument I<flags> modifie le comportement de la fonction. C'est un I<OU> binaire entre zéro ou plusieurs des drapeaux suivants\ :

note: type: Plain text
en: If this flag is set, treat backslash as an ordinary character, instead of an escape character.
fr: Traiter la barre oblique inverse «\ \e\ » comme un caractère ordinaire, et non pas un caractère d'échappement.

note: type: Plain text
en: If this flag is set, match a slash in I<string> only with a slash in I<pattern> and not by an asterisk (*) or a question mark (?) metacharacter, nor by a bracket expression ([]) containing a slash.
fr: Ne faire correspondre une barre oblique «\ /\ » dans I<string> qu'avec une barre oblique dans I<pattern>, et non avec les méta-caractères «\ *\ » ou «\ ?\ », et non plus avec une expression entre crochets «\ []\ » contenant une barre oblique.

note: type: Plain text
en: If this flag is set, a leading period in I<string> has to be matched exactly by a period in I<pattern>.  A period is considered to be leading if it is the first character in I<string>, or if both B<FNM_PATHNAME> is set and the period immediately follows a slash.
fr: Un point en début de I<string> doit exactement correspondre avec un point dans I<pattern>. Un point est considéré comme en-tête de chaîne, s'il est le premier caractère de I<string>, ou si B<FNM_PATHNAME> est défini, et si le point suit immédiatement une barre oblique.

note: type: Plain text
en: This is a GNU synonym for B<FNM_PATHNAME>.
fr: Il s'agit d'un synonyme GNU de B<FNM_PATHNAME>.

note: type: Plain text
en: If this flag (a GNU extension) is set, the pattern is considered to be matched if it matches an initial segment of I<string> which is followed by a slash.  This flag is mainly for the internal use of glibc and is implemented only in certain cases.
fr: (Extension GNU) La correspondance est considérée comme correcte si le motif correspond à un segment initial de la chaîne I<string> suivi d'une barre oblique. Ce drapeau est réservé pour un usage interne de la glibc, et n'est pas toujours implémenté.

note: type: Plain text
en: If this flag (a GNU extension) is set, the pattern is matched case-insensitively.
fr: (Extension GNU) La correspondance est insensible à la casse.

note: type: SH
en: RETURN VALUE
fr: VALEUR RENVOYÉE

note: type: Plain text
en: Zero if I<string> matches I<pattern>, B<FNM_NOMATCH> if there is no match or another nonzero value if there is an error.
fr: Zéro si la chaîne I<string> correspond au motif I<pattern>, B<FNM_NOMATCH> s'il n'y a pas correspondance, et une autre valeur non nulle s'il y a erreur.

note: type: SH
en: CONFORMING TO
fr: CONFORMITÉ

note: type: Plain text
en: POSIX.2.  The B<FNM_FILE_NAME>, B<FNM_LEADING_DIR>, and B<FNM_CASEFOLD> flags are GNU extensions.
fr: POSIX.2. Les drapeaux B<FNM_FILE_NAME>, B<FNM_LEADING_DIR> et B<FNM_CASEFOLD> sont des extensions GNU.

note: type: SH
en: SEE ALSO
fr: VOIR AUSSI

note: type: Plain text
en: This page is part of release 3.65 of the Linux I<man-pages> project.  A description of the project, and information about reporting bugs, can be found at \%http://www.kernel.org/doc/man-pages/.
fr: Cette page fait partie de la publication 3.65 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies peuvent être trouvées à l'adresse \%http://www.kernel.org/doc/man-pages/.

note: type: TH
en: 2007-10-10
fr: 10 octobre 2007

note: type: Plain text
en: glob, globfree - find pathnames matching a pattern, free memory from glob()
fr: glob, globfree - Rechercher un chemin d'accès correspondant à un motif

note: type: Plain text
en: The B<glob>()  function searches for all the pathnames matching I<pattern> according to the rules used by the shell (see B<glob>(7)).  No tilde expansion or parameter substitution is done; if you want these, use B<wordexp>(3).
fr: La fonction B<glob>() recherche tous les chemins d'accès correspondant au motif I<pattern> en utilisant les règles du shell (consultez B<glob>(7)). Aucun remplacement de tilde ou substitution de paramètre n'est effectué. Si vous avez besoin de ces fonctionnalités, utilisez B<wordexp>(3).

note: type: Plain text
en: The B<globfree>()  function frees the dynamically allocated storage from an earlier call to B<glob>().
fr: La fonction B<globfree>() libère la mémoire allouée dynamiquement lors d'un appel précédent à B<glob>().

note: type: Plain text
en: The results of a B<glob>()  call are stored in the structure pointed to by I<pglob>.  This structure is of type I<glob_t> (declared in I<E<lt>glob.hE<gt>>)  and includes the following elements defined by POSIX.2 (more may be present as an extension):
fr: Les résultats d'un appel à B<glob>() sont stockés dans une structure pointée par I<pglob>. Cette structure est de type I<glob_t> (défini dans I<E<lt>glob.hE<gt>>) et inclut les éléments définis par POSIX.2 (il peut y en avoir plus sous forme d'extension GNU)\ :

note: type: Plain text
en: typedef struct {
        size_t   gl_pathc;    /* Count of paths matched so far  */
        char   **gl_pathv;    /* List of matched pathnames.  */
        size_t   gl_offs;     /* Slots to reserve in I<gl_pathv>.  */
    } glob_t;
fr: typedef struct {
        size_t   gl_pathc;    /* Nombre de chemins correspondant  */
        char   **gl_pathv;    /* Liste des chemins correspondant  */
        size_t   gl_offs;     /* Entrées à réserver dans I<gl_pathv>.  */
    } glob_t;

note: type: Plain text
en: Results are stored in dynamically allocated storage.
fr: Les résultats sont sauvés dans une zone allouée dynamiquement.

note: type: Plain text
en: The argument I<flags> is made up of the bitwise OR of zero or more the following symbolic constants, which modify the behavior of B<glob>():
fr: Le paramètre I<flags> est constitué d'un OU binaire «\ |\ » entre zéro ou plus des constantes symboliques suivantes, modifiant le comportement de B<glob>()\ :

note: type: Plain text
en: Return upon a read error (because a directory does not have read permission, for example).  By default, B<glob>()  attempts carry on despite errors, reading all of the directories that it can.
fr: Terminer dès qu'une erreur se produit (par exemple, un répertoire non lisible). Par défaut, B<glob>() tente, malgré les erreurs, de lire tous les répertoires qu'il peut.

note: type: Plain text
en: Append a slash to each path which corresponds to a directory.
fr: Ajoute une barre oblique finale à chaque nom correspondant à un répertoire.

note: type: Plain text
en: Don't sort the returned pathnames.  The only reason to do this is to save processing time.  By default, the returned pathnames are sorted.
fr: Ne pas trier les chemins d'accès renvoyés. La seule raison pour faire cela est d'économiser du temps de traitement. Par défaut, les chemins d'accès renvoyés sont triés.

note: type: Plain text
en: Reserve I<pglob-E<gt>gl_offs> slots at the beginning of the list of strings in I<pglob-E<gt>pathv>.  The reserved slots contain null pointers.
fr: Réserve I<pglob-E<gt>gl_offs> points d'entrée au début de la liste de chaînes dans I<pglob-E<gt>pathv>. Les points d'entrée réservés contiennent des pointeurs NULL.

note: type: Plain text
en: If no pattern matches, return the original pattern.  By default, B<glob>()  returns B<GLOB_NOMATCH> if there are no matches.
fr: Si aucun motif ne correspond, renvoyer le motif original. Par défaut, B<glob>() renvoie B<GLOB_NOMATCH> s'il n'y a pas de correspondance.

note: type: Plain text
en: Append the results of this call to the vector of results returned by a previous call to B<glob>().  Do not set this flag on the first invocation of B<glob>().
fr: Ajoute les résultats de cet appel au tableau de résultats renvoyé par un appel précédent à B<glob>(). Ne pas indiquer cet attribut lors du premier appel de B<glob>().

note: type: Plain text
en: Don't allow backslash (\(aq\e\(aq) to be used as an escape character.  Normally, a backslash can be used to quote the following character, providing a mechanism to turn off the special meaning metacharacters.
fr: Ne pas permettre l'utilisation de barre oblique inverse (« \e ») pour désactiver les caractères d'échappement. Normalement, une barre oblique inverse peut être utilisée pour échapper le caractère qui le suit, fournissant un mécanisme de désactivation du sens particulier des méta-caractères.

note: type: Plain text
en: I<flags> may also include any of the following, which are GNU extensions and not defined by POSIX.2:
fr: I<flags> peut également utiliser les constantes suivantes, qui sont des extensions GNU, non définies dans POSIX.2\ :

note: type: Plain text
en: Allow a leading period to be matched by metacharacters.  By default, metacharacters can't match a leading period.
fr: Permettre à un point en tête de chemin de correspondre à un méta-caractère. Par défaut, les méta-caractères ne peuvent pas correspondre à un point en tête de chemin.

note: type: Plain text
en: Use alternative functions I<pglob-E<gt>gl_closedir>, I<pglob-E<gt>gl_readdir>, I<pglob-E<gt>gl_opendir>, I<pglob-E<gt>gl_lstat>, and I<pglob-E<gt>gl_stat> for filesystem access instead of the normal library functions.
fr: Utiliser les fonctions alternatives I<pglob-E<gt>gl_closedir>, I<pglob-E<gt>gl_readdir>, I<pglob-E<gt>gl_opendir>, I<pglob-E<gt>gl_lstat> et I<pglob-E<gt>gl_stat> pour l'accès au système de fichiers au lieu des fonctions normales de bibliothèque.

note: type: Plain text
en: Expand B<csh>(1)  style brace expressions of the form B<{a,b}>.  Brace expressions can be nested.  Thus, for example, specifying the pattern "{foo/{,cat,dog},bar}" would return the same results as four separate B<glob>()  calls using the strings: "foo/", "foo/cat", "foo/dog", and "bar".
fr: Développer dans le style B<csh>(1) les expressions de type B<{a,b}>. Les expressions entre accolades peuvent être imbriquées. Ainsi, par exemple, spécifier le motif « {foo/{,cat,dog},bar} » retournera le même résultat que quatre appels à B<glob>() séparés utilisant les chaînes : « foo/ », « foo/cat », « foo/dog », et « bar ».

note: type: Plain text
en: If the pattern contains no metacharacters, then it should be returned as the sole matching word, even if there is no file with that name.
fr: Si le motif renvoyé ne contient pas de méta-caractères, il sera retourné comme seul mot correspondant, même s'il n'existe pas de fichier avec ce nom.

note: type: Plain text
en: Carry out tilde expansion.  If a tilde (\(aq~\(aq) is the only character in the pattern, or an initial tilde is followed immediately by a slash (\(aq/\(aq), then the home directory of the caller is substituted for the tilde.  If an initial tilde is followed by a username (e.g., "~andrea/bin"), then the tilde and username are substituted by the home directory of that user.  If the username is invalid, or the home directory cannot be determined, then no substitution is performed.
fr: Prendre en charge l'expansion du tilde. Si un tilde (« ~ ») est le seul caractère du motif, ou si un tilde en tête est suivi par une barre oblique (« / »), le répertoire personnel de l'appelant sera substitué au tilde. Si un tilde en tête est suivi par un nom d'utilisateur (par exemple, « ~alain/bin », le tilde et le nom d'utilisateur sont substitués par le répertoire personnel de cet utilisateur. Si le nom d'utilisateur n'est pas valide ou si le répertoire personnel ne peut pas être déterminé, la substitution n'est pas effectuée.

note: type: Plain text
en: This provides behavior similar to that of B<GLOB_TILDE>.  The difference is that if the username is invalid, or the home directory cannot be determined, then instead of using the pattern itself as the name, B<glob>()  returns B<GLOB_NOMATCH> to indicate an error.
fr: Fournit un comportement similaire à celui de B<GLOB_TILDE>. La différence est que si le nom d'utilisateur n'est pas valable ou si le répertoire personnel ne peut pas être déterminé, plutôt que d'utiliser le motif lui-même comme nom, B<glob>() renvoie B<GLOB_NOMATCH> pour indiquer l'erreur.

note: type: Plain text
en: This is a I<hint> to B<glob>()  that the caller is interested only in directories that match the pattern.  If the implementation can easily determine file-type information, then nondirectory files are not returned to the caller.  However, the caller must still check that returned files are directories.  (The purpose of this flag is merely to optimize performance when the caller is interested only in directories.)
fr: C'est une I<indication> pour B<glob>() indiquant que l'appelant ne s'intéresse qu'aux répertoires correspondant au motif. Si l'implémentation peut facilement déterminer le type de fichier, les fichiers qui ne sont pas des répertoires ne sont pas renvoyés à l'appelant. Toutefois, l'appelant doit toujours vérifier que les fichiers renvoyés sont des répertoires (le but de cet attribut est simplement d'optimiser les performances lorsque l'appelant ne s'intéresse qu'aux répertoires).

note: type: Plain text
en: If I<errfunc> is not NULL, it will be called in case of an error with the arguments I<epath>, a pointer to the path which failed, and I<eerrno>, the value of I<errno> as returned from one of the calls to B<opendir>(3), B<readdir>(3), or B<stat>(2).  If I<errfunc> returns nonzero, or if B<GLOB_ERR> is set, B<glob>()  will terminate after the call to I<errfunc>.
fr: Si I<errfunc> n'est pas NULL, elle sera appelée en cas d'erreur, avec les arguments I<epath> un pointeur sur le chemin qui a échoué, et I<eerrno> la valeur de I<errno> telle qu'elle a été renvoyée par un appel à B<opendir>(3), B<readdir>(3) ou B<stat>(2). Si I<errfunc> renvoie une valeur non nulle, ou si B<GLOB_ERR> est positionné, B<glob>() se terminera après l'appel de I<errfunc>.

note: type: Plain text
en: Upon successful return, I<pglob-E<gt>gl_pathc> contains the number of matched pathnames and I<pglob-E<gt>gl_pathv> contains a pointer to the list of pointers to matched pathnames.  The list of pointers is terminated by a null pointer.
fr: Si B<glob>() réussit complètement, I<pglob-E<gt>gl_pathc> contient le nombre de chemins d'accès correspondants et I<pglob-E<gt>gl_pathv> contient un pointeur sur une liste des chemins. Le premier pointeur après le dernier chemin vaut NULL.

note: type: Plain text
en: It is possible to call B<glob>()  several times.  In that case, the B<GLOB_APPEND> flag has to be set in I<flags> on the second and later invocations.
fr: Il est possible d'appeler B<glob>() plusieurs fois. Dans ce cas, l'attribut B<GLOB_APPEND> doit être indiqué dans I<flags> durant le second appel et les suivants.

note: type: Plain text
en: As a GNU extension, I<pglob-E<gt>gl_flags> is set to the flags specified, B<or>ed with B<GLOB_MAGCHAR> if any metacharacters were found.
fr: En tant qu'extension GNU, le champ I<pglob-E<gt>gl_flags> contient les attributs indiqués liés par un B<OU> avec B<GLOB_MAGCHAR> si un méta-caractère a été trouvé.

note: type: Plain text
en: On successful completion, B<glob>()  returns zero.  Other possible returns are:
fr: S'il réussit complètement B<glob>() renvoie zéro. Les autres valeurs renvoyées peuvent être\ :

note: type: Plain text
en: for running out of memory,
fr: pas assez de mémoire,

note: type: Plain text
en: for a read error, and
fr: erreur de lecture,

note: type: Plain text
en: for no found matches.
fr: aucune correspondance trouvée.

note: type: Plain text
en: The structure elements I<gl_pathc> and I<gl_offs> are declared as I<size_t> in glibc 2.1, as they should be according to POSIX.2, but are declared as I<int> in libc4, libc5 and glibc 2.0.
fr: Les membres I<gl_pathc> et I<gl_offs> de la structure glob_t sont des I<size_t> dans glibc 2.1, comme indiqué dans POSIX.2, mais sont déclarés sous forme de I<int> dans libc4, libc5 et glibc 2.0.

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: The B<glob>()  function may fail due to failure of underlying function calls, such as B<malloc>(3)  or B<opendir>(3).  These will store their error code in I<errno>.
fr: La fonction B<glob>() peut échouer en cas d'erreur dans un appel de fonction sous-jacent, comme B<malloc>(3) ou B<opendir>(3). Le code d'erreur sera alors stocké dans I<errno>.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: One example of use is the following code, which simulates typing
fr: L'exemple d'utilisation suivant simule la frappe de

note: type: Plain text
en: in the shell:
fr: dans un shell\ :

note: type: Plain text
en: globbuf.gl_offs = 2;
    glob("*.c", GLOB_DOOFFS, NULL, &globbuf);
    glob("../*.c", GLOB_DOOFFS | GLOB_APPEND, NULL, &globbuf);
    globbuf.gl_pathv[0] = "ls";
    globbuf.gl_pathv[1] = "-l";
    execvp("ls", &globbuf.gl_pathv[0]);
fr: globbuf.gl_offs = 2;
    glob("*.c", GLOB_DOOFS, NULL, &globbuf);
    glob("../*.c", GLOB_DOOFS | GLOB_APPEND, NULL, &globbuf);
    globbuf.gl_pathv[0] = "ls";
    globbuf.gl_pathv[1] = "-l";
    execvp("ls", &globbuf.gl_pathv[0]);

note: type: TH
en: 2012-07-28
fr: 28 juillet 2012

note: type: Plain text
en: glob - globbing pathnames
fr: glob - Développement des noms de fichiers

note: type: Plain text
en: Long ago, in UNIX V6, there was a program I</etc/glob> that would expand wildcard patterns.  Soon afterward this became a shell built-in.
fr: Il y a bien longtemps, dans UNIX V6, existait un programme nommé I</etc/glob> qui permettait de développer les motifs génériques dans les noms de fichiers. Ce programme devint bientôt une routine interne du shell.

note: type: Plain text
en: These days there is also a library routine B<glob>(3)  that will perform this function for a user program.
fr: De nos jours, on trouve également une routine de bibliothèque nommée B<glob>(3) qui effectue le même travail en étant invoquée par un programme utilisateur.

note: type: Plain text
en: The rules are as follows (POSIX.2, 3.13).
fr: Les règles de développement sont les suivantes (POSIX.2, 3.13).

note: type: SS
en: Wildcard matching
fr: Motifs génériques

note: type: Plain text
en: A string is a wildcard pattern if it contains one of the characters \(aq?\(aq, \(aq*\(aq or \(aq[\(aq.  Globbing is the operation that expands a wildcard pattern into the list of pathnames matching the pattern.  Matching is defined by:
fr: Une chaîne est un motif générique si elle contient un ou plusieurs caractères parmi «\ ?\ », «\ *\ » et «\ [\ ». Le développement (I<globbing>) est l'opération qui transforme un motif générique en une liste de noms de fichiers correspondant à ce motif. La correspondance est définie ainsi\ :

note: type: Plain text
en: A \(aq?\(aq (not between brackets) matches any single character.
fr: Un «\ ?\ » (sans les guillemets) correspond à n'importe quel caractère.

note: type: Plain text
en: A \(aq*\(aq (not between brackets) matches any string, including the empty string.
fr: Un «\ *\ » (sans les guillemets) correspond à n'importe quelle chaîne, y compris la chaîne vide.

note: type: Plain text
en: B<Character classes>
fr: B<Classes de caractères>

note: type: Plain text
en: An expression "I<[...]>" where the first character after the leading \(aq[\(aq is not an \(aq!\(aq matches a single character, namely any of the characters enclosed by the brackets.  The string enclosed by the brackets cannot be empty; therefore \(aq]\(aq can be allowed between the brackets, provided that it is the first character.  (Thus, "I<[][!]>" matches the three characters \(aq[\(aq, \(aq]\(aq and \(aq!\(aq.)
fr: Une expression du type «\ I<[...]>\ », dans laquelle le premier caractère après le «\ [\ » n'est pas un «\ !\ » est mise en correspondance avec un seul des caractères contenus entre les crochets. L'ensemble des caractères cités ne peut pas être vide, ainsi, le crochet fermant «\ ]\ » peut être présent dans l'ensemble, à la condition qu'il soit en première place. Par conséquent, la chaîne «\ I<[][!]>\ » peut être mise en correspondance avec l'un des trois caractères «\ [\ », «\ ]\ » et «\ !\ ».

note: type: Plain text
en: B<Ranges>
fr: B<Intervalles>

note: type: Plain text
en: There is one special convention: two characters separated by \(aq-\(aq denote a range.  (Thus, "I<[A-Fa-f0-9]>" is equivalent to "I<[ABCDEFabcdef0123456789]>".)  One may include \(aq-\(aq in its literal meaning by making it the first or last character between the brackets.  (Thus, "I<[]-]>" matches just the two characters \(aq]\(aq and \(aq-\(aq, and "I<[--0]>" matches the three characters \(aq-\(aq, \(aq.\(aq, \(aq0\(aq, since \(aq/\(aq cannot be matched.)
fr: Il existe une convention particulière, suivant laquelle deux caractères séparés par un tiret «\ -\ » indiquent un intervalle. Ainsi, «\ I<[A-Fa-f0-9]>\ » équivaut à «\ I<[ABCDEFabcdef0123456789]>\ ». Pour inclure un tiret au sens littéral, il suffit de l'utiliser en premier ou en dernier entre les crochets. Ainsi, «\ I<[]-]>\ » correspond uniquement aux caractères «\ ]\ » et «\ -\ », et «\ I<[--0]>\ » correspond aux trois caractères «\ -\ », «\ .\ » et «\ 0\ », puisqu'il ne peut y avoir de correspondance avec « / ».

note: type: Plain text
en: B<Complementation>
fr: B<Négation>

note: type: Plain text
en: An expression "I<[!...]>" matches a single character, namely any character that is not matched by the expression obtained by removing the first \(aq!\(aq from it.  (Thus, "I<[!]a-]>" matches any single character except \(aq]\(aq, \(aqa\(aq and \(aq-\(aq.)
fr: Une expression «\ I<[!...]>\ » correspond à n'importe quel caractère qui ne puisse pas être mis en correspondance avec la chaîne obtenue en supprimant le «\ !\ » initial (ainsi, «\ I<[!]a-]>\ » correspond à tout caractère sauf «\ ]\ », «\ a\ » et «\ -\ »).

note: type: Plain text
en: One can remove the special meaning of \(aq?\(aq, \(aq*\(aq and \(aq[\(aq by preceding them by a backslash, or, in case this is part of a shell command line, enclosing them in quotes.  Between brackets these characters stand for themselves.  Thus, "I<[[?*\e]>" matches the four characters \(aq[\(aq, \(aq?\(aq, \(aq*\(aq and \(aq\e\(aq.
fr: On peut désactiver le comportement spécial des caractères «\ ?\ », «\ *\ » et «\ [\ » en les faisant précéder par une barre oblique inverse «\ \e\ », ou, dans le cas d'une ligne de commande shell, en les encadrant par des guillemets. Entre crochets, ces caractères ne prennent que leur signification littérale. Ainsi, «\ I<[[?*\e]>\ » correspond aux quatre caractères «\ [\ », «\ ?\ », «\ *\ » et «\ \e\ ».

note: type: SS
en: Pathnames
fr: Chemins d'accès

note: type: Plain text
en: Globbing is applied on each of the components of a pathname separately.  A \(aq/\(aq in a pathname cannot be matched by a \(aq?\(aq or \(aq*\(aq wildcard, or by a range like "I<[.-0]>".  A range cannot contain an explicit \(aq/\(aq character; this would lead to a syntax error.
fr: Le développement est appliqué à chaque composant du chemin d'accès séparément. Un «\ /\ » dans un chemin ne peut pas être mis en correspondance avec un «\ ?\ » ou «\ *\ », ni par un intervalle tel que «\ I<[.-0]>\ ». Un intervalle ne peut pas contenir explicitement un caractère «\ /\ ». Ceci déclencherait une erreur de syntaxe.

note: type: Plain text
en: If a filename starts with a \(aq.\(aq, this character must be matched explicitly.  (Thus, I<rm\ *> will not remove .profile, and I<tar\ c\ *> will not archive all your files; I<tar\ c\ .> is better.)
fr: Si un nom de fichier commence par un «\ .\ », ce caractère doit être mis en correspondance explicitement (ainsi, I<rm *> ne supprimera pas .profile, et I<tar c *> n'archivera pas tous les fichiers\ ; I<tar c .>serait préférable).

note: type: SS
en: Empty lists
fr: Listes vides

note: type: Plain text
en: The nice and simple rule given above: "expand a wildcard pattern into the list of matching pathnames" was the original UNIX definition.  It allowed one to have patterns that expand into an empty list, as in
fr: La définition simple et élégante fournie plus haut «\ transformer un motif générique en une liste de noms de fichiers correspondants\ » est la définition UNIX originale. Elle autorisait la présence de motif se développant en listes vides, comme

note: type: Plain text
en: where perhaps no *.gif files are present (and this is not an error).  However, POSIX requires that a wildcard pattern is left unchanged when it is syntactically incorrect, or the list of matching pathnames is empty.  With I<bash> one can force the classical behavior using this command:
fr: alors qu'il n'y a peut-être aucun fichier *.gif présent (et on ne peut pas considérer cela comme une erreur). Toutefois, POSIX réclame qu'un motif soit laissé inchangé s'il est syntaxiquement incorrect, ou si la liste des noms de fichiers correspondants est vide. On peut forcer B<bash> à adopter le comportement classique en utilisant cette commande :

note: type: Plain text
en: (Similar problems occur elsewhere.  E.g., where old scripts have
fr: (Des problèmes similaires se produisent ailleurs. Par exemple, de vieux scripts avec

note: type: Plain text
en: new scripts require
fr: devraient être remplacés par des nouveaux scripts contenant

note: type: Plain text
en:     rm -f nosuchfile \`find . -name "*~"\`
fr:     rm -f fichier-non-existant \`find . -name "*~"\`

note: type: Plain text
en: to avoid error messages from I<rm> called with an empty argument list.)
fr: pour éviter les messages d'erreurs si B<rm> est invoqué avec une liste vide d'arguments).

note: type: SS
en: Regular expressions
fr: Expressions rationnelles

note: type: Plain text
en: Note that wildcard patterns are not regular expressions, although they are a bit similar.  First of all, they match filenames, rather than text, and secondly, the conventions are not the same: for example, in a regular expression \(aq*\(aq means zero or more copies of the preceding thing.
fr: Notez que les motifs génériques ne sont pas des expressions rationnelles bien qu'ils leur ressemblent. Tout d'abord, ils correspondent à des noms de fichiers, et pas à du texte. De plus, les conventions ne sont pas identiques. Par exemple, dans une expression rationnelle, «\ *\ » signifie zéro ou plusieurs copies de l'élément précédent.

note: type: Plain text
en: Now that regular expressions have bracket expressions where the negation is indicated by a \(aq^\(aq, POSIX has declared the effect of a wildcard pattern "I<[^...]>" to be undefined.
fr: Maintenant que les expressions rationnelles disposent de composants entre crochets où la négation est indiquée par un «\ ^\ », POSIX a précisé que le motif générique «\ I<[^...]>\ » a un effet indéfini.

note: type: SS
en: Character classes and internationalization
fr: Internationalisation et classes de caractères

note: type: Plain text
en: Of course ranges were originally meant to be ASCII ranges, so that "I<[\ -%]>" stands for "I<[\ !"#$%]>" and "I<[a-z]>" stands for "any lowercase letter".  Some UNIX implementations generalized this so that a range X-Y stands for the set of characters with code between the codes for X and for Y.  However, this requires the user to know the character coding in use on the local system, and moreover, is not convenient if the collating sequence for the local alphabet differs from the ordering of the character codes.  Therefore, POSIX extended the bracket notation greatly, both for wildcard patterns and for regular expressions.  In the above we saw three types of items that can occur in a bracket expression: namely (i) the negation, (ii) explicit single characters, and (iii) ranges.  POSIX specifies ranges in an internationally more useful way and adds three more types:
fr: Bien entendu, les intervalles ont été créés à l'origine en tant qu'intervalle ASCII où «\ I<[\ -%]>\ » signifie «\ I<[\ !"#$%]>\ » et «\ I<[a-z]>\ » correspond à «\ toute lettre minuscule\ ». Certaines implémentations UNIX ont généralisé ceci de manière à ce que l'intervalle X-Y corresponde à l'ensemble des caractères dont les codes se trouvent entre ceux de X et de Y. Néanmoins, ceci signifie que l'utilisateur doit connaître le codage utilisé sur le système local. De plus, ceci ne fonctionne pas si l'ordre de l'alphabet local n'est pas celui adopté pour le codage des caractères. POSIX a alors étendu grandement la notation des expressions entre crochets autant pour les motifs génériques que pour les expressions rationnelles. Nous avons vu précédemment 3 types d'éléments pouvant se trouver entre crochets. Plus précisément (i) une négation, (ii) des caractères explicites, et (iii) des intervalles. POSIX spécifie les intervalles d'une manière plus utile au niveau international, et ajoute trois nouveaux types\ :

note: type: Plain text
en: (iii) Ranges X-Y comprise all characters that fall between X and Y (inclusive) in the current collating sequence as defined by the B<LC_COLLATE> category in the current locale.
fr: (iii) Les intervalles X-Y comprenant tous les caractères se trouvant entre X et Y (inclus) dans l'ordre de l'alphabet décrit par la catégorie B<LC_COLLATE> de la localisation en cours.

note: type: Plain text
en: (iv) Named character classes, like
fr: (iv) Des classes de caractères comme

note: type: Plain text
en: so that one can say "I<[[:lower:]]>" instead of "I<[a-z]>", and have things work in Denmark, too, where there are three letters past \(aqz\(aq in the alphabet.  These character classes are defined by the B<LC_CTYPE> category in the current locale.
fr: Ainsi, on peut écrire «\ I<[[:lower:]]>\ » à la place de «\ I<[a-z]>\ », et que le comportement soit aussi valide au Danemark, où il existe 3 lettres postérieures au «\ z\ ». Ces classes de caractères sont définies par la catégorie B<LC_CTYPE> de la localisation en cours.

note: type: Plain text
en: (v) Collating symbols, like "I<[.ch.]>" or "I<[.a-acute.]>", where the string between "I<[.>" and "I<.]>" is a collating element defined for the current locale.  Note that this may be a multicharacter element.
fr: (v) Les symboles groupant plusieurs lettres comme «\ I<[.ch.]>\ » ou «\ I<[.a-acute.]>\ », dans lesquels les chaînes entre «\ I<[.>\ » et «\ I<.]>\ » sont un élément de classement (I<collating element>) défini dans la localisation en cours. Il peut également s'agir de multicaractères.

note: type: Plain text
en: (vi) Equivalence class expressions, like "I<[=a=]>", where the string between "I<[=>" and "I<=]>" is any collating element from its equivalence class, as defined for the current locale.  For example, "I<[[=a=]]>" might be equivalent to "I<[a\('a\(`a\(:a\(^a]>", that is, to "I<[a[.a-acute.][.a-grave.][.a-umlaut.][.a-circumflex.]]>".
fr: (vi) Des classes d'équivalence comme «\ I<[=a=]>\ », où la chaîne entre «\ I<[=>\ » et «\ I<=]>\ » est un élément de classement définissant une classe d'équivalence dans la localisation en cours. Par exemple, «\ I<[[=a=]]>\ » peut être équivalent à « I<[a\('a\(`a\(:a\(^a]> », c'est-à-dire «\ I<[a[.a-acute.][.a-grave.][.a-umlaut.][.a-circumflex.]]>\ ».

note: type: TH
en: 2013-06-21
fr: 21 juin 2013

note: type: Plain text
en: re_comp, re_exec - BSD regex functions
fr: re_comp, re_exec - Fonction BSD pour les expressions rationnelles (« regex »)

note: type: Plain text
en: B<re_comp>()  is used to compile the null-terminated regular expression pointed to by I<regex>.  The compiled pattern occupies a static area, the pattern buffer, which is overwritten by subsequent use of B<re_comp>().  If I<regex> is NULL, no operation is performed and the pattern buffer's contents are not altered.
fr: La fonction B<re_comp>() permet de compiler une expression rationnelle, terminée par un caractère nul, et pointée par I<regex>. Le motif compilé occupe une zone de mémoire statique, le tampon de motif, qui sera écrasée par un autre appel à B<re_comp>(). Si I<regex> vaut NULL, rien n'est effectué, et le contenu du tampon de motif n'est pas altéré.

note: type: Plain text
en: B<re_exec>()  is used to assess whether the null-terminated string pointed to by I<string> matches the previously compiled I<regex>.
fr: B<re_exec>() est utilisé pour vérifier si la chaîne terminée par un caractère nul, pointée par I<string> correspond au motif précédemment compilé par I<regex>.

note: type: Plain text
en: B<re_comp>()  returns NULL on successful compilation of I<regex> otherwise it returns a pointer to an appropriate error message.
fr: B<re_comp>() renvoie NULL s'il peut compiler correctement I<regex>, sinon, il renvoie un pointeur sur le message d'erreur approprié.

note: type: Plain text
en: B<re_exec>()  returns 1 for a successful match, zero for failure.
fr: B<re_exec>() renvoie 1 si la correspondance est exacte, zéro si elle échoue.

note: type: SH
en: ATTRIBUTES
fr: ATTRIBUTS

note: type: SS
en: Multithreading (see pthreads(7))
fr: Multithreading (voir pthreads(7))

note: type: Plain text
en: The B<re_comp>()  and B<re_exec>()  functions are not thread-safe.
fr: Les fonctions B<re_comp>() et B<re_exec>() ne sont pas sûres dans un contexte multithread.

note: type: Plain text
en: 4.3BSD.
fr: BSD\ 4.3.

note: type: Plain text
en: These functions are obsolete; the functions documented in B<regcomp>(3)  should be used instead.
fr: Ces fonctions sont obsolètes. L'utilisation de B<regcomp>(3) est recommandée à la place de ces fonctions.

note: type: Plain text
en: B<regcomp>(3), B<regex>(7), GNU regex manual
fr: B<regcomp>(3), B<regex>(7), Manuel GNU pour les expressions rationnelles

note: type: TH
en: 2013-02-11
fr: 11 février 2013

note: type: Plain text
en: regcomp, regexec, regerror, regfree - POSIX regex functions
fr: regcomp, regexec, regerror, regfree - Fonctions POSIX pour les expressions rationnelles (« regex »)

note: type: SS
en: POSIX regex compiling
fr: Compilation d'expressions rationnelles POSIX

note: type: Plain text
en: B<regcomp>()  is used to compile a regular expression into a form that is suitable for subsequent B<regexec>()  searches.
fr: B<regcomp>() est utilisée pour compiler une expression rationnelle sous une forme utilisable par la suite pour des recherches avec B<regexec>().

note: type: Plain text
en: B<regcomp>()  is supplied with I<preg>, a pointer to a pattern buffer storage area; I<regex>, a pointer to the null-terminated string and I<cflags>, flags used to determine the type of compilation.
fr: On fournit à B<regcomp>() les arguments I<preg>, un pointeur vers une zone de stockage du motif, I<regex>, un pointeur vers une chaîne terminée par un caractère nul, et I<cflags>, les attributs indiquant le type de compilation.

note: type: Plain text
en: All regular expression searching must be done via a compiled pattern buffer, thus B<regexec>()  must always be supplied with the address of a B<regcomp>()  initialized pattern buffer.
fr: Toutes les recherches d'expressions rationnelles sont effectuées à travers la zone de motif compilé, ainsi B<regexec>() doit toujours recevoir l'adresse d'un motif initialisé par B<regcomp>().

note: type: Plain text
en: I<cflags> may be the bitwise-B<or> of one or more of the following:
fr: I<cflags> peut être un B<OU binaire> entre une ou plusieurs constantes symboliques suivantes\ :

note: type: Plain text
en: Use B<POSIX> Extended Regular Expression syntax when interpreting I<regex>.  If not set, B<POSIX> Basic Regular Expression syntax is used.
fr: Utiliser la syntaxe d'expression rationnelle étendue B<POSIX> pour interpréter I<regex>. Sinon, la syntaxe d'expression rationnelle de base B<POSIX> est utilisée.

note: type: Plain text
en: Do not differentiate case.  Subsequent B<regexec>()  searches using this pattern buffer will be case insensitive.
fr: Ne pas différencier les majuscules des minuscules. Les recherches B<regexec>() suivantes utilisant le tampon de motif n'effectueront pas la différenciation.

note: type: Plain text
en: Do not report position of matches.  The I<nmatch> and I<pmatch> arguments to B<regexec>()  are ignored if the pattern buffer supplied was compiled with this flag set.
fr: Ne pas signaler la position des correspondances de chaînes. Les paramètres I<nmatch> et I<pmatch> de B<regexec>() ne sont pas pris en compte si le tampon de motif est compilé avec cet attribut.

note: type: Plain text
en: Match-any-character operators don't match a newline.
fr: L'opérateur «\ n'importe-quel-caractère\ » ne s'identifie pas avec le saut de ligne.

note: type: Plain text
en: A nonmatching list (B<[^...]>)  not containing a newline does not match a newline.
fr: Une liste d'exceptions (B<[^...]>) ne contenant pas de saut de ligne ne s'identifie pas avec un saut de ligne.

note: type: Plain text
en: Match-beginning-of-line operator (B<^>)  matches the empty string immediately after a newline, regardless of whether I<eflags>, the execution flags of B<regexec>(), contains B<REG_NOTBOL>.
fr: L'opérateur «\ début-de-ligne\ » (B<^>) s'identifie avec une chaîne vide suivant immédiatement un saut de ligne, même si l'attribut I<eflags> de B<regexec>() contient B<REG_NOTBOL>.

note: type: Plain text
en: Match-end-of-line operator (B<$>)  matches the empty string immediately before a newline, regardless of whether I<eflags> contains B<REG_NOTEOL>.
fr: L'opérateur «\ fin-de-ligne\ » (B<$>) s'identifie avec une chaîne vide précédant immédiatement un saut de ligne, même si l'attribut I<eflags> contient B<REG_NOTEOL>.

note: type: SS
en: POSIX regex matching
fr: Correspondance d'expressions rationnelles POSIX

note: type: Plain text
en: B<regexec>()  is used to match a null-terminated string against the precompiled pattern buffer, I<preg>.  I<nmatch> and I<pmatch> are used to provide information regarding the location of any matches.  I<eflags> may be the bitwise-B<or> of one or both of B<REG_NOTBOL> and B<REG_NOTEOL> which cause changes in matching behavior described below.
fr: B<regexec>() est utilisée pour mettre en correspondance une chaîne terminée par un caractère nul, avec le tampon de motif précompilé I<preg>. I<nmatch> et I<pmatch> fournissent des informations concernant l'emplacement des correspondances. I<eflags> peut être un B<OU binaire> entre les constantes B<REG_NOTBOL> ou B<REG_NOTEOL> qui modifient le comportement de la mise en correspondance décrite ci-dessous.

note: type: Plain text
en: The match-beginning-of-line operator always fails to match (but see the compilation flag B<REG_NEWLINE> above).  This flag may be used when different portions of a string are passed to B<regexec>()  and the beginning of the string should not be interpreted as the beginning of the line.
fr: L'opérateur «\ début-de-ligne\ » échoue toujours (mais voyez l'attribut de compilation B<REG_NEWLINE> ci-dessus). Cet attribut peut être utilisé quand différentes portions d'une chaîne sont transmises à B<regexec>() et que le début de la chaîne ne correspond pas à un début de ligne.

note: type: Plain text
en: The match-end-of-line operator always fails to match (but see the compilation flag B<REG_NEWLINE> above).
fr: L'opérateur «\ fin-de-ligne\ » échoue toujours (mais voyez l'attribut de compilation B<REG_NEWLINE> ci-dessus).

note: type: SS
en: Byte offsets
fr: Décalage d'octets

note: type: Plain text
en: Unless B<REG_NOSUB> was set for the compilation of the pattern buffer, it is possible to obtain match addressing information.  I<pmatch> must be dimensioned to have at least I<nmatch> elements.  These are filled in by B<regexec>()  with substring match addresses.  The offsets of the subexpression starting at the I<i>th open parenthesis are stored in I<pmatch[i]>.  The entire regular expression's match addresses are stored in I<pmatch[0]>.  (Note that to return the offsets of I<N> subexpression matches, I<nmatch> must be at least I<N+1>.)  Any unused structure elements will contain the value -1.
fr: À moins que l'attribut B<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. I<pmatch> doit être dimensionnée pour contenir au moins I<nmatch> éléments. Ils sont remplis par B<regexec>() avec les adresses des sous-chaînes mises en correspondance. Les positions de la sous-expression débutant à la I<i>e parenthèse sont stockées dans I<pmatch[i]>. Les adresses de mise en correspondance de l'expression complète sont stockées dans  I<pmatch[0]>. (Remarquez que pour obtenir les positions de correspondance de la sous-expression I<N>, I<nmatch> doit valoir au moins I<N+1>.) Tous les éléments de structure inutilisés contiendront la valeur -1.

note: type: Plain text
en: The I<regmatch_t> structure which is the type of I<pmatch> is defined in I<E<lt>regex.hE<gt>>.
fr: La structure I<regmatch_t> du type I<pmatch> est définie dans I<E<lt>regex.hE<gt>>.

note: type: Plain text
en: Each I<rm_so> element that is not -1 indicates the start offset of the next largest substring match within the string.  The relative I<rm_eo> element indicates the end offset of the match, which is the offset of the first character after the matching text.
fr: Chaque élément I<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 I<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.

note: type: SS
en: POSIX error reporting
fr: Retours d'erreurs POSIX

note: type: Plain text
en: B<regerror>()  is used to turn the error codes that can be returned by both B<regcomp>()  and B<regexec>()  into error message strings.
fr: B<regerror>() est utilisé pour transformer les codes d'erreur renvoyés par B<regcomp>() et par B<regexec>() en libellés.

note: type: Plain text
en: B<regerror>()  is passed the error code, I<errcode>, the pattern buffer, I<preg>, a pointer to a character string buffer, I<errbuf>, and the size of the string buffer, I<errbuf_size>.  It returns the size of the I<errbuf> required to contain the null-terminated error message string.  If both I<errbuf> and I<errbuf_size> are nonzero, I<errbuf> is filled in with the first I<errbuf_size - 1> characters of the error message and a terminating null byte (\(aq\e0\(aq).
fr: B<regerror>() reçoit le code I<errcode>, le tampon de motif I<preg>, un pointeur sur une chaîne de caractères I<errbuf>, et la longueur maximale de cette chaîne I<errbuf_size>. Cette fonction renvoie la taille I<errbuf> nécessaire pour contenir le libellé d'erreur terminé par un caractère nul. Si I<errbuf> et I<errbuf_size> son non nuls, I<errbuf> est rempli avec les I<errbuf_size - 1> premiers caractères du libellé d'erreur, suivis d'un caractère nul de terminaison («\ \e0\ »).

note: type: SS
en: POSIX pattern buffer freeing
fr: Libération des tampons de motifs POSIX

note: type: Plain text
en: Supplying B<regfree>()  with a precompiled pattern buffer, I<preg> will free the memory allocated to the pattern buffer by the compiling process, B<regcomp>().
fr: En fournissant à B<regfree>() un tampon de motif précompilé I<preg>, il libérera la mémoire allouée au tampon durant la compilation avec B<regcomp>().

note: type: Plain text
en: B<regcomp>()  returns zero for a successful compilation or an error code for failure.
fr: B<regcomp>() renvoie zéro si la compilation réussit, ou un code d'erreur en cas d'échec.

note: type: Plain text
en: B<regexec>()  returns zero for a successful match or B<REG_NOMATCH> for failure.
fr: B<regexec>() renvoie zéro si la correspondance réussit, et B<REG_NOMATCH> si elle échoue.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: The following errors can be returned by B<regcomp>():
fr: Les erreurs suivantes peuvent être déclenchées par B<regcomp>()\ :

note: type: Plain text
en: Invalid use of back reference operator.
fr: Utilisation illégale de l'opérateur de référence inverse.

note: type: Plain text
en: Invalid use of pattern operators such as group or list.
fr: Utilisation illégale d'un opérateur du type groupe ou liste.

note: type: Plain text
en: Invalid use of repetition operators such as using \(aq*\(aq as the first character.
fr: Utilisation invalide d'opérateurs de répétition, comme un caractère «\ *\ » en première place.

note: type: Plain text
en: Un-matched brace interval operators.
fr: Accolade manquante.

note: type: Plain text
en: Un-matched bracket list operators.
fr: Crochet manquant.

note: type: Plain text
en: Invalid collating element.
fr: Élément de classement invalide.

note: type: Plain text
en: Unknown character class name.
fr: Nom de classe de caractère inconnu.

note: type: Plain text
en: Nonspecific error.  This is not defined by POSIX.2.
fr: Erreur non spécifique. Elle n'est pas définie par POSIX.2.

note: type: Plain text
en: Trailing backslash.
fr: Barre oblique inverse de fin.

note: type: Plain text
en: Un-matched parenthesis group operators.
fr: Parenthèse manquante.

note: type: Plain text
en: Invalid use of the range operator; for example, the ending point of the range occurs prior to the starting point.
fr: 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.

note: type: Plain text
en: Compiled regular expression requires a pattern buffer larger than 64Kb.  This is not defined by POSIX.2.
fr: La compilation aurait besoin d'un tampon de taille supérieure à 64 Ko. Ce n'est pas défini par POSIX.2.

note: type: Plain text
en: The regex routines ran out of memory.
fr: Les routines regex ont épuisé la mémoire.

note: type: Plain text
en: Invalid back reference to a subexpression.
fr: Référence inverse illégale vers une sous-expression.

note: type: Plain text
en: The glibc manual section, I<Regular Expression Matching>
fr: La section I<Regular Expression Matching> du manuel de glibc

note: type: TH
en: 2009-01-12
fr: 12 janvier 2009

note: type: Plain text
en: regex - POSIX.2 regular expressions
fr: regex - Expressions rationnelles POSIX.2

note: type: Plain text
en: Regular expressions ("RE"s), as defined in POSIX.2, come in two forms: modern REs (roughly those of I<egrep>; POSIX.2 calls these "extended" REs)  and obsolete REs (roughly those of B<ed>(1); POSIX.2 "basic" REs).  Obsolete REs mostly exist for backward compatibility in some old programs; they will be discussed at the end.  POSIX.2 leaves some aspects of RE syntax and semantics open; "\*(dg" marks decisions on these aspects that may not be fully portable to other POSIX.2 implementations.
fr: Les expressions rationnelles («\ ER\ »), définies par POSIX.2 existent sous deux formes\ : les ER modernes (en gros celles de I<egrep>\ ; que POSIX.2 appelle expressions rationnelles «\ étendues\ »), et les ER obsolètes (en gros celles de B<ed>(1)\ ; les ER de base pour POSIX.2) (N.d.T.\ : le terme «\ officiel\ » pour la traduction de «\ regular expression\ » est «\ expression rationnelle\ », et c'est celui que j'emploierai. Toutefois, on utilise couramment le terme «\ expression régulière\ », même s'il s'agit d'un léger abus de langage). Les ER obsolètes existent surtout à titre de compatibilité avec d'anciens programmes\ ; on en parlera à la fin. POSIX.2 laisse de côté certains aspects syntaxiques et sémantiques des ER\ ; un signe «\ \*(dg\ » indique une interprétation qui peut ne pas être totalement portable sur d'autres implémentations de POSIX.2.

note: type: Plain text
en: A (modern) RE is one\*(dg or more nonempty\*(dg I<branches>, separated by \(aq|\(aq.  It matches anything that matches one of the branches.
fr: Une ER (moderne) est une\*(dg ou plusieurs I<branches> non-vides\*(dg, séparées par «\ |\ ». Elle correspond à tout ce qui correspond à l'une des branches.

note: type: Plain text
en: A branch is one\*(dg or more I<pieces>, concatenated.  It matches a match for the first, followed by a match for the second, and so on.
fr: Une branche est une\*(dg ou plusieurs I<pièces> concaténées. Elle correspond à ce qui correspond à la première pièce, suivi de ce qui correspond à la seconde, et ainsi de suite.

note: type: Plain text
en: A piece is an I<atom> possibly followed by a single\*(dg \(aq*\(aq, \(aq+\(aq, \(aq?\(aq, or I<bound>.  An atom followed by \(aq*\(aq matches a sequence of 0 or more matches of the atom.  An atom followed by \(aq+\(aq matches a sequence of 1 or more matches of the atom.  An atom followed by \(aq?\(aq matches a sequence of 0 or 1 matches of the atom.
fr: Une pièce est un I<atome> suivi éventuellement d'un unique\*(dg «\ *\ », «\ +\ », «\ ?\ », ou d'un I<encadrement>. Un atome suivi de «\ *\ » correspond à une séquence de 0 ou plusieurs correspondances pour l'atome. Un atome suivi d'un «\ +\ » correspond à une séquence de 1 ou plusieurs correspondances pour l'atome. Un atome suivi d'un «\ ?\ » correspond à une séquence de zéro ou une correspondance pour l'atome.

note: type: Plain text
en: A I<bound> is \(aq{\(aq followed by an unsigned decimal integer, possibly followed by \(aq,\(aq possibly followed by another unsigned decimal integer, always followed by \(aq}\(aq.  The integers must lie between 0 and B<RE_DUP_MAX> (255\*(dg) inclusive, and if there are two of them, the first may not exceed the second.  An atom followed by a bound containing one integer I<i> and no comma matches a sequence of exactly I<i> matches of the atom.  An atom followed by a bound containing one integer I<i> and a comma matches a sequence of I<i> or more matches of the atom.  An atom followed by a bound containing two integers I<i> and I<j> matches a sequence of I<i> through I<j> (inclusive) matches of the atom.
fr: Un I<encadrement> est un «\ {\ » suivi d'un entier décimal non-signé, suivis éventuellement d'une virgule, suivis éventuellement d'un entier décimal non-signé, toujours suivis d'un «\ }\ ». Les entiers doivent être entre 0 et B<RE_DUP_MAX> (255\*(dg) compris, et s'il y en a deux, le second ne doit pas être plus petit que le premier. Un atome suivi d'un encadrement contenant un entier I<i> et pas de virgule correspond à une séquence de I<i> correspondances pour l'atome exactement. Un atome suivi d'un encadrement contenant un entier I<i> et une virgule correspond à une séquence d'au moins I<i> correspondances pour l'atome. Un atome suivi d'un encadrement contenant deux entiers I<i> et I<j> correspond à une séquence de I<i> à I<j> (compris) correspondances pour l'atome.

note: type: Plain text
en: An atom is a regular expression enclosed in "I<()>" (matching a match for the regular expression), an empty set of "I<()>" (matching the null string)\*(dg, a I<bracket expression> (see below), \(aq.\(aq (matching any single character), \(aq^\(aq (matching the null string at the beginning of a line), \(aq$\(aq (matching the null string at the end of a line), a \(aq\e\(aq followed by one of the characters "I<^.[$()|*+?{\e>" (matching that character taken as an ordinary character), a \(aq\e\(aq followed by any other character\*(dg (matching that character taken as an ordinary character, as if the \(aq\e\(aq had not been present\*(dg), or a single character with no other significance (matching that character).  A \(aq{\(aq followed by a character other than a digit is an ordinary character, not the beginning of a bound\*(dg.  It is illegal to end an RE with \(aq\e\(aq.
fr: Un atome est une expression rationnelle encadrée par des parenthèses (correspondant à ce qui correspond à l'expression rationnelle), un ensemble vide «\ I<()>\ » (correspondant à une chaîne nulle)\*(dg, une I<expression entre crochets> (voir plus bas), un point «\ .\ » (correspondant à n'importe quel caractère), un accent «\ ^\ » (correspondant à une chaîne vide en début de ligne), «\ $\ » (correspondant à une chaîne vide en fin de ligne), un «\ \e\ » suivi d'un des caractères «\ I<^.[$()|*+?{\e>\ » (correspondant au caractère littéral - sans signification particulière), un «\ \e\ » suivi de n'importe quel autre caractère\*(dg (correspondant au caractère pris sous forme littérale, comme si le «\ \e\ » était absent\*(dg), ou un caractère simple sans signification particulière (correspondant à ce caractère). Un «\ {\ » suivi d'un caractère autre qu'un chiffre est considéré sous sa forme littérale, pas un encadrement\*(dg. Il est illégal de terminer une ER avec un «\ \e\ » seul.

note: type: Plain text
en: A I<bracket expression> is a list of characters enclosed in "I<[]>".  It normally matches any single character from the list (but see below).  If the list begins with \(aq^\(aq, it matches any single character (but see below) I<not> from the rest of the list.  If two characters in the list are separated by \(aq-\(aq, this is shorthand for the full I<range> of characters between those two (inclusive) in the collating sequence, for example, "I<[0-9]>" in ASCII matches any decimal digit.  It is illegal\*(dg for two ranges to share an endpoint, for example, "I<a-c-e>".  Ranges are very collating-sequence-dependent, and portable programs should avoid relying on them.
fr: Une I<expression entre crochets> est une liste de caractères encadrés par «\ I<[]>\ ». Elle correspond normalement à n'importe quel caractère de la liste. Si la liste débute par «\ ^\ », elle correspond à n'importe quel caractère I<sauf> ceux de la liste. Si deux caractères de la liste sont séparés par un «\ -\ », ils représentent tout I<l'intervalle> de caractères entre eux (compris). Par exemple « I<[0-9]> » en ASCII représente n'importe quel chiffre décimal. Il est illégal\*(dg d'utiliser la même limite dans deux intervalles, comme «\ I<a-c-e>\ ». Les intervalles dépendent beaucoup de l'ordre de classement des caractères, et les programmes portables doivent éviter de les utiliser.

note: type: Plain text
en: To include a literal \(aq]\(aq in the list, make it the first character (following a possible \(aq^\(aq).  To include a literal \(aq-\(aq, make it the first or last character, or the second endpoint of a range.  To use a literal \(aq-\(aq as the first endpoint of a range, enclose it in "I<[.>" and "I<.]>" to make it a collating element (see below).  With the exception of these and some combinations using \(aq[\(aq (see next paragraphs), all other special characters, including \(aq\e\(aq, lose their special significance within a bracket expression.
fr: Pour insérer un «\ ]\ » littéral dans la liste, il faut le mettre en première position (ou après un éventuel «\ ^\ »). Pour inclure un «\ -\ » littéral, il faut le placer en première, dernière position, ou en seconde borne d'un intervalle. Pour utiliser un - en première borne d'intervalle, encadrez-le entre «\ I<[.>\ » et «\ I<.]>\ » pour en faire un élément de classement (voir plus bas). À l'exception de ces éléments, et de quelques combinaisons avec des crochets (voir plus bas), tous les autres caractères spéciaux, y compris le «\ \e\ », perdent leurs significations spéciales dans une expression entre crochets.

note: type: Plain text
en: Within a bracket expression, a collating element (a character, a multicharacter sequence that collates as if it were a single character, or a collating-sequence name for either)  enclosed in "I<[.>" and "I<.]>" stands for the sequence of characters of that collating element.  The sequence is a single element of the bracket expression's list.  A bracket expression containing a multicharacter collating element can thus match more than one character, for example, if the collating sequence includes a "ch" collating element, then the RE "I<[[.ch.]]*c>" matches the first five characters of "chchcc".
fr: Dans une expression entre crochets, un élément de classement (un seul caractère, ou une séquence de caractères qui se comporte comme un seul, ou un nom de séquence de classement) entre «\ I<[.>\ » et «\ I<.]>\ » correspond à la séquence des caractères de cet élément de classement. Une séquence est un élément unique de l'expression entre crochets. Ainsi, une expression entre crochets contenant un élément de classement multicaractères peut correspondre à plus d'un caractère. Par exemple, si la séquence inclut un élément de classement «\ ch\ », alors l'ER «\ I<[[.ch.]]*c>\ » correspond aux cinq premiers caractères de «\ chchcc\ ».

note: type: Plain text
en: Within a bracket expression, a collating element enclosed in "I<[=>" and "I<=]>" is an equivalence class, standing for the sequences of characters of all collating elements equivalent to that one, including itself.  (If there are no other equivalent collating elements, the treatment is as if the enclosing delimiters were "I<[.>" and "I<.]>".)  For example, if o and \o'o^' are the members of an equivalence class, then "I<[[=o=]]>", "I<[[=\o'o^'=]]>", and "I<[o\o'o^']>" are all synonymous.  An equivalence class may not\*(dg be an endpoint of a range.
fr: Dans une expression entre crochets, un élément de classement encadré par «\ I<[=>\ » et «\ I<=]>\ » est une classe d'équivalence, correspondant à la séquence des caractères de tous les éléments de classement équivalents à celui-ci, y compris lui-même (s'il n'y a pas d'autres éléments équivalents, le fonctionnement est le même que si l'encadrement était «\ I<[.>\ » et «\ I<.]>\ »). Par exemple, si o et \o'o^' sont membres d'une classe équivalence, alors «\ I<[[=o=]]>\ », «\ I<[[=\o'o^'=]]>\ », et «\ I<[o\o'o^']>\ » sont tous synonymes. Une classe d'équivalence ne doit\*(dg pas être une borne d'intervalle.

note: type: Plain text
en: Within a bracket expression, the name of a I<character class> enclosed in "I<[:>" and "I<:]>" stands for the list of all characters belonging to that class.  Standard character class names are:
fr: Dans une expression entre crochets, le nom d'une I<classe de caractères> encadré par «\ I<[:>\ » et «\ I<:]>\ » correspond à la liste de tous les caractères de la classe. Les noms des classes standard sont\ :

note: As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=295666 The following does not seem to apply in the glibc implementation .PP There are two special cases\*(dg of bracket expressions: the bracket expressions "\fI[[:<:]]\fP" and "\fI[[:>:]]\fP" match the null string at the beginning and end of a
en: These stand for the character classes defined in B<wctype>(3).  A locale may provide others.  A character class may not be used as an endpoint of a range.
fr: Cela correspond aux classes des caractères définies pour B<wctype>(3). Une localisation peut en fournir d'autres. Une classe de caractères ne doit pas être utilisée comme borne d'intervalle.

note: type: Plain text
en: In the event that an RE could match more than one substring of a given string, the RE matches the one starting earliest in the string.  If the RE could match more than one substring starting at that point, it matches the longest.  Subexpressions also match the longest possible substrings, subject to the constraint that the whole match be as long as possible, with subexpressions starting earlier in the RE taking priority over ones starting later.  Note that higher-level subexpressions thus take priority over their lower-level component subexpressions.
fr: Dans le cas où une ER peut correspondre à plusieurs sous-chaînes d'une chaîne donnée, elle correspond à celle qui commence le plus tôt dans la chaîne. Si l'ER peut correspondre à plusieurs sous-chaînes débutant au même point, elle correspond à la plus longue sous-chaîne. Les sous-expressions correspondent aussi à la plus longue sous-chaîne possible, à condition que la correspondance complète soit la plus longue possible, les sous-expressions débutant le plus tôt dans l'ER ayant priorité sur celles débutant plus loin. Notez que les sous-expressions de haut niveau ont donc priorité sur les sous-expressions de bas niveau les composant.

note: type: Plain text
en: Match lengths are measured in characters, not collating elements.  A null string is considered longer than no match at all.  For example, "I<bb*>" matches the three middle characters of "abbbc", "I<(wee|week)(knights|nights)>" matches all ten characters of "weeknights", when "I<(.*).*>" is matched against "abc" the parenthesized subexpression matches all three characters, and when "I<(a*)*>" is matched against "bc" both the whole RE and the parenthesized subexpression match the null string.
fr: La longueur des correspondances est mesurée en caractères, pas en éléments de classement. Une chaîne vide est considérée comme plus longue qu'aucune correspondance. Par exemple «\ I<bb*>\ » correspond aux trois caractères du milieu de «\ abbbc\ », «\ I<(wee|week)(knights|nights)>\ » correspond aux dix caractères de «\ weeknights\ », quand «\ I<(.*).*>\ » est mis en correspondance avec «\ abc\ », la sous-expression entre parenthèses correspond aux trois caractères, et si «\ I<(a*)*>\ » est mis en correspondance avec «\ bc\ » l'ER entière et la sous-ER entre parenthèses correspondent toutes deux avec une chaîne nulle.

note: type: Plain text
en: If case-independent matching is specified, the effect is much as if all case distinctions had vanished from the alphabet.  When an alphabetic that exists in multiple cases appears as an ordinary character outside a bracket expression, it is effectively transformed into a bracket expression containing both cases, for example, \(aqx\(aq becomes "I<[xX]>".  When it appears inside a bracket expression, all case counterparts of it are added to the bracket expression, so that, for example, "I<[x]>" becomes "I<[xX]>" and "I<[^x]>" becomes "I<[^xX]>".
fr: Si une correspondance sans distinction de casse est demandée, toutes les différences entre majuscules et minuscules disparaissent de l'alphabet. Un symbole alphabétique apparaissant hors d'une expression entre crochets est remplacé par une expression contenant les deux casses (par exemple «\ x\ » devient «\ I<[xX]>\ »). Lorsqu'il apparaît dans une expression entre crochets, tous ses équivalents sont ajoutés («\ I<[x]>\ » devient «\ I<[xX]>\ » et «\ I<[^x]>\ » devient «\ I<[^xX]>\ »).

note: type: Plain text
en: No particular limit is imposed on the length of REs\*(dg.  Programs intended to be portable should not employ REs longer than 256 bytes, as an implementation can refuse to accept such REs and remain POSIX-compliant.
fr: Aucune limite particulière n'est imposée sur la longueur est ER\*(dg. Les programmes destinés à être portables devrait limiter leurs ER à 256 octets, car une implémentation compatible POSIX peut refuser les expressions plus longues.

note: type: Plain text
en: Obsolete ("basic") regular expressions differ in several respects.  \(aq|\(aq, \(aq+\(aq, and \(aq?\(aq are ordinary characters and there is no equivalent for their functionality.  The delimiters for bounds are "I<\e{>" and "I<\e}>", with \(aq{\(aq and \(aq}\(aq by themselves ordinary characters.  The parentheses for nested subexpressions are "I<\e(>" and "I<\e)>", with \(aq(\(aq and \(aq)\(aq by themselves ordinary characters.  \(aq^\(aq is an ordinary character except at the beginning of the RE or\*(dg the beginning of a parenthesized subexpression, \(aq$\(aq is an ordinary character except at the end of the RE or\*(dg the end of a parenthesized subexpression, and \(aq*\(aq is an ordinary character if it appears at the beginning of the RE or the beginning of a parenthesized subexpression (after a possible leading \(aq^\(aq).
fr: Les expressions rationnelles obsolètes (de base) diffèrent sur plusieurs points. «\ |\ », «\ +\ », et «\ ?\ » sont des caractères normaux sans équivalents. Les délimiteurs d'encadrements sont «\ I<\e{>\ » et «\ I<\e}>\ », car «\ {\ » et «\ {\ » sont des caractères ordinaires. Les parenthèses pour les sous-expressions sont «\ I<\e(>\ » et «\ I<\e)>\ », car «\ (\ » et «\ )\ » sont des caractères ordinaires. «\ ^\ » est un caractère ordinaire sauf au début d'une ER ou au\*(dg début d'une sous-expression entre parenthèses, «\ $\ » est un caractère ordinaire sauf à la fin d'une ER ou à\*(dg la fin d'une sous-expressions entre parenthèses, et «\ *\ » est un caractère ordinaire s'il apparaît au début d'une ER ou au début d'une sous-expression entre parenthèses (après un éventuel «\ ^\ »).

note: type: Plain text
en: Finally, there is one new type of atom, a I<back reference>: \(aq\e\(aq followed by a nonzero decimal digit I<d> matches the same sequence of characters matched by the I<d>th parenthesized subexpression (numbering subexpressions by the positions of their opening parentheses, left to right), so that, for example, "I<\e([bc]\e)\e1>" matches "bb" or "cc" but not "bc".
fr: Enfin, il existe un nouveau type d'atome, la I<référence arrière>\ : «\ \e\ » suivi d'un chiffre décimal non-nul I<n> correspond à la même séquence de caractères que ceux mis en correspondance avec la I<n>-ième sous-expression entre parenthèses (les sous-expressions sont numérotées par leurs parenthèses ouvrantes, de gauche à droite), ainsi «\ I<\e([bc]\e)\e1>\ » correspond à «\ bb\ » ou «\ cc\ » mais pas à «\ bc\ ».

note: type: Plain text
en: Having two kinds of REs is a botch.
fr: Avoir deux sortes d'ER est un calvaire.

note: type: Plain text
en: The current POSIX.2 spec says that \(aq)\(aq is an ordinary character in the absence of an unmatched \(aq(\(aq; this was an unintentional result of a wording error, and change is likely.  Avoid relying on it.
fr: La norme POSIX.2 actuelle dit que «\ )\ » est un caractère ordinaire en l'absence de la «\ (\ » correspondante. C'est dû à une erreur d'interprétation et changera probablement. Évitez d'en tenir compte.

note: type: Plain text
en: Back references are a dreadful botch, posing major problems for efficient implementations.  They are also somewhat vaguely defined (does "I<a\e(\e(b\e)*\e2\e)*d>" match "abbbd"?).  Avoid using them.
fr: Les références arrières sont un vrai calvaire, et posent de gros problèmes d'efficacité pour l'implémentation. Elles sont de plus assez mal définies (est-ce que «\ I<a\e(\e(b\e)*\e2\e)*d>\ » correspond à «\ abbbd\ »\ ?). Évitez-les.

note: As per http://bugs.debian.org/cgi-bin/bugreport.cgi?bug=295666 The following does not seem to apply in the glibc implementation .PP The syntax for word boundaries is incredibly ugly. type: Plain text
en: POSIX.2's specification of case-independent matching is vague.  The "one case implies all cases" definition given above is current consensus among implementors as to the right interpretation.
fr: Les spécifications POSIX.2 sur les correspondances sans distinction de casse sont assez vagues. La description donnée plus haut est le consensus actuel parmi les implémenteurs.

note: type: SH
en: AUTHOR
fr: AUTEUR

note: Sigh... The page license means we must have the author's name in the formatted output. type: Plain text
en: This page was taken from Henry Spencer's regex package.
fr: Cette page a été prise dans le paquet regex de Henry Spencer.

note: type: Plain text
en: POSIX.2, section 2.8 (Regular Expression Notation).
fr: POSIX.2, section 2.8 (Regular Expression Notation).

note: type: TH
en: 2008-07-14
fr: 14 juillet 2008

note: type: Plain text
en: wordexp, wordfree - perform word expansion like a posix-shell
fr: wordexp, wordfree - Effectuer l'expansion de mots à la manière d'un shell POSIX

note: type: Plain text
en: Feature Test Macro Requirements for glibc (see B<feature_test_macros>(7)):
fr: Exigences de macros de test de fonctionnalités pour la glibc (consultez B<feature_test_macros>(7)) :

note: type: Plain text
en: B<wordexp>(), B<wordfree>(): _XOPEN_SOURCE
fr: B<wordexp>(), B<wordfree>() : _XOPEN_SOURCE

note: type: Plain text
en: The function B<wordexp>()  performs a shell-like expansion of the string I<s> and returns the result in the structure pointed to by I<p>.  The data type I<wordexp_t> is a structure that at least has the fields I<we_wordc>, I<we_wordv>, and I<we_offs>.  The field I<we_wordc> is a I<size_t> that gives the number of words in the expansion of I<s>.  The field I<we_wordv> is a I<char\ **> that points to the array of words found.  The field I<we_offs> of type I<size_t> is sometimes (depending on I<flags>, see below) used to indicate the number of initial elements in the I<we_wordv> array that should be filled with NULLs.
fr: La fonction B<wordexp>() effectue une expansion de type shell de la chaîne I<s> et retourne le résultat dans la structure pointée par I<p>. Le type de données I<wordexp_t> est une structure qui possède au moins les membres I<we_wordc>, I<we_wordv>, et I<we_offs>. Le membre I<we_wordc> est de type I<size_t> et donne le nombre de mots dans l'expansion de I<s>. Le membre I<we_wordv> est de type I<char\ **> et pointe sur le tableau des mots trouvés. Le membre I<we_offs> de type I<size_t> est quelquefois (suivant I<flags>, voir plus loin) utilisé pour indiquer le nombre d'éléments du tableau I<we_wordv> qui devraient être remplis initialement avec le caractère NULL.

note: type: Plain text
en: The function B<wordfree>()  frees the allocated memory again.  More precisely, it does not free its argument, but it frees the array I<we_wordv> and the strings that points to.
fr: La fonction B<wordfree>() libère la mémoire nouvellement allouée. Plus précisément, elle ne libère pas son argument mais libère le tableau I<we_wordv> ainsi que les chaînes vers lesquelles il pointe.

note: type: SS
en: The string argument
fr: L'argument chaîne

note: type: Plain text
en: Since the expansion is the same as the expansion by the shell (see B<sh>(1))  of the parameters to a command, the string I<s> must not contain characters that would be illegal in shell command parameters.  In particular, there must not be any unescaped newline or |, &, ;, E<lt>, E<gt>, (, ), {, } characters outside a command substitution or parameter substitution context.
fr: Puisque l'expansion est effectuée de la même manière que le shell (consultez B<sh>(1)) sur les paramètres d'une commande, la chaîne I<s> ne doit pas contenir de caractères qui seraient illégaux dans les paramètres d'une commande shell. En particulier, il ne doit pas y avoir de caractères nouvelle ligne ou |, &, ;, E<lt>, E<gt>, (, ), {, } non protégés en dehors d'un contexte de substitution de commande ou de paramètre.

note: type: Plain text
en: If the argument I<s> contains a word that starts with an unquoted comment character #, then it is unspecified whether that word and all following words are ignored, or the # is treated as a non-comment character.
fr: Si l'argument I<s> contient un mot qui débute par un caractère de commentaires «\ #\ » hors de tous guillemets, il n'est pas spécifié si ce mot et les suivants sont ignorés, ou si le # est considéré comme un caractère normal.

note: type: SS
en: The expansion
fr: L'expansion

note: type: Plain text
en: The expansion done consists of the following stages: tilde expansion (replacing ~user by user's home directory), variable substitution (replacing $FOO by the value of the environment variable FOO), command substitution (replacing $(command) or \`command\` by the output of command), arithmetic expansion, field splitting, wildcard expansion, quote removal.
fr: L'expansion effectuée consiste en les étapes suivantes\ : expansion du caractère tilde (remplacement de ~utilisateur par le répertoire personnel de l'utilisateur), substitution de variable (remplacement de $FOO par la valeur de la variable d'environnement FOO), substitution de commande (remplacement de $(commande) ou \`commande\` par la sortie de la commande), expansion arithmétique, découpage de champs, expansion des caractères de remplacement (wildcard), suppression des caractères de citation (I<quotes>).

note: type: Plain text
en: The result of expansion of special parameters ($@, $*, $#, $?, $-, $$, $!, $0) is unspecified.
fr: Le résultat de l'expansion de caractères spéciaux ($@, $*, $#, $?, $-, $$, $!, $0) n'est pas spécifié.

note: type: Plain text
en: Field splitting is done using the environment variable $IFS.  If it is not set, the field separators are space, tab and newline.
fr: Le découpage des champs est effectué en utilisant la variable d'environnement $IFS. Si elle n'est pas positionnée, les séparateurs de champs sont l'espace, la tabulation et le caractère nouvelle ligne.

note: type: SS
en: The output array
fr: Le tableau de sortie

note: type: Plain text
en: The array I<we_wordv> contains the words found, followed by a NULL.
fr: Le tableau I<we_wordv> contient les mots trouvés, suivis par le caractère NULL.

note: type: SS
en: The flags argument
fr: L'argument flags

note: type: Plain text
en: The I<flag> argument is a bitwise inclusive OR of the following values:
fr: L'argument I<flag> est un OU inclusif bit à bit des valeurs suivantes\ :

note: type: Plain text
en: Append the words found to the array resulting from a previous call.
fr: Ajouter les mots trouvés au tableau résultant d'un précédent appel.

note: type: Plain text
en: Insert I<we_offs> initial NULLs in the array I<we_wordv>.  (These are not counted in the returned I<we_wordc>.)
fr: Insérer I<we_offs> caractères initiaux NULL dans le tableau I<we_wordv> (ils ne seront pas comptés dans le membre I<we_wordc> retourné).

note: type: Plain text
en: Don't do command substitution.
fr: Ne pas effectuer la substitution de commande.

note: type: Plain text
en: The argument I<p> resulted from a previous call to B<wordexp>(), and B<wordfree>()  was not called.  Reuse the allocated storage.
fr: Le paramètre I<p> résulte d'un précédent appel à B<wordexp>(), et B<wordfree>() n'a pas été appelé. Réutiliser l'espace de stockage alloué.

note: type: Plain text
en: Normally during command substitution I<stderr> is redirected to I</dev/null>.  This flag specifies that I<stderr> is not to be redirected.
fr: Normalement, lors d'une substitution de commande, I<stderr> est redirigée vers I</dev/null>. Ce drapeau spécifie que I<stderr> ne sera pas redirigé.

note: type: Plain text
en: Consider it an error if an undefined shell variable is expanded.
fr: Considérer comme une erreur le fait qu'une variable shell non définie soit développée.

note: type: Plain text
en: In case of success 0 is returned.  In case of error one of the following five values is returned.
fr: Si elle réussit, la fonction renvoie 0. Si elle échoue, elle renvoie l'une des cinq valeurs suivantes\ :

note: type: Plain text
en: Illegal occurrence of newline or one of |, &, ;, E<lt>, E<gt>, (, ), {, }.
fr: Occurrence illégale d'un caractère nouvelle ligne ou d'un caractère parmi |, &, ;, E<lt>, E<gt>, (, ), {, }.

note: type: Plain text
en: An undefined shell variable was referenced, and the B<WRDE_UNDEF> flag told us to consider this an error.
fr: Il y a une référence à une variable shell non définie, et le drapeau B<WRDE_UNDEF> nous demande de considérer que c'est une erreur.

note: type: Plain text
en: Command substitution occurred, and the B<WRDE_NOCMD> flag told us to consider this an error.
fr: Une substitution de commande est apparue, et le drapeau B<WRDE_NOCMD> nous demande de considérer que c'est une erreur.

note: type: Plain text
en: Out of memory.
fr: Plus de mémoire disponible.

note: type: Plain text
en: Shell syntax error, such as unbalanced parentheses or unmatched quotes.
fr: Erreur de syntaxe shell, comme des parenthèses ou des guillemets non appariés.

note: type: Plain text
en: B<wordexp>()  and B<wordfree>()  are provided in glibc since version 2.1.
fr: B<wordexp>() et B<wordfree>() sont fournies par la glibc depuis la version 2.1.

note: type: Plain text
en: The output of the following example program is approximately that of "ls [a-c]*.c".
fr: La sortie du programme d'exemple suivant est approximativement celle de «\ ls [a-c]*.c\ ».
