perkamon - en to fr translation catalogue (247 entries)

note: type: TH
en: 2012-12-31
fr: 31 décembre 2012

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: __setfpucw - set FPU control word on i386 architecture (obsolete)
fr: __setfpucw - Positionner le mot de contrôle du FPU sur les machines i386 (obsolète)

note: type: Plain text
en: B<__setfpucw>()  transfers I<control_word> to the registers of the FPU (floating-point unit) on the i386 architecture.  This was used to control floating-point precision, rounding and floating-point exceptions.
fr: B<__setfpucw>() transfère le I<mot_de_controle> dans les registres du FPU (Floating Point Unit, unité de calcul en virgule flottante), sur les machines reposant sur une architecture à base de i386. Ceci permet de commander la précision des calculs en virgule flottante, les arrondis, et les exceptions mathématiques.

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

note: type: Plain text
en: This function was a nonstandard GNU extension.
fr: Cette fonction était une extension GNU non standard.

note: type: Plain text
en: As of glibc 2.1 this function does not exist anymore.  There are new functions from C99, with prototypes in I<E<lt>fenv.hE<gt>>, to control FPU rounding modes, like B<fegetround>(3), B<fesetround>(3), and the floating-point environment, like B<fegetenv>(3), B<feholdexcept>(3), B<fesetenv>(3), B<feupdateenv>(3), and FPU exception handling, like B<feclearexcept>(3), B<fegetexceptflag>(3), B<feraiseexcept>(3), B<fesetexceptflag>(3), and B<fetestexcept>(3).
fr: Depuis la glib  2.1, cette fonction n'existe plus. Il y a quelques nouvelles fonctions de C99, dont les prototypes se trouvent dans I<E<lt>fenv.hE<gt>>, permettant de commander le mode d'arrondi du FPU comme B<fegetround>(3), B<fesetround>(3), l'environnement en virgule flottante comme B<fegetenv>(3), B<feholdexcept>(3), B<fesetenv>(3), B<feupdateenv>(3) et la gestion des exception du FPU comme B<feclearexcept>(3), B<fegetexceptflag>(3), B<feraiseexcept>(3), B<fesetexceptflag>(3) et B<fetestexcept>(3).

note: type: Plain text
en: If direct access to the FPU control word is still needed, the B<_FPU_GETCW> and B<_FPU_SETCW> macros from I<E<lt>fpu_control.hE<gt>> can be used.
fr: Si l'accès direct au mot de commande du FPU est encore nécessaire, on peut utiliser les macros B<_FPU_GETCW> et B<_FPU_SETCW> de I<E<lt>fpu_control.hE<gt>>.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: Set FPU control word on the i386 architecture to
fr: Positionne le mot de contrôle du FPU sur une machine i386 ainsi\ :

note: type: Plain text
en:      - extended precision
fr:      - Précision étendue

note: type: Plain text
en:      - rounding to nearest
fr:      - Arrondi au plus proche

note: type: Plain text
en:      - exceptions on overflow, zero divide and NaN
fr:      - Exceptions si débordement, division par zéro, ou NaN (not a number)

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: 2008-06-14
fr: 14 juin 2008

note: type: Plain text
en: addseverity - introduce new severity classes
fr: addseverity - Introduire de nouvelles classes de sévérité

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<addseverity>(): _SVID_SOURCE
fr: B<addseverity>()\ : _SVID_SOURCE

note: type: Plain text
en: This function allows the introduction of new severity classes which can be addressed by the I<severity> argument of the B<fmtmsg>(3)  function.  By default that latter function only knows how to print messages for severity 0-4 (with strings (none), HALT, ERROR, WARNING, INFO).  This call attaches the given string I<s> to the given value I<severity>.  If I<s> is NULL, the severity class with the numeric value I<severity> is removed.  It is not possible to overwrite or remove one of the default severity classes.  The severity value must be nonnegative.
fr: Cette fonction permet l'introduction de nouvelles classes de sévérité qui peuvent être adressées par le paramètre I<severity> de la fonction B<fmtmsg>(3). Par défaut, cette dernière ne sait afficher des messages que pour les sévérités de 0 à 4 (avec les chaînes (none), HALT, ERROR, WARNING, INFO). Cet appel associe la chaîne I<s> donnée à la valeur I<severity> donnée. Si I<s> est vide (NULL), la classe de sévérité de valeur numérique I<severity> est supprimée. Il n'est pas possible de surcharger ou de supprimer une des classes de sévérité par défaut. La valeur de sévérité ne doit pas être négative.

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

note: type: Plain text
en: Upon success, the value B<MM_OK> is returned.  Upon error, the return value is B<MM_NOTOK>.  Possible errors include: out of memory, attempt to remove a nonexistent or default severity class.
fr: En cas de réussite, la valeur B<MM_OK> est renvoyée. En cas d'échec, la valeur de retour est B<MM_NOTOK>. Parmi les erreurs possibles, on trouve\ : pas assez de mémoire, tentative de suppression d'une classe de sévérité par défaut ou d'une classe de sévérité inexistante.

note: type: Plain text
en: B<addseverity>()  is provided in glibc since version 2.1.
fr: B<addseverity>() est fournie par la glibc depuis la version 2.1.

note: type: Plain text
en: This function is not specified in the X/Open Portability Guide although the B<fmtmsg>(3)  function is.  It is available on System V systems.
fr: Cette fonction n'est pas spécifiée dans le «\ X/Open Portability Guide\ » bien que la fonction B<fmtmsg>(3) le soit. Elle est disponible sur les systèmes System V.

note: type: Plain text
en: New severity classes can also be added by setting the environment variable B<SEV_LEVEL>.
fr: De nouvelles classes de sévérité peuvent également être ajoutées avec la variable d'environnement B<SEV_LEVEL>.

note: type: TH
en: 2007-05-18
fr: 18 mai 2007

note: type: Plain text
en: argz_add, argz_add_sep, argz_append, argz_count, argz_create, argz_create_sep, argz_delete, argz_extract, argz_insert, argz_next, argz_replace, argz_stringify - functions to handle an argz list
fr: argz_add, argz_add_sep, argz_append, argz_count, argz_create, argz_create_sep, argz_delete, argz_extract, argz_insert, argz_next, argz_replace, argz_stringify - Fonctions pour manipuler les vecteurs argz

note: type: Plain text
en: These functions are glibc-specific.
fr: Ces fonctions sont spécifiques à la glibc.

note: type: Plain text
en: An argz vector is a pointer to a character buffer together with a length.  The intended interpretation of the character buffer is an array of strings, where the strings are separated by null bytes (\(aq\e0\(aq).  If the length is nonzero, the last byte of the buffer must be a null byte.
fr: Un vecteur argz est un pointeur sur un tampon de caractères associé à une longueur. L'interprétation voulue pour le tampon de caractères est un tableau de chaînes où les chaînes sont séparées par des octets nuls (« \e0 »). Si la longueur est non nulle, le dernier octet du tampon doit être nul.

note: type: Plain text
en: These functions are for handling argz vectors.  The pair (NULL,0) is an argz vector, and, conversely, argz vectors of length 0 must have null pointer.  Allocation of nonempty argz vectors is done using B<malloc>(3), so that B<free>(3)  can be used to dispose of them again.
fr: Ces fonctions servent à manipuler les vecteurs argz. La paire (NULL, 0)  est un vecteur argz et réciproquement les vecteurs argz de longueur zéro doivent avoir un pointeur NULL. L'allocation de vecteurs argz non nuls est faite avec B<malloc>(3) afin que B<free>(3) puisse être utilisée pour les libérer.

note: type: Plain text
en: B<argz_add>()  adds the string I<str> at the end of the array I<*argz>, and updates I<*argz> and I<*argz_len>.
fr: B<argz_add>() ajoute la chaîne I<str> à la fin du tableau I<*argz> et met à jour I<*argz> et I<*argz_len>.

note: type: Plain text
en: B<argz_add_sep>()  is similar, but splits the string I<str> into substrings separated by the delimiter I<delim>.  For example, one might use this on a UNIX search path with delimiter \(aq:\(aq.
fr: B<argz_add_sep>() est similaire, mais découpe la chaîne I<str> en sous-chaînes séparées par le délimiteur I<delim>. Par exemple, on peut l'utiliser sur la liste de recherche des chemins UNIX avec le délimiteur «\ :\ ».

note: type: Plain text
en: B<argz_append>()  appends the argz vector (I<buf>,\ I<buf_len>)  after (I<*argz>,\ I<*argz_len>)  and updates I<*argz> and I<*argz_len>.  (Thus, I<*argz_len> will be increased by I<buf_len>.)
fr: B<argz_append>() ajoute le vecteur argz (I<buf>,\ I<buf_len>) après (I<*argz>,\ I<*argz_len>) et met à jour I<*argz> et I<*argz_len> (donc I<*argz_len> sera augmenté de I<buf_len>).

note: type: Plain text
en: B<argz_count>()  counts the number of strings, that is, the number of null bytes (\(aq\e0\(aq), in (I<argz>,\ I<argz_len>).
fr: B<argz_count>() compte le nombre de chaînes, c'est-à-dire le nombre d'octets nuls («\ \e0\ ») dans le vecteur (I<argz>,\ I<argz_len>).

note: type: Plain text
en: B<argz_create>()  converts a UNIX-style argument vector I<argv>, terminated by I<(char\ *)\ 0>, into an argz vector (I<*argz>,\ I<*argz_len>).
fr: B<argz_create>() convertit un vecteur de type UNIX I<argv> terminé par I<(char *) 0> en un vecteur argz (I<*argz>,\ I<*argz_len>).

note: type: Plain text
en: B<argz_create_sep>()  converts the null-terminated string I<str> into an argz vector (I<*argz>,\ I<*argz_len>)  by breaking it up at every occurrence of the separator I<sep>.
fr: B<argz_create_sep>() convertit la chaîne terminée par un caractère nul I<str> en un vecteur argz (I<*argz>,\ I<*argz_len>) en la découpant à chaque occurrence du séparateur I<sep>.

note: type: Plain text
en: B<argz_delete>()  removes the substring pointed to by I<entry> from the argz vector (I<*argz>,\ I<*argz_len>)  and updates I<*argz> and I<*argz_len>.
fr: B<argz_delete>() retire la sous-chaîne pointée par I<entry> du vecteur argz (I<*argz>,\ I<*argz_len>) et met à jour I<*argz> et I<*argz_len>.

note: type: Plain text
en: B<argz_extract>()  is the opposite of B<argz_create>().  It takes the argz vector (I<argz>,\ I<argz_len>)  and fills the array starting at I<argv> with pointers to the substrings, and a final NULL, making a UNIX-style argv vector.  The array I<argv> must have room for I<argz_count>(I<argz>, I<argz_len>) + 1 pointers.
fr: B<argz_extract>() est l'inverse de B<argz_create>(). Elle prend le vecteur argz (I<argz>,\ I<argz_len>) et remplit le tableau commençant à I<argv> avec des pointeurs sur les sous-chaînes et un NULL final en créant un vecteur de type UNIX argv. Le tableau I<argv> doit avoir assez de place pour I<argz_count>(I<argz>, I<argz_len>) + 1 pointeurs.

note: type: Plain text
en: B<argz_insert>()  is the opposite of B<argz_delete>().  It inserts the argument I<entry> at position I<before> into the argz vector (I<*argz>,\ I<*argz_len>)  and updates I<*argz> and I<*argz_len>.  If I<before> is NULL, then I<entry> will inserted at the end.
fr: B<argz_insert>() est l'opposée de B<argz_delete>(). Elle insère l'argument I<entry> à la position I<before> dans le vecteur argz (I<*argz>,\ I<*argz_len>) et met à jour I<*argz> et I<*argz_len>. Si I<before> est NULL, alors I<entry> est insérée à la fin.

note: type: Plain text
en: B<argz_next>()  is a function to step trough the argz vector.  If I<entry> is NULL, the first entry is returned.  Otherwise, the entry following is returned.  It returns NULL if there is no following entry.
fr: B<argz_next>() est une fonction pour se déplacer dans le vecteur argz. Si I<entry> est NULL, elle renvoie la première entrée. Sinon, l'entrée suivante est renvoyée. Elle renvoie NULL s'il n'y a pas d'entrée suivante.

note: type: Plain text
en: B<argz_replace>()  replaces each occurrence of I<str> with I<with>, reallocating argz as necessary.  If I<replace_count> is non-NULL, I<*replace_count> will be incremented by the number of replacements.
fr: B<argz_replace>() remplace chaque occurrence de I<str> avec I<with>, en réallouant argz si nécessaire. Si I<replace_count> est non NULL, I<*replace_count> sera incrémenté du nombre de remplacements.

note: type: Plain text
en: B<argz_stringify>()  is the opposite of B<argz_create_sep>().  It transforms the argz vector into a normal string by replacing all null bytes (\(aq\e0\(aq) except the last by I<sep>.
fr: B<argz_stringify>() est l'opposée de B<argz_create_sep>(). Elle transforme le vecteur argz en une chaîne normale en remplaçant tous les octets nuls (« \e0 ») sauf le dernier par I<sep>.

note: type: Plain text
en: All argz functions that do memory allocation have a return type of I<error_t>, and return 0 for success, and B<ENOMEM> if an allocation error occurs.
fr: Toutes les fonctions argz qui font de l'allocation mémoire ont un type de retour I<error_t>, et renvoient 0 si elles réussissent et B<ENOMEM> si l'allocation échoue.

note: type: Plain text
en: These functions are a GNU extension.  Handle with care.
fr: Ces fonctions sont des extensions GNU. Utilisez-les avec précaution.

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: Argz vectors without a terminating null byte may lead to Segmentation Faults.
fr: Les vecteurs argz sans caractère nul final conduisent à une erreur de segmentation.

note: type: Plain text
en: backtrace, backtrace_symbols, backtrace_symbols_fd - support for application self-debugging
fr: backtrace, backtrace_symbols, backtrace_symbols_fd - Outils d'auto-débogage d'applications

note: type: Plain text
en: B<backtrace>()  returns a backtrace for the calling program, in the array pointed to by I<buffer>.  A backtrace is the series of currently active function calls for the program.  Each item in the array pointed to by I<buffer> is of type I<void\ *>, and is the return address from the corresponding stack frame.  The I<size> argument specifies the maximum number of addresses that can be stored in I<buffer>.  If the backtrace is larger than I<size>, then the addresses corresponding to the I<size> most recent function calls are returned; to obtain the complete backtrace, make sure that I<buffer> and I<size> are large enough.
fr: B<backtrace>() renvoie une trace des appels du programme dans un tableau pointé par I<buffer>. Une trace est une série d'appels de fonction actuellement actif d'un programme. Chaque élément du tableau pointé par I<buffer> est de type I<void\ *>, et correspond à l'adresse de retour de la «\ stack frame\ » correspondante. Le paramètre I<size> spécifie le nombre maximum d'adresses qui peut être enregistré dans I<buffer>. Si la trace est plus grande que I<size>, alors les adresses correspondant aux I<size> plus récents appels de fonction sont retournées. Pour obtenir une trace complète, soyez sûre que I<buffer> et I<size> sont assez grand.

note: type: Plain text
en: Given the set of addresses returned by B<backtrace>()  in I<buffer>, B<backtrace_symbols>()  translates the addresses into an array of strings that describe the addresses symbolically.  The I<size> argument specifies the number of addresses in I<buffer>.  The symbolic representation of each address consists of the function name (if this can be determined), a hexadecimal offset into the function, and the actual return address (in hexadecimal).  The address of the array of string pointers is returned as the function result of B<backtrace_symbols>().  This array is B<malloc>(3)ed by B<backtrace_symbols>(), and must be freed by the caller.  (The strings pointed to by the array of pointers need not and should not be freed.)
fr: À partir des adresses renvoyées par B<backtrace>() dans le I<buffer>, B<backtrace_symbols>() traduit les adresses en un tableau de chaînes qui donne les symboles associés à ces adresses. Le paramètre I<size> indique le nombre d'adresses dans le I<buffer>. La représentation symbolique de chaque adresse consiste en un nom de fonction (s'il peut être déterminé), un décalage hexadécimal à l'intérieur de la fonction, et l'adresse (hexadécimale) de retour. L'adresse du tableau de chaînes est renvoyé comme résultat de la fonction B<backtrace_symbols>(). Ce tableau est alloué avec B<malloc>(3) par B<backtrace_symbols>() et doit être libéré par l'appelant. Les chaînes pointées par le tableau de pointeurs n'ont pas et ne devraient pas être libérées.

note: type: Plain text
en: B<backtrace_symbols_fd>()  takes the same I<buffer> and I<size> arguments as B<backtrace_symbols>(), but instead of returning an array of strings to the caller, it writes the strings, one per line, to the file descriptor I<fd>.  B<backtrace_symbols_fd>()  does not call B<malloc>(3), and so can be employed in situations where the latter function might fail.
fr: B<backtrace_symbols_fd>() prend les mêmes paramètres I<buffer> et I<size> que B<backtrace_symbols>() mais au lieu de renvoyer un tableau de chaînes à l'appelant, elle écrit les chaînes ligne par ligne dans le descripteur de fichier I<fd>. B<backtrace_symbols_fd>() n'appelle pas B<malloc>(3) et peut donc être utilisée dans des conditions où cette dernière fonction risque d'échouer.

note: type: Plain text
en: B<backtrace>()  returns the number of addresses returned in I<buffer>, which is not greater than I<size>.  If the return value is less than I<size>, then the full backtrace was stored; if it is equal to I<size>, then it may have been truncated, in which case the addresses of the oldest stack frames are not returned.
fr: B<backtrace>() fournit le nombre d'adresses renvoyées dans le I<buffer>, qui ne sera pas supérieur à I<size>. Si la valeur de retour est inférieure à I<size>, alors toute la trace a pu être sauvée\ ; si elle est égale à I<size>, alors il se peut qu'elle ait été tronquée et les adresses des trames les plus anciennes sur la pile ne sont pas renvoyées.

note: type: Plain text
en: On success, B<backtrace_symbols>()  returns a pointer to the array B<malloc>(3)ed by the call; on error, NULL is returned.
fr: En cas de succès, B<backtrace_symbols>() renvoie un pointeur vers le tableau alloué avec B<malloc>(3). En cas d'erreur NULL est renvoyé.

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

note: type: Plain text
en: These functions are GNU extensions.
fr: Ces fonctions sont des extensions GNU.

note: type: Plain text
en: These functions make some assumptions about how a function's return address is stored on the stack.  Note the following:
fr: Ces fonctions font des suppositions sur la façon dont l'adresse de retour d'une fonction est sauvegardée dans la pile. Prenez note des points suivants\ :

note: type: Plain text
en: Omission of the frame pointers (as implied by any of B<gcc>(1)'s nonzero optimization levels) may cause these assumptions to be violated.
fr: L'omission du pointeur de trame (comme le fait B<gcc>(1) avec les niveaux d'optimisation différents de zéro) peut être incompatible avec ces suppositions.

note: type: Plain text
en: Inlined functions do not have stack frames.
fr: Les fonctions en lignes («\ inline\ ») n'apparaissent pas sur la pile.

note: type: Plain text
en: Tail-call optimization causes one stack frame to replace another.
fr: Avec les optimisations de type Tail-call une trame sur la pile peut être remplacée par une autre.

note: type: Plain text
en: The symbol names may be unavailable without the use of special linker options.  For systems using the GNU linker, it is necessary to use the I<-rdynamic> linker option.  Note that names of "static" functions are not exposed, and won't be available in the backtrace.
fr: Le nom des symboles peut ne pas être disponible si certaines options de l'éditeur de liens n'ont pas été utilisées. Pour les systèmes qui utilisent l'éditeur de liens GNU, il faut utiliser l'option I<-rdynamic>. Notez que les noms des fonctions statiques (avec le mot clef «\ static\ ») ne sont pas exposés, et ne seront pas disponibles pour la trace.

note: type: Plain text
en: The program below demonstrates the use of B<backtrace>()  and B<backtrace_symbols>().  The following shell session shows what we might see when running the program:
fr: Le programme ci-dessous explique l'utilisation de B<backtrace>() et B<backtrace_symbols>(). Les sessions d'interpréteur de commandes montrent ce que produira l'exécution du programme\ :

note: type: SS
en: Program source
fr: Source du programme

note: type: TH
en: 2009-03-30
fr: 30 mars 2009

note: type: Plain text
en: basename, dirname - parse pathname components
fr: basename, dirname - Analyse des composants d'un chemin d'accès

note: type: Plain text
en: Warning: there are two different functions B<basename>()  - see below.
fr: Attention\ : il y a deux fonctions B<basename> différentes;\ consultez ci-dessous.

note: type: Plain text
en: The functions B<dirname>()  and B<basename>()  break a null-terminated pathname string into directory and filename components.  In the usual case, B<dirname>()  returns the string up to, but not including, the final \(aq/\(aq, and B<basename>()  returns the component following the final \(aq/\(aq.  Trailing \(aq/\(aq characters are not counted as part of the pathname.
fr: Les fonctions B<basename>() et B<dirname>() décomposent une chaîne terminée par un caractère nul, représentant un chemin d'accès en ses composants répertoire et nom de fichier. En général, B<dirname>() renvoie la chaîne s'étendant jusqu'au dernier «\ /\ », sans l'inclure, et B<basename>() renvoie la partie se trouvant après le dernier «\ /\ ». Les caractères «\ /\ » en fin de chaîne ne font pas partie du chemin.

note: type: Plain text
en: If I<path> does not contain a slash, B<dirname>()  returns the string "." while B<basename>()  returns a copy of I<path>.  If I<path> is the string "/", then both B<dirname>()  and B<basename>()  return the string "/".  If I<path> is a null pointer or points to an empty string, then both B<dirname>()  and B<basename>()  return the string ".".
fr: Si I<path> ne contient pas de barre oblique, B<dirname>() renvoie la chaîne «\ .\ » et B<basename>() renvoie une copie de la chaîne I<path>. Si I<path> est représenté par la chaîne «\ /\ », alors B<dirname>() et B<basename>() renvoient tout deux la chaîne «\ /\ ». Si I<path> est un pointeur NULL, ou pointe vers une chaîne vide, alors B<dirname>() et B<basename>() renvoient tout deux la chaîne «\ .\ ».

note: type: Plain text
en: Concatenating the string returned by B<dirname>(), a "/", and the string returned by B<basename>()  yields a complete pathname.
fr: En mettant bout à bout la chaîne renvoyée par B<dirname>(), un «\ /\ », et la chaîne renvoyée par B<basename>(), on obtient un chemin d'accès complet.

note: type: Plain text
en: Both B<dirname>()  and B<basename>()  may modify the contents of I<path>, so it may be desirable to pass a copy when calling one of these functions.
fr: B<dirname>() et B<basename>() peuvent tous deux modifier le contenu de I<path>, il est donc préférable de passer une copie de celui-ci lors d'un appel à l'une de ces fonctions.

note: type: Plain text
en: These functions may return pointers to statically allocated memory which may be overwritten by subsequent calls.  Alternatively, they may return a pointer to some part of I<path>, so that the string referred to by I<path> should not be modified or freed until the pointer returned by the function is no longer required.
fr: Ces fonctions devraient renvoyer des pointeurs vers de la mémoire allouée statiquement qui peut être réécrite par des appels ultérieurs. Cependant, il pourraient renvoyer un pointeur vers une partie de I<path>, ainsi la chaîne référencée par I<path> ne doit pas être modifiée ou libérée tant que le pointeur renvoyé par la fonction ne possède pas la bonne longueur.

note: type: Plain text
en: The following list of examples (taken from SUSv2)  shows the strings returned by B<dirname>()  and B<basename>()  for different paths:
fr: La liste suivante d'exemple (prise dans SUSv2) montre les chaînes renvoyées par B<dirname>() et B<basename>() pour différents chemins d'accès\ :

note: type: tbl table
en: path    	dirname	basename
fr: chemin  	dirname	basename

note: type: Plain text
en: Both B<dirname>()  and B<basename>()  return pointers to null-terminated strings.  (Do not pass these pointers to B<free>(3).)
fr: Les fonctions B<dirname>() et B<basename>() renvoient des pointeurs sur des chaînes terminées par un caractère nul. (Ne pas passer ces pointeurs à B<free>(3).)

note: type: Plain text
en: There are two different versions of B<basename>()  - the POSIX version described above, and the GNU version, which one gets after
fr: Il y a deux versions différentes de B<basename>()\ ; la version POSIX décrite précédemment, et la version GNU que l'on utilise avec

note: type: Plain text
en: B<    #define _GNU_SOURCE>         /* See feature_test_macros(7) */
fr: B<    #define _GNU_SOURCE>         /* Consultez feature_test_macros(7) */

note: type: Plain text
en: The GNU version never modifies its argument, and returns the empty string when I<path> has a trailing slash, and in particular also when it is "/".  There is no GNU version of B<dirname>().
fr: La version GNU ne modifie jamais son argument et renvoie une chaîne vide lorsque I<path> finit par une barre oblique «\ /\ » et en particulier aussi lorsqu'il vaut «\ /\ ». Il n'y a pas de version GNU de B<dirname>().

note: type: Plain text
en: With glibc, one gets the POSIX version of B<basename>()  when I<E<lt>libgen.hE<gt>> is included, and the GNU version otherwise.
fr: Avec la glibc, on utilise la version POSIX de B<basename>() lorsque I<E<lt>libgen.hE<gt>> est inclus, et la version GNU sinon.

note: type: Plain text
en: In the glibc implementation of the POSIX versions of these functions they modify their argument, and segfault when called with a static string like "/usr/".  Before glibc 2.2.1, the glibc version of B<dirname>()  did not correctly handle pathnames with trailing \(aq/\(aq characters, and generated a segfault if given a NULL argument.
fr: Dans l'implémentation de la glibc des versions POSIX de ces fonctions, celles-ci modifient leur argument et provoquent une erreur de segmentation lorsqu'elles sont invoquées avec une chaîne statique comme «\ /usr/\ ». Avant la glibc\ 2.2.1, la fonction B<dirname>() ne géraient pas correctement les chemins se terminant par un caractère «\ /\ » et déclenchaient une erreur de segmentation en recevant un pointeur NULL.

note: type: Plain text
en: envz_add, envz_entry, envz_get, envz_merge, envz_remove, envz_strip - environment string support
fr: envz_add, envz_entry, envz_get, envz_merge, envz_remove, envz_strip - Gestion des chaînes d'environnement

note: type: Plain text
en: An argz vector is a pointer to a character buffer together with a length, see B<argz_add>(3).  An envz vector is a special argz vector, namely one where the strings have the form "name=value".  Everything after the first \(aq=\(aq is considered to be the value.  If there is no \(aq=\(aq, the value is taken to be NULL.  (While the value in case of a trailing \(aq=\(aq is the empty string "".)
fr: Un vecteur argz est un pointeur sur un tampon de caractère associé à une longueur, consultez B<argz_add>(3). Un vecteur envz est un vecteur argz spécial, plus précisément un dont les chaînes ont la forme «\ nom=valeur\ ». Tout ce qui suit le «\ =\ » est considéré comme la valeur. S'il n'y a pas de «\ =\ », la valeur correspondante est NULL (tandis qu'un «\ =\ » en dernière position indique une chaîne vide "").

note: type: Plain text
en: These functions are for handling envz vectors.
fr: Ces fonctions permettent la manipulation des vecteurs envz.

note: type: Plain text
en: B<envz_add>()  adds the string "I<name>=I<value>" (in case I<value> is non-NULL) or "I<name>" (in case I<value> is NULL) to the envz vector (I<*envz>,\ I<*envz_len>)  and updates I<*envz> and I<*envz_len>.  If an entry with the same I<name> existed, it is removed.
fr: B<envz_add>() ajoute la chaîne «\ I<name>=I<value>\ » (si I<value> n'est pas NULL) ou «\ I<name>\ » (si I<value> est NULL) au vecteur envz (I<*envz>,\ I<*envz_len>) et met à jour I<*envz> et I<*envz_len>. Si une entrée avec le même I<name> existe, elle est supprimée.

note: type: Plain text
en: B<envz_entry>()  looks for I<name> in the envz vector (I<envz>,\ I<envz_len>)  and returns the entry if found, or NULL if not.
fr: B<envz_entry>() recherche I<name> dans le vecteur envz (I<envz>,\ I<envz_len>) et renvoie son entrée si elle est trouvée, ou NULL sinon.

note: type: Plain text
en: B<envz_get>()  looks for I<name> in the envz vector (I<envz>,\ I<envz_len>)  and returns the value if found, or NULL if not.  (Note that the value can also be NULL, namely when there is an entry for I<name> without \(aq=\(aq sign.)
fr: B<envz_get>() recherche le I<name> dans le vecteur envz (I<envz>,\ I<envz_len>) et renvoie sa valeur si elle est trouvée, et NULL sinon. (Notez que la valeur peut aussi être NULL, lorsqu'il y a une entrée pour I<name> sans le signe «\ =\ »).

note: type: Plain text
en: B<envz_merge>()  adds each entry in I<envz2> to I<*envz>, as if with B<envz_add>().  If I<override> is true, then values in I<envz2> will supersede those with the same name in I<*envz>, otherwise not.
fr: B<envz_merge>() ajoute les entrées de I<envz2> dans I<*envz>, comme avec B<envz_add>(). Si I<override> est vrai, alors les valeurs de I<envz2> écraseront celles avec le même nom dans I<*envz>, sinon elles seront ignorées.

note: type: Plain text
en: B<envz_remove>()  removes the entry for I<name> from (I<*envz>,\ I<*envz_len>)  if there was one.
fr: B<envz_remove>() supprime l'entrée correspondant à I<name> du vecteur (I<*envz>,\ I<*envz_len>) si elle s'y trouve.

note: type: Plain text
en: B<envz_strip>()  removes all entries with value NULL.
fr: B<envz_strip> supprime toutes les entrées avec une valeur NULL.

note: type: Plain text
en: All envz functions that do memory allocation have a return type of I<error_t>, and return 0 for success, and B<ENOMEM> if an allocation error occurs.
fr: Toutes les fonctions envz qui font une allocation mémoire ont un type de retour I<error_t>, et renvoient 0 en cas de succès et B<ENOMEM> si une erreur d'allocation se produit.

note: type: TH
en: 2013-10-07
fr: 7 octobre 2013

note: type: Plain text
en: ftok - convert a pathname and a project identifier to a System V IPC key
fr: ftok - Convertir un nom de fichier et un identificateur de projet en clé IPC System V

note: type: Plain text
en: The B<ftok>()  function uses the identity of the file named by the given I<pathname> (which must refer to an existing, accessible file)  and the least significant 8 bits of I<proj_id> (which must be nonzero) to generate a I<key_t> type System V IPC key, suitable for use with B<msgget>(2), B<semget>(2), or B<shmget>(2).
fr: La fonction B<ftok>() utilise l'identité du fichier indiqué par I<pathname> (qui doit exister et être accessible), et les huit bits de poids faible de I<proj_id> (qui doit être non nul) pour créer une clé IPC System V de type I<key_t>, utilisable avec B<msgget>(2), B<semget>(2) ou B<shmget>(2).

note: type: Plain text
en: The resulting value is the same for all pathnames that name the same file, when the same value of I<proj_id> is used.  The value returned should be different when the (simultaneously existing) files or the project IDs differ.
fr: La valeur résultante est la même pour tous les chemins d'accès identifiant le même fichier, en utilisant une valeur identique pour I<proj_id>. La valeur devrait être différente lorsque des fichiers différents (existants simultanément), ou des identificateurs de projet différents sont employés.

note: type: Plain text
en: On success, the generated I<key_t> value is returned.  On failure -1 is returned, with I<errno> indicating the error as for the B<stat>(2)  system call.
fr: En cas de succès, la clé générée I<key_t> est renvoyée. Sinon elle renvoie -1, et I<errno> indique l'erreur de la même façon que l'appel système B<stat>(2).

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<ftok>()  function is thread-safe.
fr: La fonction B<ftok>() est sûre dans un contexte multithread.

note: type: Plain text
en: Under libc4 and libc5 (and under SunOS 4.x) the prototype was:
fr: Avec les bibliothèques libc4 et libc5 (et également sous SunOS\ 4.x), le prototype était

note: type: Plain text
en: Today I<proj_id> is an I<int>, but still only 8 bits are used.  Typical usage has an ASCII character I<proj_id>, that is why the behavior is said to be undefined when I<proj_id> is zero.
fr: De nos jours I<proj_id> est un I<int>, mais seuls huit bits sont utilisés. L'habitude veut que l'on utilise un caractère ASCII comme identifiant de I<proj_id>, ce qui explique pourquoi le comportement est indéfini lorsque I<proj_id> vaut zéro.

note: type: Plain text
en: Of course no guarantee can be given that the resulting I<key_t> is unique.  Typically, a best effort attempt combines the given I<proj_id> byte, the lower 16 bits of the inode number, and the lower 8 bits of the device number into a 32-bit result.  Collisions may easily happen, for example between files on I</dev/hda1> and files on I</dev/sda1>.
fr: Naturellement, aucune garantie ne peut être donné sur le fait que la clé I<key_t> résultante soit unique. En général, la meilleure méthode est de combiner l'octet de I<proj_id>, les seize bits de poids faibles du numéro d'inode, et les huit bits de poids faibles du numéro de périphérique pour obtenir un entier sur 32\ bits. Des collisions peuvent se produire facilement, par exemple entre les fichiers se trouvant sur I</dev/hda1> et ceux sur I</dev/sda1>.

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

note: type: Plain text
en: longjmp, siglongjmp - nonlocal jump to a saved stack context
fr: longjmp, siglongjmp - Saut non local vers un contexte de pile sauvegardé

note: type: Plain text
en: B<siglongjmp>(): _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_C_SOURCE
fr: B<siglongjmp>()\ : _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_C_SOURCE

note: type: Plain text
en: B<longjmp>()  and B<setjmp>(3)  are useful for dealing with errors and interrupts encountered in a low-level subroutine of a program.  B<longjmp>()  restores the environment saved by the last call of B<setjmp>(3)  with the corresponding I<env> argument.  After B<longjmp>()  is completed, program execution continues as if the corresponding call of B<setjmp>(3)  had just returned the value I<val>.  B<longjmp>()  cannot cause 0 to be returned.  If B<longjmp>()  is invoked with a second argument of 0, 1 will be returned instead.
fr: B<longjmp>() et B<setjmp>(3) sont utiles pour la gestion d'erreurs et d'interruptions rencontrées dans une routine bas-niveau d'un programme. B<longjmp>() restitue l'environnement sauvegardé lors du dernier appel de B<setjmp>(3) avec l'argument I<env> correspondant. Après l'appel B<longjmp>(), l'exécution du programme continue comme si l'appel correspondant de B<setjmp>(3) venait juste de renvoyer I<val>. B<longjmp>() ne peut pas renvoyer 0. Si B<longjmp> est appelé avec 0 en tant que second argument, B<setjmp>(3) renverra 1 à la place.

note: type: Plain text
en: B<siglongjmp>()  is similar to B<longjmp>()  except for the type of its I<env> argument.  If, and only if, the B<sigsetjmp>(3)  call that set this I<env> used a nonzero I<savesigs> flag, B<siglongjmp>()  also restores the signal mask that was saved by B<sigsetjmp>(3).
fr: B<siglongjmp>() est identique à B<longjmp>() excepté pour le type de son argument I<env>. Si et seulement si l'appel B<sigsetjmp>(3) définit cet I<env>, utilisé comme drapeau I<savesigs> non nul, alors B<siglongjmp>() restituera également le signal masqué qui a été sauvé par B<sigsetjmp>(3).

note: type: Plain text
en: These functions never return.
fr: Ces fonctions ne reviennent jamais.

note: type: Plain text
en: C89, C99, and POSIX.1-2001 specify B<longjmp>().  POSIX.1-2001 specifies B<siglongjmp>().
fr: C89, C99 et POSIX.1-2001 spécifient B<longjmp>(). POSIX.1-2001 spécifie B<siglongjmp>().

note: type: Plain text
en: POSIX does not specify whether B<longjmp>()  will restore the signal context (see B<setjmp>(3)  for some more details).  If you want to portably save and restore signal masks, use B<sigsetjmp>(3)  and B<siglongjmp>().
fr: POSIX ne précise pas si B<longjmp>() restaurera le contexte du signal (consultez B<setjmp>(3) pour plus de détails). Si vous voulez sauver et restaurer le masque de signaux de façon portable, utilisez B<sigsetjmp>(3) et B<siglongjmp>().

note: type: Plain text
en: The values of automatic variables are unspecified after a call to B<longjmp>()  if they meet all the following criteria:
fr: Les valeurs des variables automatiques ne sont pas spécifiées après un appel à B<longjmp>() si elles suivent tous les critères suivants\ :

note: type: Plain text
en: they are local to the function that made the corresponding B<setjmp>(3)  call;
fr: elles sont locales à la fonction qui effectue l'appel correspondant B<setjmp>(3)\ ;

note: type: Plain text
en: their values are changed between the calls to B<setjmp>(3)  and B<longjmp>(); and
fr: leur valeur est changée entre les appels B<setjmp>(3) et B<longjmp>()\ ;

note: type: Plain text
en: they are not declared as I<volatile>.
fr: elles ne sont pas déclarées comme I<volatile>.

note: type: Plain text
en: Analogous remarks apply for B<siglongjmp>().
fr: Ces remarques s'appliquent aussi à B<siglongjmp>().

note: type: Plain text
en: B<longjmp>()  and B<siglongjmp>()  make programs hard to understand and maintain.  If possible, an alternative should be used.
fr: B<longjmp>() et B<siglongjmp>() rendent les programmes difficiles à comprendre et à maintenir. Il est préférable si possible d'utiliser une autre méthode.

note: type: TH
en: 2014-04-06
fr: 6 avril 2014

note: type: Plain text
en: offsetof - offset of a structure member
fr: offsetof - Décalage d'un membre d'une structure

note: type: Plain text
en: B<size_t offsetof(>I<type>B<, >I<member>B<);>
fr: B<size_t offsetof(>I<type>B<, >I<membre>B<);>

note: type: Plain text
en: The macro B<offsetof>()  returns the offset of the field I<member> from the start of the structure I<type>.
fr: La macro B<offsetof>() renvoie le décalage du champ I<membre> à partir du début de la structure I<type>.

note: type: Plain text
en: This macro is useful because the sizes of the fields that compose a structure can vary across implementations, and compilers may insert different numbers of padding bytes between fields.  Consequently, an element's offset is not necessarily given by the sum of the sizes of the previous elements.
fr: Cette macro est utile car la taille des champs qui composent une structure peut varier d'une implémentation à l'autre. De plus, les compilateurs peuvent insèrer des octets entre les champs pour des questions d'alignement, le nombre de ces octets dépendant de chaque compilateur. Ainsi, le décalage d'un élément n'est pas forcément égal à la somme des tailles des membres qui le précèdent.

note: type: Plain text
en: A compiler error will result if I<member> is not aligned to a byte boundary (i.e., it is a bit field).
fr: Une erreur de compilateur sera signalée si I<membre> n'est pas aligné avec une frontière d'octet (c'est-à-dire qu'il s'agit d'un champ de bits).

note: type: Plain text
en: B<offsetof>()  returns the offset of the given I<member> within the given I<type>, in units of bytes.
fr: B<offsetof>() renvoie le décalage (en octets) du I<membre> spécifié à l'intérieur de la structure I<type>.

note: type: Plain text
en: On a Linux/i386 system, when compiled using the default B<gcc>(1)  options, the program below produces the following output:
fr: Sur un système Linux/i386, le programme ci-dessous, compilé avec les options par défaut de B<gcc>(1), affichera le résultat suivant\ :

note: type: Plain text
en: $B< ./a.out>
    offsets: i=0; c=4; d=8 a=16
    sizeof(struct s)=16
fr: $B< ./a.out>
    décalages: i=0 c=4 d=8 a=16
    sizeof(struct s)=16

note: type: Plain text
en:     /* Output is compiler dependent */
fr:     /* La sortie dépend du compilateur */

note: type: Plain text
en:     printf("offsets: i=%zd; c=%zd; d=%zd a=%zd\en",
                offsetof(struct s, i), offsetof(struct s, c),
                offsetof(struct s, d), offsetof(struct s, a));
        printf("sizeof(struct s)=%zd\en", sizeof(struct s));
fr:     printf("décalages: i=%zd c=%zd d=%zd a=%zd\en",
                offsetof(struct s, i), offsetof(struct s, c),
                offsetof(struct s, d), offsetof(struct s, a));
        printf("sizeof(struct s)=%zd\en", sizeof(struct s));

note: type: TH
en: 2006-04-29
fr: 29 avril 2006

note: type: Plain text
en: program_invocation_name, program_invocation_short_name - obtain name used to invoke calling program
fr: program_invocation_name, program_invocation_short_name - Obtenir le nom utilisé pour invoquer le programme appelant

note: type: Plain text
en: B<#define _GNU_SOURCE>         /* See feature_test_macros(7) */
    B<#include E<lt>errno.hE<gt>>
fr: B<#define _GNU_SOURCE>         /* Consultez feature_test_macros(7) */
    B<#include E<lt>errno.hE<gt>>

note: type: Plain text
en: I<program_invocation_name> contains the name that was used to invoke the calling program.  This is the same as the value of I<argv[0]> in I<main>(), with the difference that the scope of I<program_invocation_name> is global.
fr: I<program_invocation_name> contient le nom qui a été utilisé pour invoquer le programme appelant. C'est le même que la valeur de I<argv[0]> dans I<main>(), à la différence que la portée de I<program_invocation_name> est globale.

note: type: Plain text
en: I<program_invocation_short_name> contains the basename component of name that was used to invoke the calling program.  That is, it is the same value as I<program_invocation_name>, with all text up to and including the final slash (/), if any, removed.
fr: I<program_invocation_short_name> contient la partie nom de base du nom utilisé pour invoquer le programme appelant. Ainsi, c'est la même valeur que I<program_invocation_name>, amputée de tout le texte jusqu'à la dernière barre oblique (/).

note: type: Plain text
en: These variables are automatically initialized by the glibc run-time startup code.
fr: Ces variables sont automatiquement initialisées par le code exécuté au démarrage de la glibc.

note: type: Plain text
en: These variables are GNU extensions, and should not be used in programs intended to be portable.
fr: Ces variables sont des extensions GNU et ne devraient pas être utilisées dans des programmes destinés à être portables.

note: type: Plain text
en: The Linux-specific I</proc/[number]/cmdline> file provides access to similar information.
fr: Le fichier I</proc/[nombre]/cmdline>, spécifique à Linux, fournit un accès à une information similaire.

note: type: TH
en: 2007-12-28
fr: 28 décembre 2007

note: type: Plain text
en: LIST_ENTRY, LIST_HEAD, LIST_INIT, LIST_INSERT_AFTER, LIST_INSERT_HEAD, LIST_REMOVE, TAILQ_ENTRY, TAILQ_HEAD, TAILQ_INIT, TAILQ_INSERT_AFTER, TAILQ_INSERT_HEAD, TAILQ_INSERT_TAIL, TAILQ_REMOVE, CIRCLEQ_ENTRY, CIRCLEQ_HEAD, CIRCLEQ_INIT, CIRCLEQ_INSERT_AFTER, CIRCLEQ_INSERT_BEFORE, CIRCLEQ_INSERT_HEAD, CIRCLEQ_INSERT_TAIL, CIRCLEQ_REMOVE - implementations of lists, tail queues, and circular queues
fr: LIST_ENTRY, LIST_HEAD, LIST_INIT, LIST_INSERT_AFTER, LIST_INSERT_HEAD, LIST_REMOVE, TAILQ_ENTRY, TAILQ_HEAD, TAILQ_INIT, TAILQ_INSERT_AFTER, TAILQ_INSERT_HEAD, TAILQ_INSERT_TAIL, TAILQ_REMOVE, CIRCLEQ_ENTRY, CIRCLEQ_HEAD, CIRCLEQ_INIT, CIRCLEQ_INSERT_AFTER, CIRCLEQ_INSERT_BEFORE, CIRCLEQ_INSERT_HEAD, CIRCLEQ_INSERT_TAIL, CIRCLEQ_REMOVE - Implementations des listes, listes doubles et circulaires

note: type: Plain text
en: These macros define and operate on three types of data structures: lists, tail queues, and circular queues.  All three structures support the following functionality:
fr: Ces macros définissent et manipulent trois types de structures de données\ : les listes simples, les listes doubles et les listes circulaires. Ces trois structures supportent les fonctionnalités suivantes\ :

note: type: Plain text
en: Insertion of a new entry at the head of the list.
fr: Insertion d'un élément en tête de liste\ ;

note: type: Plain text
en: Insertion of a new entry after any element in the list.
fr: Insertion d'un élément après n'importe quel élément existant\ ;

note: type: Plain text
en: Removal of any entry in the list.
fr: Suppression de n'importe quel élément\ ;

note: type: Plain text
en: Forward traversal through the list.
fr: Traversée séquentielle de la liste.

note: type: Plain text
en: Lists are the simplest of the three data structures and support only the above functionality.
fr: Les listes sont les plus simples de ces trois structures de données et ne supportent que les fonctionnalités ci-dessus.

note: type: Plain text
en: Tail queues add the following functionality:
fr: Les listes doubles ajoutent la fonctionnalité suivante\ :

note: type: Plain text
en: Entries can be added at the end of a list.
fr: Un élément peut être ajouté en fin de liste.

note: type: Plain text
en: However:
fr: Cependant\ :

note: type: Plain text
en: All list insertions and removals must specify the head of the list.
fr: Toutes les insertions et suppressions doivent mentionner la tête de la liste\ ;

note: type: Plain text
en: Each head entry requires two pointers rather than one.
fr: L'élément de tête nécessite deux pointeurs au lieu d'un seul\ ;

note: type: Plain text
en: Code size is about 15% greater and operations run about 20% slower than lists.
fr: La taille du code est environ 15% plus grande, et l'exécution environ 20% plus lente que les listes.

note: type: Plain text
en: Circular queues add the following functionality:
fr: Les listes circulaires ajoutent les fonctionnalités suivantes\ :

note: type: Plain text
en: Entries can be added before another entry.
fr: Des entrées peuvent être ajoutées avant chaque entrée\ ;

note: type: Plain text
en: They may be traversed backward, from tail to head.
fr: Elles peuvent être traversées à l'envers, de la queue à la tête\ ;

note: type: Plain text
en: The termination condition for traversal is more complex.
fr: La condition de terminaison pour la traversée est plus compliquée\ ;

note: type: Plain text
en: Code size is about 40% greater and operations run about 45% slower than lists.
fr: La taille du code est environ 40% plus grande, et l'exécution environ 45% plus lente que les listes.

note: type: Plain text
en: In the macro definitions, I<TYPE> is the name of a user-defined structure, that must contain a field of type B<LIST_ENTRY>, B<TAILQ_ENTRY>, or B<CIRCLEQ_ENTRY>, named I<NAME>.  The argument I<HEADNAME> is the name of a user-defined structure that must be declared using the macros B<LIST_HEAD>, B<TAILQ_HEAD>, or B<CIRCLEQ_HEAD>.  See the examples below for further explanation of how these macros are used.
fr: Dans les définitions de macros, I<TYPE> est le nom d'une structure définie par l'utilisateur, qui doit contenir un champ de type B<LIST_ENTRY>, B<TAILQ_ENTRY> ou B<CIRCLEQ_ENTRY>, appelé I<NAME>. L'argument I<HEADNAME> est le nom d'une structure définie par l'utilisateur qui doit être déclarée en utilisant les macros B<LIST_HEAD>, B<TAILQ_HEAD> ou B<CIRCLEQ_HEAD>. Consultez les exemples plus bas pour une explication sur l'utilisation de ces macros.

note: type: SS
en: Lists
fr: Listes

note: type: Plain text
en: A list is headed by a structure defined by the B<LIST_HEAD> macro.  This structure contains a single pointer to the first element on the list.  The elements are doubly linked so that an arbitrary element can be removed without traversing the list.  New elements can be added to the list after an existing element or at the head of the list.  A B<LIST_HEAD> structure is declared as follows:
fr: Une liste débute par une structure définie par la macro B<LIST_HEAD>. Cette structure contient un pointeur simple sur le premier élément de la liste. Les éléments sont doublement chaînés afin qu'un élément puisse être supprimé sans parcourir toute la liste. Des éléments peuvent être ajoutés après un élément existant ou en tête de liste. Une structure B<LIST_HEAD> est déclarée ainsi\ :

note: type: Plain text
en: where I<HEADNAME> is the name of the structure to be defined, and I<TYPE> is the type of the elements to be linked into the list.  A pointer to the head of the list can later be declared as:
fr: où I<HEADNAME> est le nom de la structure à définir, et I<TYPE> le type d'élément à lier dans la liste. Un pointeur sur la tête de la liste peut ensuite être déclaré ainsi\ :

note: type: Plain text
en: (The names I<head> and I<headp> are user selectable.)
fr: (les noms I<head> et I<headp> sont choisis par l'utilisateur)

note: type: Plain text
en: The macro B<LIST_ENTRY> declares a structure that connects the elements in the list.
fr: La macro B<LIST_ENTRY> déclare une structure qui connecte les éléments dans la liste.

note: type: Plain text
en: The macro B<LIST_INIT> initializes the list referenced by I<head>.
fr: La macro B<LIST_INIT> initialise la liste référencée par I<head>.

note: type: Plain text
en: The macro B<LIST_INSERT_HEAD> inserts the new element I<elm> at the head of the list.
fr: La macro B<LIST_INSERT_HEAD> insère le nouvel élément I<elm> à la tête de la liste.

note: type: Plain text
en: The macro B<LIST_INSERT_AFTER> inserts the new element I<elm> after the element I<listelm>.
fr: La macro B<LIST_INSERT_AFTER> insère le nouvel élément I<elm> après l'élément I<listelm>.

note: type: Plain text
en: The macro B<LIST_REMOVE> removes the element I<elm> from the list.
fr: La macro B<LIST_REMOVE> supprime l'élément I<elm> de la liste.

note: type: SS
en: List example
fr: Exemple de liste

note: type: Plain text
en: LIST_HEAD(listhead, entry) head;
    struct listhead *headp;                 /* List head. */
    struct entry {
        ...
        LIST_ENTRY(entry) entries;          /* List. */
        ...
    } *n1, *n2, *np;
fr: LIST_HEAD(listhead, entry) head;
    struct listhead *headp;                 /* Tête de la liste */
    struct entry {
        ...
        LIST_ENTRY(entry) entries;          /* Liste */
        ...
    } *n1, *n2, *np;

note: type: Plain text
en: LIST_INIT(&head);                       /* Initialize the list. */
fr: LIST_INIT(&head);                       /* Initialisation de liste */

note: type: Plain text
en: n1 = malloc(sizeof(struct entry));      /* Insert at the head. */
    LIST_INSERT_HEAD(&head, n1, entries);
fr: n1 = malloc(sizeof(struct entry));      /* Insertion en tête */
    LIST_INSERT_HEAD(&head, n1, entries);

note: type: Plain text
en: n2 = malloc(sizeof(struct entry));      /* Insert after. */
    LIST_INSERT_AFTER(n1, n2, entries);
                                            /* Forward traversal. */
    for (np = head.lh_first; np != NULL; np = np-E<gt>entries.le_next)
        np-E<gt> ...
fr: n2 = malloc(sizeof(struct entry));      /* Insertion après */
    LIST_INSERT_AFTER(n1, n2, entries);
                                            /* Parcours en avant */
    for (np = head.lh_first; np != NULL; np = np-E<gt>entries.le_next)
        np-E<gt> ...

note: FIXME http://sourceware.org/bugzilla/show_bug.cgi?id=1506 type: Plain text
en: while (head.lh_first != NULL)           /* Delete. */
        LIST_REMOVE(head.lh_first, entries);
fr: while (head.lh_first != NULL)           /* Suppression */
        LIST_REMOVE(head.lh_first, entries);

note: type: SS
en: Tail queues
fr: Listes doubles

note: type: Plain text
en: A tail queue is headed by a structure defined by the B<TAILQ_HEAD> macro.  This structure contains a pair of pointers, one to the first element in the tail queue and the other to the last element in the tail queue.  The elements are doubly linked so that an arbitrary element can be removed without traversing the tail queue.  New elements can be added to the tail queue after an existing element, at the head of the tail queue, or at the end of the tail queue.  A B<TAILQ_HEAD> structure is declared as follows:
fr: La tête d'une liste double est désignée par une structure définie par la macro B<TAILQ_HEAD>. Cette structure contient deux pointeurs, l'un sur le premier élément et l'autre sur le dernier élément. Les éléments sont doublement chaînés, ainsi un élément quelconque peut être supprimé sans reparcourir toute la liste. Les nouveaux éléments peuvent être ajoutés après un élément existant, en tête ou en queue de liste. Une structure B<TAILQ_HEAD> est déclarée ainsi\ :

note: type: Plain text
en: where I<HEADNAME> is the name of the structure to be defined, and I<TYPE> is the type of the elements to be linked into the tail queue.  A pointer to the head of the tail queue can later be declared as:
fr: où I<HEADNAME> est le nom de la structure à définir, et I<TYPE> représente le type des éléments à lier dans la liste. Un pointeur sur la tête de la liste peut être déclaré ainsi\ :

note: type: Plain text
en: The macro B<TAILQ_ENTRY> declares a structure that connects the elements in the tail queue.
fr: La macro B<TAILQ_ENTRY> déclare une structure qui connecte les éléments dans la liste double.

note: type: Plain text
en: The macro B<TAILQ_INIT> initializes the tail queue referenced by I<head>.
fr: La macro B<TAILQ_INIT> initialise la liste double référencée par I<head>.

note: type: Plain text
en: The macro B<TAILQ_INSERT_HEAD> inserts the new element I<elm> at the head of the tail queue.
fr: La macro B<TAILQ_INSERT_HEAD> insère le nouvel élément I<elm> à la fin de la liste double.

note: type: Plain text
en: The macro B<TAILQ_INSERT_TAIL> inserts the new element I<elm> at the end of the tail queue.
fr: La macro B<TAILQ_INSERT_TAIL> insère le nouvel élément I<elm> à la fin de la liste double.

note: type: Plain text
en: The macro B<TAILQ_INSERT_AFTER> inserts the new element I<elm> after the element I<listelm>.
fr: La macro B<TAILQ_INSERT_AFTER> insère le nouvel élément I<elm> après l'élément I<listelm>.

note: type: Plain text
en: The macro B<TAILQ_REMOVE> removes the element I<elm> from the tail queue.
fr: La macro B<TAILQ_REMOVE> supprime l'élément I<elm> de la liste double.

note: type: SS
en: Tail queue example
fr: Exemple de liste double

note: type: Plain text
en: TAILQ_HEAD(tailhead, entry) head;
    struct tailhead *headp;                 /* Tail queue head. */
    struct entry {
        ...
        TAILQ_ENTRY(entry) entries;         /* Tail queue. */
        ...
    } *n1, *n2, *np;
fr: TAILQ_HEAD(tailhead, entry) head;
    struct tailhead *headp;                 /* Tête de liste double */
    struct entry {
        ...
        TAILQ_ENTRY(entry) entries;         /* Liste double */
        ...
    } *n1, *n2, *np;

note: type: Plain text
en: TAILQ_INIT(&head);                      /* Initialize the queue. */
fr: TAILQ_INIT(&head);                      /* Initialisation de liste */

note: type: Plain text
en: n1 = malloc(sizeof(struct entry));      /* Insert at the head. */
    TAILQ_INSERT_HEAD(&head, n1, entries);
fr: n1 = malloc(sizeof(struct entry));      /* Insertion au début */
    TAILQ_INSERT_HEAD(&head, n1, entries);

note: type: Plain text
en: n1 = malloc(sizeof(struct entry));      /* Insert at the tail. */
    TAILQ_INSERT_TAIL(&head, n1, entries);
fr: n1 = malloc(sizeof(struct entry));      /* Insertion à la fin */
    TAILQ_INSERT_TAIL(&head, n1, entries);

note: type: Plain text
en: n2 = malloc(sizeof(struct entry));      /* Insert after. */
    TAILQ_INSERT_AFTER(&head, n1, n2, entries);
                                            /* Forward traversal. */
    for (np = head.tqh_first; np != NULL; np = np-E<gt>entries.tqe_next)
        np-E<gt> ...
                                            /* Delete. */
    while (head.tqh_first != NULL)
        TAILQ_REMOVE(&head, head.tqh_first, entries);
fr: n2 = malloc(sizeof(struct entry));      /* Insertion après */
    TAILQ_INSERT_AFTER(&head, n1, n2, entries);
                                            /* Parcours en avant */
    for (np = head.tqh_first; np != NULL; np = np-E<gt>entries.tqe_next)
        np-E<gt> ...
                                            /* Suppression */
    while (head.tqh_first != NULL)
        TAILQ_REMOVE(&head, head.tqh_first, entries);

note: type: SS
en: Circular queues
fr: Listes circulaires

note: type: Plain text
en: A circular queue is headed by a structure defined by the B<CIRCLEQ_HEAD> macro.  This structure contains a pair of pointers, one to the first element in the circular queue and the other to the last element in the circular queue.  The elements are doubly linked so that an arbitrary element can be removed without traversing the queue.  New elements can be added to the queue after an existing element, before an existing element, at the head of the queue, or at the end of the queue.  A B<CIRCLEQ_HEAD> structure is declared as follows:
fr: La tête d'une liste circulaire est désignée par une structure définie par la macro B<CIRCLEQ_HEAD>. Cette structure contient une paire de pointeurs, l'un sur le premier élément de la liste circulaire et l'autre sur le dernier élément. Les éléments sont doublement chaînés, afin de pouvoir supprimer un élément quelconque sans reparcourir toute la liste. De nouveaux éléments peuvent être ajoutés avant ou après un élément existant, au début ou à la fin de la liste. Une structure B<CIRCLEQ_HEAD> est déclarée ainsi\ :

note: type: Plain text
en: where I<HEADNAME> is the name of the structure to be defined, and I<TYPE> is the type of the elements to be linked into the circular queue.  A pointer to the head of the circular queue can later be declared as:
fr: où I<HEADNAME> est le nom de la structure à définir, et I<TYPE> est le type de l'élément à lier dans la liste circulaire. Un pointeur sur la tête de la liste circulaire peut être déclaré ainsi\ :

note: type: Plain text
en: The macro B<CIRCLEQ_ENTRY> declares a structure that connects the elements in the circular queue.
fr: La macro B<CIRCLEQ_ENTRY> déclare une structure qui connecte les éléments dans la liste circulaire.

note: type: Plain text
en: The macro B<CIRCLEQ_INIT> initializes the circular queue referenced by I<head>.
fr: La macro B<CIRCLEQ_INIT> initialise la liste circulaire référencée par I<head>.

note: type: Plain text
en: The macro B<CIRCLEQ_INSERT_HEAD> inserts the new element I<elm> at the head of the circular queue.
fr: La macro B<CIRCLEQ_INSERT_HEAD> insère le nouvel élément I<elm> au début de la liste circulaire.

note: type: Plain text
en: The macro B<CIRCLEQ_INSERT_TAIL> inserts the new element I<elm> at the end of the circular queue.
fr: La macro B<CIRCLEQ_INSERT_TAIL> insère le nouvel élément I<elm> à la fin de la liste circulaire.

note: type: Plain text
en: The macro B<CIRCLEQ_INSERT_AFTER> inserts the new element I<elm> after the element I<listelm>.
fr: La macro B<CIRCLEQ_INSERT_AFTER> insère le nouvel élément I<elm> après l'élément I<listelm>.

note: type: Plain text
en: The macro B<CIRCLEQ_INSERT_BEFORE> inserts the new element I<elm> before the element I<listelm>.
fr: La macro B<CIRCLEQ_INSERT_BEFORE> insère le nouvel élément I<elm> avant l'élément I<listelm>.

note: type: Plain text
en: The macro B<CIRCLEQ_REMOVE> removes the element I<elm> from the circular queue.
fr: La macro B<CIRCLEQ_REMOVE> supprime l'élément I<elm> de la liste circulaire.

note: type: SS
en: Circular queue example
fr: Exemple de liste circulaire

note: type: Plain text
en: CIRCLEQ_HEAD(circleq, entry) head;
    struct circleq *headp;              /* Circular queue head. */
    struct entry {
        ...
        CIRCLEQ_ENTRY(entry) entries;   /* Circular queue. */
        ...
    } *n1, *n2, *np;
fr: CIRCLEQ_HEAD(circleq, entry) head;
    struct circleq *headp;              /* Tête de liste circulaire */
    struct entry {
        ...
        CIRCLEQ_ENTRY(entry) entries;   /* Liste circulaire */
        ...
    } *n1, *n2, *np;

note: type: Plain text
en: CIRCLEQ_INIT(&head);                /* Initialize the circular queue. */
fr: CIRCLEQ_INIT(&head);                /* Initialisation */

note: type: Plain text
en: n1 = malloc(sizeof(struct entry));  /* Insert at the head. */
    CIRCLEQ_INSERT_HEAD(&head, n1, entries);
fr: n1 = malloc(sizeof(struct entry));  /* Insertion au début */
    CIRCLEQ_INSERT_HEAD(&head, n1, entries);

note: type: Plain text
en: n1 = malloc(sizeof(struct entry));  /* Insert at the tail. */
    CIRCLEQ_INSERT_TAIL(&head, n1, entries);
fr: n1 = malloc(sizeof(struct entry));  /* Insertion à la fin */
    CIRCLEQ_INSERT_TAIL(&head, n1, entries);

note: type: Plain text
en: n2 = malloc(sizeof(struct entry));  /* Insert after. */
    CIRCLEQ_INSERT_AFTER(&head, n1, n2, entries);
fr: n2 = malloc(sizeof(struct entry));  /* Insertion après */
    CIRCLEQ_INSERT_AFTER(&head, n1, n2, entries);

note: type: Plain text
en: n2 = malloc(sizeof(struct entry));  /* Insert before. */
    CIRCLEQ_INSERT_BEFORE(&head, n1, n2, entries);
                                        /* Forward traversal. */
    for (np = head.cqh_first; np != (void *)&head;
            np = np-E<gt>entries.cqe_next)
        np-E<gt> ...
                                        /* Reverse traversal. */
    for (np = head.cqh_last; np != (void *)&head; np = np-E<gt>entries.cqe_prev)
        np-E<gt> ...
                                        /* Delete. */
    while (head.cqh_first != (void *)&head)
        CIRCLEQ_REMOVE(&head, head.cqh_first, entries);
fr: n2 = malloc(sizeof(struct entry));  /* Insertion avant */
    CIRCLEQ_INSERT_BEFORE(&head, n1, n2, entries);
                                        /* Parcours en avant */
    for (np = head.cqh_first; np != (void *)&head;
            np = np-E<gt>entries.cqe_next)
        np-E<gt> ...
                                        /* Parcours en arrière */
    for (np = head.cqh_last; np != (void *)&head; np = np-E<gt>entries.cqe_prev)
        np-E<gt> ...
                                        /* Suppression */
    while (head.cqh_first != (void *)&head)
        CIRCLEQ_REMOVE(&head, head.cqh_first, entries);

note: type: Plain text
en: Not in POSIX.1-2001.  Present on the BSDs.  The queue functions first appeared in 4.4BSD.
fr: Pas dans POSIX.1-2001. Présentes sur les BSD. Les fonctions de liste queue sont apparues dans BSD 4.4.

note: type: TH
en: 2013-03-15
fr: 15 mars 2013

note: type: Plain text
en: realpath - return the canonicalized absolute pathname
fr: realpath - Renvoyer le chemin d'accès absolu

note: type: Plain text
en: B<realpath>():
fr: B<realpath>() :

note: type: Plain text
en: B<realpath>()  expands all symbolic links and resolves references to I</./>, I</../> and extra \(aq/\(aq characters in the null-terminated string named by I<path> to produce a canonicalized absolute pathname.  The resulting pathname is stored as a null-terminated string, up to a maximum of B<PATH_MAX> bytes, in the buffer pointed to by I<resolved_path>.  The resulting path will have no symbolic link, I</./> or I</../> components.
fr: B<realpath> développe tous les liens symboliques, et résout les références à «\ /./\ », «\ /../\ » ainsi que les caractères «\ /\ » supplémentaires dans la chaîne, terminée par un caractère nul, pointée par I<path> pour produire une forme canonique du chemin absolu. Le chemin résultant est stocké sous la forme d'une chaîne terminée par un caractère nul pouvant contenir jusqu'à B<PATH_MAX> octets, dans le tampon pointé par I<resolved_path>. Le chemin résultant ne traversera plus de liens symboliques, et ne contiendra plus d'éléments «\ /./\ » ou «\ /../\ ».

note: Even if we use resolved_path == NULL, then realpath() will still return ENAMETOOLONG if the resolved pathname would exceed PATH_MAX bytes -- MTK, Dec 04 .SH HISTORY The .BR realpath () function first appeared in 4.4BSD, contributed by Jan-Simon Pendry. type: Plain text
en: If I<resolved_path> is specified as NULL, then B<realpath>()  uses B<malloc>(3)  to allocate a buffer of up to B<PATH_MAX> bytes to hold the resolved pathname, and returns a pointer to this buffer.  The caller should deallocate this buffer using B<free>(3).
fr: Si I<resolved_path> est NULL, alors B<realpath>() utilise B<malloc>(3) pour allouer un tampon allant jusqu'à B<PATH_MAX> octets pour contenir le chemin trouvé, et retourner un pointeur sur ce tampon. L'appelant doit libérer ce tampon avec B<free>(3).

note: type: Plain text
en: If there is no error, B<realpath>()  returns a pointer to the I<resolved_path>.
fr: S'il n'y a pas d'erreur, B<realpath>() renvoie un pointeur sur I<resolved_path>.

note: type: Plain text
en: Otherwise, it returns NULL, the contents of the array I<resolved_path> are undefined, and I<errno> is set to indicate the error.
fr: Sinon elle renvoie NULL, le contenu de I<resolved_path> n'est pas défini, et I<errno> prend la valeur du code d'erreur.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: Read or search permission was denied for a component of the path prefix.
fr: La permission de recherche ou de lecture n'est pas accordée pour un composant du chemin d'accès.

note: (In libc5 this would just cause a segfault.) type: Plain text
en: I<path> is NULL.  (In glibc versions before 2.3, this error is also returned if I<resolved_path> is NULL.)
fr: I<path> est NULL (dans les versions de glibc précédant la 2.3, cette erreur est aussi renvoyée si I<resolved_path> est NULL).

note: type: Plain text
en: An I/O error occurred while reading from the filesystem.
fr: Une erreur d'entrée-sortie est survenue lors de la lecture sur le système de fichiers.

note: type: Plain text
en: Too many symbolic links were encountered in translating the pathname.
fr: Trop de liens symboliques ont été rencontrés en parcourant le chemin.

note: type: Plain text
en: A component of a pathname exceeded B<NAME_MAX> characters, or an entire pathname exceeded B<PATH_MAX> characters.
fr: Un élément du chemin d'accès dépasse B<NAME_MAX> caractères de long, ou le chemin d'accès complet dépasse B<PATH_MAX> caractères.

note: type: Plain text
en: The named file does not exist.
fr: Le fichier indiqué n'existe pas.

note: type: Plain text
en: A component of the path prefix is not a directory.
fr: Un élément du chemin d'accès n'est pas un répertoire.

note: type: Plain text
en: On Linux, this function appeared in libc 4.5.21.
fr: Sous Linux, cette fonction est apparue dans la libc 4.5.21.

note: type: Plain text
en: 4.4BSD, POSIX.1-2001.
fr: BSD\ 4.4, POSIX.1-2001.

note: type: Plain text
en: POSIX.1-2001 says that the behavior if I<resolved_path> is NULL is implementation-defined.  POSIX.1-2008 specifies the behavior described in this page.
fr: POSIX.1 indique que le comportement dans le cas où I<resolved_path> est NULL dépend de l'implémentation. POSIX.1-2008 spécifie le comportement décrit dans cette page.

note: type: Plain text
en: In 4.4BSD and Solaris, the limit on the pathname length is B<MAXPATHLEN> (found in I<E<lt>sys/param.hE<gt>>).  SUSv2 prescribes B<PATH_MAX> and B<NAME_MAX>, as found in I<E<lt>limits.hE<gt>> or provided by the B<pathconf>(3)  function.  A typical source fragment would be
fr: Dans BSD\ 4.4 et Solaris, la limite de longueur du chemin est B<MAXPATHLEN> (dans I<E<lt>sys/param.hE<gt>>). SUSv2 conseille B<PATH_MAX> et B<NAME_MAX>, dans I<E<lt>limits.hE<gt>> ou fournis par B<pathconf>(3). Un fragment de code typique serait

note: type: Plain text
en: (But see the BUGS section.)
fr: (Mais voir quand même la section des BOGUES).

note: 2012-05-05, According to Casper Dik, the statement about Solaris was not true at least as far back as 1997, and may never have been true. The 4.4BSD, Linux and SUSv2 versions always return an absolute pathname. Solaris may return a relative pathname when the .I path argument is relative. type: Plain
en: The prototype of B<realpath>()  is given in I<E<lt>unistd.hE<gt>> in libc4 and libc5, but in I<E<lt>stdlib.hE<gt>> everywhere else.
fr: Le prototype de B<realpath>() est donné dans I<E<lt>unistd.hE<gt>> dans les libc4 et libc5, mais dans I<E<lt>stdlib.hE<gt>> partout ailleurs.

note: type: SS
en: GNU extensions
fr: Extensions GNU

note: type: Plain text
en: If the call fails with either B<EACCES> or B<ENOENT> and I<resolved_path> is not NULL, then the prefix of I<path> that is not readable or does not exist is returned in I<resolved_path>.
fr: Si l'appel échoue avec B<EACCES> ou B<ENOENT> alors que I<resolved_path> n'est pas NULL, alors le préfixe de I<path> qui n'est pas lisible ou qui n'existe pas est renvoyé dans I<resolved_path>.

note: type: Plain text
en: The POSIX.1-2001 standard version of this function is broken by design, since it is impossible to determine a suitable size for the output buffer, I<resolved_path>.  According to POSIX.1-2001 a buffer of size B<PATH_MAX> suffices, but B<PATH_MAX> need not be a defined constant, and may have to be obtained using B<pathconf>(3).  And asking B<pathconf>(3)  does not really help, since, on the one hand POSIX warns that the result of B<pathconf>(3)  may be huge and unsuitable for mallocing memory, and on the other hand B<pathconf>(3)  may return -1 to signify that B<PATH_MAX> is not bounded.  The I<resolved_path\ ==\ NULL> feature, not standardized in POSIX.1-2001, but standardized in POSIX.1-2008, allows this design problem to be avoided.
fr: La version du standard POSIX.1-2001 de cette fonctions est erronée par construction car elle ne permet pas de connaître la taille nécessaire pour le tampon de sortie I<resolved_path>. D'après POSIX.1-2001, un tampon de taille B<PATH_MAX> suffit, mais B<PATH_MAX> n'est pas nécessairement une constante définie et peut être obtenue avec B<pathconf>(3). En outre, interroger B<pathconf>(3) n'aide pas vraiment, car d'une part POSIX prévient que les résultats de B<pathconf>(3) peuvent être immenses et inappropriés pour allouer de la mémoire et d'autre part B<pathconf>(3) peut renvoyer -1 indiquant que B<PATH_MAX> est illimité. La fonctionnalité I<resolved_path\ ==\ NULL>, non standard dans POSIX.1-2008, permet d'éviter ces problèmes.

note: type: Plain text
en: The libc4 and libc5 implementation contained a buffer overflow (fixed in libc-5.4.13).  Thus, set-user-ID programs like B<mount>(8)  needed a private version.
fr: Les implémentations dans les libc4 et libc5 contenaient un débordement de tampon (corrigé dans la libc-5.4.13). Ainsi, les programmes Set-UID, comme B<mount>(8), avaient besoin d'une version privée de cette routine.

note: type: TH
en: 2014-01-07
fr: 7 janvier 2014

note: type: Plain text
en: setjmp, sigsetjmp - save stack context for nonlocal goto
fr: setjmp, sigsetjmp - Sauver le contexte de pile pour un saut non local

note: type: Plain text
en: B<setjmp>(): see NOTES.
fr: B<setjmp>() : consultez la section NOTES.

note: type: Plain text
en: B<sigsetjmp>(): _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_C_SOURCE
fr: B<sigsetjmp>() : _POSIX_C_SOURCE\ E<gt>=\ 1 || _XOPEN_SOURCE || _POSIX_C_SOURCE

note: type: Plain text
en: B<setjmp>()  and B<longjmp>(3)  are useful for dealing with errors and interrupts encountered in a low-level subroutine of a program.  B<setjmp>()  saves the stack context/environment in I<env> for later use by B<longjmp>(3).  The stack context will be invalidated if the function which called B<setjmp>()  returns.
fr: Les fonctions B<setjmp>() et B<longjmp>(3) sont utiles pour gérer les erreurs et les interruptions rencontrées dans des routines bas-niveau. B<setjmp>() sauvegarde le contexte de pile et d'environnement dans I<env> afin de l'utiliser ultérieurement avec B<longjmp>(3). Le contexte de pile sera invalide si la fonction qui appelle B<setjmp>() se termine.

note: type: Plain text
en: B<sigsetjmp>()  is similar to B<setjmp>().  If, and only if, I<savesigs> is nonzero, the process's current signal mask is saved in I<env> and will be restored if a B<siglongjmp>(3)  is later performed with this I<env>.
fr: B<sigsetjmp>() est semblable à B<setjmp>(). Si, et seulement si, I<savesigs> est non nul, le masque de signaux actuel du processus est sauvegardé dans I<env>, et sera rétabli lorsque B<siglongjmp>(3) sera invoqué avec ce contexte I<env>.

note: type: Plain text
en: B<setjmp>()  and B<sigsetjmp>()  return 0 if returning directly, and nonzero when returning from B<longjmp>(3)  or B<siglongjmp>(3)  using the saved context.
fr: B<setjmp>() et B<sigsetjmp>() renvoient 0 lorsqu'elles reviennent directement, et une valeur non nulle si elles reviennent à travers un appel à B<longjmp>(3) ou B<siglongjmp>(3) en utilisant le contexte sauvegardé.

note: type: Plain text
en: C89, C99, and POSIX.1-2001 specify B<setjmp>().  POSIX.1-2001 specifies B<sigsetjmp>().
fr: C89, C99 et POSIX.1-2001 spécifient B<setjmp>(). POSIX.1-2001 spécifie B<sigsetjmp>().

note: type: Plain text
en: POSIX does not specify whether B<setjmp>()  will save the signal mask (to be later restored during B<longjmp>(3)).  In System V it will not.  In 4.3BSD it will, and there is a function B<_setjmp> that will not.  On Linux with glibc versions before 2.19, B<setjmp>()  follows the System V behavior by default, but the BSD behavior is provided if the B<_BSD_SOURCE> feature test macro is defined and none of B<_POSIX_SOURCE>, B<_POSIX_C_SOURCE>, B<_XOPEN_SOURCE>, B<_XOPEN_SOURCE_EXTENDED>, B<_GNU_SOURCE>, or B<_SVID_SOURCE> is defined.  Since glibc 2.19, I<E<lt>setjmp.hE<gt>> exposes only the System V version of B<setjmp>().  Programs that need the BSD semantics should replace calls to B<setjmp>()  with calls to B<sigsetjmp>()  with a nonzero I<savesigs> argument.
fr: POSIX ne spécifie pas si B<setjmp>() sauve le masque de signaux (pour être ensuite restauré lors de B<longjmp>(3)). Sous System V, ce n'est pas le cas. Sous BSD 4.3, le masque sera sauvé et il y a une fonction B<_setjmp> qui ne fait pas la copie. Sous Linux avec glibc avant la version 2.19, B<setjmp>() suit le comportement de System V par défaut, mais le comportement BSD est fournit si la macro de test de fonctionnalités B<_BSD_SOURCE> est définie et qu’aucune des macros B<_POSIX_SOURCE>, B<_POSIX_C_SOURCE>, B<_XOPEN_SOURCE>, B<_XOPEN_SOURCE_EXTENDED>, B<_GNU_SOURCE> ou B<_SVID_SOURCE> n'est définie. Depuis glibc 2.19, I<E<lt>setjmp.hE<gt>> n’expose que la version System V de B<setjmp>(). Les programmes ayant besoin de le sémantique BSD devraient remplacer les appels de B<setjmp>() par des appels de B<sigsetjmp>() avec un argument I<savesigs> non nul.

note: type: Plain text
en: If you want to portably save and restore signal masks, use B<sigsetjmp>()  and B<siglongjmp>(3).
fr: Si vous souhaitez sauver et restaurer le masque de signaux de façon portable, utilisez B<sigsetjmp>() et B<siglongjmp>(3).

note: type: Plain text
en: B<setjmp>()  and B<sigsetjmp>()  make programs hard to understand and maintain.  If possible, an alternative should be used.
fr: B<setjmp>() et B<sigsetjmp>() rendent les programmes difficiles à comprendre et à maintenir. Si possible, essayez d'utiliser une autre méthode.

note: type: TH
en: 2003-04-04
fr: 4 avril 2003

note: type: Plain text
en: xencrypt, xdecrypt, passwd2des - RFS password encryption
fr: xencrypt, xdecrypt, passwd2des - Chiffrement des mots de passe RFS

note: type: Plain text
en: B<void passwd2des(char >I<*passwd>B<, char *>I<key>B<);>
fr: B<void passwd2des(char >I<*motdepasse>B<, char *>I<key>B<);>

note: type: Plain text
en: B<int xencrypt(char *>I<secret>B<, char *>I<passwd>B<);>
fr: B<int xencrypt(char *>I<secret>B<, char *>I<motdepasse>B<);>

note: type: Plain text
en: B<int xdecrypt(char *>I<secret>B<, char *>I<passwd>B<);>
fr: B<int xdecrypt(char *>I<secret>B<, char *>I<motdepasse>B<);>

note: type: Plain text
en: The function B<passwd2des>()  takes a character string I<passwd> of arbitrary length and fills a character array I<key> of length 8.  The array I<key> is suitable for use as DES key.  It has odd parity set in bit 0 of each byte.  Both other functions described here use this function to turn their argument I<passwd> into a DES key.
fr: La fonction B<passwd2des>() prend une chaîne de caractère I<motdepasse> d'une longueur quelconque et remplit un tableau de caractères I<key> de taille 8 octets. Le tableau I<key> est utilisable comme clé DES. Elle a le bit de parité mis à zéro dans chaque octet. Les deux autres fonctions utilisent cette fonction pour transformer leur argument I<motdepasse> en clé DES.

note: (over the alphabet 0123456789abcdefABCDEF), (over the alphabet 0123456789abcdef) type: Plain text
en: The B<xencrypt>()  function takes the ASCII character string I<secret> given in hex, which must have a length that is a multiple of 16, encrypts it using the DES key derived from I<passwd> by B<passwd2des>(), and outputs the result again in I<secret> as a hex string of the same length.
fr: La fonction B<xencrypt>() prend une chaîne de caractères ASCII I<secret> en hexadécimal, qui doit avoir une longueur multiple de 16, la chiffre en utilisant la clé DES dérivée de I<motdepasse> par B<passwd2des>(), et renvoie le résultat dans I<secret> comme une chaîne hexadécimale de même longueur.

note: type: Plain text
en: The B<xdecrypt>()  function performs the converse operation.
fr: La fonction B<xdecrypt>() effectue la conversion inverse.

note: type: Plain text
en: The functions B<xencrypt>()  and B<xdecrypt>()  return 1 on success and 0 on error.
fr: Les fonctions B<xencrypt>() et B<xdecrypt>() renvoient 1 si elles réussissent et 0 en cas d'erreur.

note: type: Plain text
en: These routines are present in libc 4.6.27 and later, and in glibc 2.1 and later.
fr: Ces routines sont présentes dans la libc\ 4.6.27 et ultérieures, et dans la glibc\ 2.1 et ultérieures.

note: type: Plain text
en: The prototypes are missing from the abovementioned include file.
fr: Les prototypes sont absents des fichiers d'en-tête indiqués plus haut.
