perkamon - en to fr translation catalogue (614 entries)

note: type: TH
en: 1999-07-04
fr: 4 juillet 1999

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: MB_CUR_MAX - maximum length of a multibyte character in the current locale
fr: MB_CUR_MAX - Longueur maximale d'un caractère multioctet dans la localisation actuelle

note: type: Plain text
en: The B<MB_CUR_MAX> macro defines an integer expression giving the maximum number of bytes needed to represent a single wide character in the current locale.  It is locale dependent and therefore not a compile-time constant.
fr: La macro B<MB_CUR_MAX> définie une expression entière donnant le nombre maximal d'octets nécessaires pour représenter un caractère large unique dans la localisation courante. Cette expression n'est pas une constante à la compilation, car cette valeur change suivant la localisation.

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

note: type: Plain text
en: An integer in the range [1, B<MB_LEN_MAX>].  The value 1 denotes traditional 8-bit encoded characters.
fr: Un entier de l'intervalle [1, B<MB_LEN_MAX>]. La valeur 1 correspond à l'encodage 8 bits habituel.

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

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: Plain text
en: MB_LEN_MAX - maximum multibyte length of a character across all locales
fr: MB_LEN_MAX - Longueur maximale d'un caractère quelle que soit la localisation

note: type: Plain text
en: The B<MB_LEN_MAX> macro is the upper bound for the number of bytes needed to represent a single wide character, across all locales.
fr: La macro B<MB_LEN_MAX> est la limite supérieure au nombre d'octets nécessaires pour représenter un caractère large unique, quelque soit la localisation choisie.

note: type: Plain text
en: A constant integer greater than zero.
fr: Une constante entière supérieure à zéro.

note: type: Plain text
en: The entities B<MB_LEN_MAX> and I<sizeof(wchar_t)> are totally unrelated.  In glibc, B<MB_LEN_MAX> is typically 6 while I<sizeof(wchar_t)> is 4.
fr: Les entités B<MB_LEN_MAX> et I<sizeof(wchar_t)> n'ont aucun rapport. Dans la bibliothèque glibc, B<MB_LEN_MAX> vaut typiquement 6 alors que I<sizeof(wchar_t)> vaut 4.

note: type: TH
en: 2010-09-20
fr: 20 septembre 2010

note: type: Plain text
en: _exit, _Exit - terminate the calling process
fr: _exit, _Exit - Mettre fin au processus appelant

note: type: Plain text
en: B<void _exit(int >I<status>B<);>
fr: B<void _exit(int >I<code>B<);>

note: type: Plain text
en: B<void _Exit(int >I<status>B<);>
fr: B<void _Exit(int >I<code>B<);>

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<_Exit>():
fr: B<_Exit>() :

note: type: Plain text
en: _XOPEN_SOURCE\ E<gt>=\ 600 || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L;
fr: _XOPEN_SOURCE\ E<gt>=\ 600 || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L

note: type: Plain text
en: or I<cc\ -std=c99>
fr: ou I<cc\ -std=c99>

note: type: Plain text
en: The function B<_exit>()  terminates the calling process "immediately".  Any open file descriptors belonging to the process are closed; any children of the process are inherited by process 1, I<init>, and the process's parent is sent a B<SIGCHLD> signal.
fr: La fonction B<_exit>() met fin «\ immédiatement\ » au processus en cours, les descripteurs de fichier lui appartenant sont fermés, tous ses fils éventuels sont hérités par le processus 1 (I<init>), et son père reçoit un signal B<SIGCHLD>.

note: type: Plain text
en: The value I<status> is returned to the parent process as the process's exit status, and can be collected using one of the B<wait>(2)  family of calls.
fr: La valeur I<code> est renvoyée au processus père comme valeur de sortie et peut être récupérée en utilisant un appel système de la famille B<wait>(2).

note: type: Plain text
en: The function B<_Exit>()  is equivalent to B<_exit>().
fr: La fonction B<_Exit>() est équivalente à B<_exit>().

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

note: type: Plain text
en: SVr4, POSIX.1-2001, 4.3BSD.  The function B<_Exit>()  was introduced by C99.
fr: SVr4, POSIX.1-2001, BSD\ 4.3. La fonction B<_Exit>() est apparue dans C99.

note: type: Plain text
en: For a discussion on the effects of an exit, the transmission of exit status, zombie processes, signals sent, and so on, see B<exit>(3).
fr: Pour une discussion sur les effets de exit, la transmission de la valeur de retour, les processus zombie, les signaux envoyés, etc. reportez\(hyvous à B<exit>(3).

note: type: Plain text
en: The function B<_exit>()  is like B<exit>(3), but does not call any functions registered with B<atexit>(3)  or B<on_exit>(3).  Whether it flushes standard I/O buffers and removes temporary files created with B<tmpfile>(3)  is implementation-dependent.  On the other hand, B<_exit>()  does close open file descriptors, and this may cause an unknown delay, waiting for pending output to finish.  If the delay is undesired, it may be useful to call functions like B<tcflush>(3)  before calling B<_exit>().  Whether any pending I/O is canceled, and which pending I/O may be canceled upon B<_exit>(), is implementation-dependent.
fr: L'appel système B<_exit>() est identique à B<exit>(3), mais n'appelle aucune fonction programmée par la routine B<atexit>(3) ou B<on_exit>(3). Le fait qu'il vide ou non les tampons d'entrée-sortie, ou qu'il efface les fichiers temporaires créés avec B<tmpfile>(3) dépend de l'implémentation. En revanche, B<_exit> ferme les descripteurs de fichier, ce qui peut retarder son exécution durant le temps où des écritures se terminent. Si ce retard est gênant, on peut invoquer B<tcflush>(3) avant d'appeler B<_exit>(). Savoir si certaines entrées-sorties en attente sont annulées lors d'un B<_exit>(), et lesquelles, dépend de l'implémentation.

note: type: Plain text
en: In glibc up to version 2.3, the B<_exit>()  wrapper function invoked the kernel system call of the same name.  Since glibc 2.3, the wrapper function invokes B<exit_group>(2), in order to terminate all of the threads in a process.
fr: Dans la glibc jusqu'à la version 2.3, la fonction enveloppe B<_exit>() appelait l'appel système de même nom. Depuis la glibc 2.3, la fonction enveloppe appelle B<exit_group>(2), afin de terminer tous les threads du processus.

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

note: type: Plain text
en: a64l, l64a - convert between long and base-64
fr: a64l, l64a - Fonctions de conversion entre les types long et base 64

note: type: Plain text
en: B<a64l>(), B<l64a>():
fr: B<a64l>(), B<l64a>() :

note: type: Plain text
en: These functions provide a conversion between 32-bit long integers and little-endian base-64 ASCII strings (of length zero to six).  If the string used as argument for B<a64l>()  has length greater than six, only the first six bytes are used.  If the type I<long> has more than 32 bits, then B<l64a>()  uses only the low order 32 bits of I<value>, and B<a64l>()  sign-extends its 32-bit result.
fr: Ces fonctions assurent la conversion entre des entiers longs sur 32 bits et des chaînes de caractères ASCII (de 0 à 6 caractères) petit boutiste en base 64. Si la chaîne passée en argument à B<a64l>() possède plus de six octets, alors seuls les six premiers octets sont utilisés. Si les entiers de type I<long> font plus de 32 bits, alors B<l64a>() n'utilise que les 32 bits de poids faible de I<value>, et B<a64l>() propage le bit de signe de son résultat sur 32 bits.

note: type: Plain text
en: The 64 digits in the base-64 system are:
fr: Les 64 chiffres en base 64 sont\ :

note: type: Plain text
en: \&\(aq.\(aq	represents a 0
    \&\(aq/\(aq	represents a 1
    0-9	represent  2-11
    A-Z	represent 12-37
    a-z	represent 38-63
fr: \«\ .\ »	représente un 0
    \«\ /\ »	représente un 1
    0-9		représentent  2-11
    A-Z		représentent 12-37
    a-z		représentent 38-63

note: type: Plain text
en: So 123 = 59*64^0 + 1*64^1 = "v/".
fr: Exemple\ : 123 = 59*64^0 + 1*64^1 = "v/".

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

note: type: Plain text
en: The B<a64l>()  function is thread-safe.
fr: La fonction B<a64l>() est sûre dans un contexte multithread.

note: type: Plain text
en: The value returned by B<l64a>()  may be a pointer to a static buffer, possibly overwritten by later calls.
fr: La valeur renvoyée par B<a64l>() peut être un pointeur sur un tampon statique, qui peut être réécrit par des appels ultérieurs.

note: type: Plain text
en: The behavior of B<l64a>()  is undefined when I<value> is negative.  If I<value> is zero, it returns an empty string.
fr: Le comportement de B<l64a>() est indéfinie lorsque I<value> est négatif. Si I<value> vaut zéro, une chaîne vide est renvoyée.

note: type: Plain text
en: These functions are broken in glibc before 2.2.5 (puts most significant digit first).
fr: Ces fonctions n'étaient pas fonctionnelles avant la version\ 2.2.5 de la glibc (chiffre le plus significatif en premier).

note: type: Plain text
en: This is not the encoding used by B<uuencode>(1).
fr: Ce n'est pas l'encodage utilisé par B<uuencode>(1).

note: type: TH
en: 2008-12-05
fr: 5 décembre 2008

note: type: Plain text
en: atexit - register a function to be called at normal process termination
fr: atexit - Enregistrer une fonction à appeler à la fin d'un programme

note: type: Plain text
en: The B<atexit>()  function registers the given I<function> to be called at normal process termination, either via B<exit>(3)  or via return from the program's I<main>().  Functions so registered are called in the reverse order of their registration; no arguments are passed.
fr: La fonction B<atexit>() enregistre la fonction I<function> donnée pour que celle-ci soit automatiquement appelée lorsque le programme se termine normalement avec B<exit>(3) ou lors de la fin de la fonction I<main>. Les fonctions ainsi enregistrées sont invoquées dans l'ordre inverse de leur enregistrement\ ; aucun argument n'est transmis.

note: type: Plain text
en: The same function may be registered multiple times: it is called once for each registration.
fr: La même fonction peut être enregistrée plusieurs fois : elle sera appelée une fois pour chaque enregistrement.

note: type: Plain text
en: POSIX.1-2001 requires that an implementation allow at least B<ATEXIT_MAX> (32) such functions to be registered.  The actual limit supported by an implementation can be obtained using B<sysconf>(3).
fr: POSIX.1-2001 exige que l'implémentation permette d'enregistrer au moins B<ATEXIT_MAX> (32) de ces fonctions. La limite actuelle de l'implémentation peut être obtenue avec B<sysconf>(3).

note: type: Plain text
en: When a child process is created via B<fork>(2), it inherits copies of its parent's registrations.  Upon a successful call to one of the B<exec>(3)  functions, all registrations are removed.
fr: Lorsqu'un processus fils est créé avec B<fork>(2), il hérite d'une copie des enregistrements de son parent. À la suite d'un appel réussi à l'une des fonctions B<exec>(3), tous les enregistrements sont supprimés.

note: type: Plain text
en: The B<atexit>()  function returns the value 0 if successful; otherwise it returns a nonzero value.
fr: La fonction B<atexit>() renvoie 0 en cas de succès et une valeur non nulle en cas d'échec.

note: type: Plain text
en: SVr4, 4.3BSD, C89, C99, POSIX.1-2001.
fr: SVr4, BSD\ 4.3, C89, C99, POSIX.1-2001.

note: type: Plain text
en: Functions registered using B<atexit>()  (and B<on_exit>(3))  are not called if a process terminates abnormally because of the delivery of a signal.
fr: Les fonctions enregistrées avec B<atexit>() (et B<on_exit>(3)) ne sont pas appelées si le programme se termine anormalement à cause de l'envoi d'un signal.

note: type: Plain text
en: If one of the functions registered functions calls B<_exit>(2), then any remaining functions are not invoked, and the other process termination steps performed by B<exit>(3)  are not performed.
fr: Si l'une des fonctions enregistrées appelle B<_exit>(2), alors toutes les autres fonctions enregistrées ne seront pas appelées, et les étapes de fin de processus effectuées par B<exit>(3) ne seront pas réalisées.

note: This can happen on OpenBSD 4.2 for example, and is documented as occurring on FreeBSD as well. Glibc does "the Right Thing" -- invocation of the remaining exit handlers carries on as normal. type: Plain text
en: POSIX.1-2001 says that the result of calling B<exit>(3)  more than once (i.e., calling B<exit>(3)  within a function registered using B<atexit>())  is undefined.  On some systems (but not Linux), this can result in an infinite recursion; portable programs should not invoke B<exit>(3)  inside a function registered using B<atexit>().
fr: POSIX.1-2001 dit que le résultat de plus d'un appel à B<exit>(3) (par exemple, appelé B<exit>(3) dans une fonction enregistrée avec B<atexit>(3)) est indéfini. Sur quelques systèmes (mais pas sous Linux), cela peut produire une boucle infinie ; les programmes portables ne doivent pas appeler B<exit>(3) dans une fonction enregistrée avec B<atexit>(3).

note: type: Plain text
en: The B<atexit>()  and B<on_exit>(3)  functions register functions on the same list: at normal process termination, the registered functions are invoked in reverse order of their registration by these two functions.
fr: Les fonctions B<atexit>() et B<on_exit>(3) enregistrent les fonctions dans la même liste\ : les fonctions ainsi enregistrées sont invoquées dans l'ordre inverse de leur enregistrement par ces deux fonctions.

note: In glibc, things seem to be handled okay type: Plain text
en: POSIX.1-2001 says that the result is undefined if B<longjmp>(3)  is used to terminate execution of one of the functions registered B<atexit>().
fr: POSIX.1-2001 dit que le résultat est indéfini si B<longjmp>(3) est utilisée pour terminer l'exécution d'une fonction enregistrée avec B<atexit>().

note: type: SS
en: Linux notes
fr: Notes sur Linux

note: type: Plain text
en: Since glibc 2.2.3, B<atexit>()  (and B<on_exit>(3))  can be used within a shared library to establish functions that are called when the shared library is unloaded.
fr: Depuis la version\ 2.2.3 de la glibc, B<atexit>() (et B<on_exit>(3)) peut être utilisée dans une bibliothèque partagée pour définir les fonctions qui sont appelées lorsque la bibliothèque partagée est déchargée.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: TH
en: 2014-01-22
fr: 22 janvier 2014

note: type: Plain text
en: atof - convert a string to a double
fr: atof - Convertir une chaîne en réel double précision (double)

note: type: Plain text
en: The B<atof>()  function converts the initial portion of the string pointed to by I<nptr> to I<double>.  The behavior is the same as
fr: La fonction B<atof>() convertit le début de la chaîne pointée par I<nptr> en un type I<double>. Le comportement est le même que

note: type: Plain text
en: except that B<atof>()  does not detect errors.
fr: à la différence que B<atof>() ne détecte pas les erreurs.

note: type: Plain text
en: The converted value.
fr: Le résultat de la conversion.

note: type: Plain text
en: The B<atof>()  function is thread-safe with exceptions.  It can be safely used in multithreaded applications, as long as B<setlocale>(3)  is not called to change the locale during its execution.
fr: La fonction B<atof>() est sûre dans un contexte multithread avec exceptions. Elle peut être utilisée de manière sûre tant que B<setlocale>(3) n'est pas appelée pour modifier les paramètres régionaux pendant son exécution.

note: type: Plain text
en: SVr4, POSIX.1-2001, 4.3BSD, C89, C99.
fr: SVr4, POSIX.1-2001, BSD\ 4.3, C89, C99.

note: type: Plain text
en: atoi, atol, atoll, atoq - convert a string to an integer
fr: atoi, atol, atoll, atoq - Convertir une chaîne en entier

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

note: type: Plain text
en: _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE\ E<gt>=\ 600 || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L;
fr: _BSD_SOURCE || _SVID_SOURCE || _XOPEN_SOURCE\ E<gt>=\ 600 || _ISOC99_SOURCE || _POSIX_C_SOURCE\ E<gt>=\ 200112L

note: type: Plain text
en: The B<atoi>()  function converts the initial portion of the string pointed to by I<nptr> to I<int>.  The behavior is the same as
fr: La fonction B<atoi>() convertit le début de la chaîne pointée par I<nptr> en entier de type I<int>. Le résultat est identique à un appel à

note: type: Plain text
en: except that B<atoi>()  does not detect errors.
fr: à la différence que B<atoi>() ne détecte pas d'erreur.

note: type: Plain text
en: The B<atol>()  and B<atoll>()  functions behave the same as B<atoi>(), except that they convert the initial portion of the string to their return type of I<long> or I<long long>.  B<atoq>()  is an obsolete name for B<atoll>().
fr: Les fonctions B<atol>() et B<atoll>() se comportent comme B<atoi>(), sauf qu'elles convertissent la portion initiale de la chaîne dans leur type de retour I<long> ou I<long long>. B<atoq>() est un nom obsolète pour B<atoll>().

note: type: Plain text
en: The B<atoi>(), B<atol>(), and B<atoll>()  functions are thread-safe with exceptions.  These functions can be safely used in multithreaded applications, as long as B<setlocale>(3)  is not called to change the locale during their execution.
fr: Les fonctions B<atoi>(), B<atol>() et B<atoll>() sont sûres dans un contexte multithread avec exceptions. Elles peuvent être utilisées de manière sûre tant que B<setlocale>(3) n'est pas appelée pour modifier les paramètres régionaux pendant leur exécution.

note: type: Plain text
en: SVr4, POSIX.1-2001, 4.3BSD, C99.  C89 and POSIX.1-1996 include the functions B<atoi>()  and B<atol>()  only.  B<atoq>()  is a GNU extension.
fr: SVr4, POSIX.1-2001, BSD\ 4.3, C99. C89 et POSIX.1-1996 n'incluent que les fonctions B<atoi>() et B<atol>(). B<atoq>() est une extension GNU.

note: type: Plain text
en: The nonstandard B<atoq>()  function is not present in libc 4.6.27 or glibc 2, but is present in libc5 and libc 4.7 (though only as an inline function in I<E<lt>stdlib.hE<gt>> until libc 5.4.44).  The B<atoll>()  function is present in glibc 2 since version 2.0.2, but not in libc4 or libc5.
fr: La fonction non standard B<atoq>() n'est pas présente dans la libc\ 4.6.27 ni dans la glibc2, mais est présente dans libc5 et libc\ 4.7 (bien que ce ne soit qu'une fonction «\ inline\ » dans I<E<lt>stdlib.hE<gt>> jusqu'à la libc\ 5.4.44). La fonction B<atoll>() est présente dans la glibc2 depuis la version\ 2.0.2, mais pas dans libc4 ou libc5.

note: type: TH
en: 2013-05-11
fr: 11 mai 2013

note: type: Plain text
en: canonicalize_file_name - return the canonicalized absolute pathname
fr: canonicalize_file_name - Renvoyer le chemin absolu sous forme canonique

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 B<canonicalize_file_name>()  function returns a null-terminated string containing the canonicalized absolute pathname corresponding to I<path>.  In the returned string, symbolic links are resolved, as are I<.> and I<..> pathname components.  Consecutive slash (I</>)  characters are replaced by a single slash.
fr: La fonction B<canonicalize_file_name>() renvoie une chaîne terminée par un caractère nul contenant la forme canonique du chemin absolu indiqué par I<path>. Dans la chaîne renvoyée, les liens symboliques sont résolus, ainsi que tout élément I<.> ou I<..> présent dans I<path>. Les doublons de barres obliques (« slash », I</>) sont supprimés.

note: type: Plain text
en: The returned string is dynamically allocated by B<canonicalize_file_name>()  and the caller should deallocate it with B<free>(3)  when it is no longer required.
fr: La chaîne renvoyée est allouée dynamiquement par B<canonicalize_file_name>(). L'appelant doit la désallouer avec B<free>(3) dès qu'elle n'est plus nécessaire.

note: type: Plain text
en: The call I<canonicalize_file_name(path)> is equivalent to the call:
fr: L'appel I<canonicalize_file_name(path)> est équivalent à l'appel :

note: type: Plain text
en: On success, B<canonicalize_file_name>()  returns a null-terminated string.  On error (e.g., a pathname component is unreadable or does not exist), B<canonicalize_file_name>()  returns NULL and sets I<errno> to indicate the error.
fr: En cas de succès, B<canonicalize_file_name>() renvoie une chaîne terminée par un caractère nul. En cas d'erreur (par exemple, si une partie du chemin n'est pas lisible ou n'existe pas), B<canonicalize_file_name>() renvoie NULL et I<errno> contient le code d'erreur.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: See B<realpath>(3).
fr: Consultez B<realpath>(3).

note: type: Plain text
en: This function is a GNU extension.
fr: Cette fonction est une extension GNU.

note: type: TH
en: 2007-07-26
fr: 26 juillet 2007

note: type: Plain text
en: cfree - free allocated memory
fr: cfree - Libérer la mémoire allouée

note: type: Plain text
en: /* In SunOS 4 */
    B<int cfree(void *>I<ptr>B<);>
fr: /* Avec SunOS 4 */
    B<int cfree(void *>I<ptr>B<);>

note: type: Plain text
en: /* In glibc or FreeBSD libcompat */
    B<void cfree(void *>I<ptr>B<);>
fr: /* Avec la glibc ou avec FreeBSD libcompat */
    B<void cfree(void *>I<ptr>B<);>

note: type: Plain text
en: /* In SCO OpenServer */
    B<void cfree(char *>I<ptr>B<, unsigned >I<num>B<, unsigned >I<size>B<);>
fr: /* Avec SCO OpenServer */
    B<void cfree(char *>I<ptr>B<, unsigned >I<num>B<, unsigned >I<size>B<);>

note: type: Plain text
en: /* In Solaris watchmalloc.so.1 */
    B<void cfree(void *>I<ptr>B<, size_t >I<nelem>B<, size_t >I<elsize>B<);>
fr: /* Dans Solaris watchmalloc.so.1 */
    B<void cfree(void *>I<ptr>B<, size_t >I<nelem>B<, size_t >I<elsize>B<);>

note: type: Plain text
en: B<cfree>(): _BSD_SOURCE || _SVID_SOURCE
fr: B<cfree>()\ : _BSD_SOURCE || _SVID_SOURCE

note: type: Plain text
en: This function should never be used.  Use B<free>(3)  instead.
fr: Cette fonction ne devrait jamais être utilisée. Utilisez B<free>(3) à la place.

note: type: SS
en: 1-arg cfree
fr: cfree avec un argument

note: type: Plain text
en: In glibc, the function B<cfree>()  is a synonym for B<free>(3), "added for compatibility with SunOS".
fr: Dans la glibc, la fonction B<cfree>() est un synonyme de B<free>(3), «\ ajoutée pour être compatible avec SunOS\ ».

note: type: Plain text
en: Other systems have other functions with this name.  The declaration is sometimes in I<E<lt>stdlib.hE<gt>> and sometimes in I<E<lt>malloc.hE<gt>>.
fr: D'autres systèmes ont d'autres fonctions du même nom. La déclaration se trouve parfois dans I<E<lt>stdlib.hE<gt>> et parfois dans I<E<lt>malloc.hE<gt>>.

note: type: SS
en: 3-arg cfree
fr: cfree avec trois arguments

note: type: Plain text
en: Some SCO and Solaris versions have malloc libraries with a 3-argument B<cfree>(), apparently as an analog to B<calloc>(3).
fr: Certaines versions de SCO et de Solaris ont des bibliothèques malloc avec une fonction B<cfree>() à 3 arguments, apparemment par analogie à B<calloc>(3).

note: type: Plain text
en: If you need it while porting something, add
fr: Si vous en avez besoin et que vous faites un portage, ajoutez

note: type: Plain text
en: to your file.
fr: dans votre fichier.

note: type: Plain text
en: A frequently asked question is "Can I use B<free>(3)  to free memory allocated with B<calloc>(3), or do I need B<cfree>()?" Answer: use B<free>(3).
fr: Une question fréquemment posée est\ : «\ Puis-je utiliser B<free>(3) pour libérer de la mémoire allouée avec B<calloc>(3), ou bien dois-je utiliser B<cfree>()\ ?\ ». La réponse est\ : utilisez B<free>(3).

note: type: Plain text
en: An SCO manual writes: "The cfree routine is provided for compliance to the iBCSe2 standard and simply calls free.  The num and size arguments to cfree are not used."
fr: Un manuel de SCO dit\ : «\ La routine cfree est fournie pour être conforme à la norme iBCSe2 et faciliter les appels de free. Les arguments num et size de cfree ne sont pas utilisés.\ »

note: type: Plain text
en: The SunOS version of B<cfree>()  (which is a synonym for B<free>(3))  returns 1 on success and 0 on failure.  In case of error, I<errno> is set to B<EINVAL>: the value of I<ptr> was not a pointer to a block previously allocated by one of the routines in the B<malloc>(3)  family.
fr: La version SunOS de B<cfree>() (qui est un synonyme de B<free>(3)) renvoie 1 si elle réussit et 0 si elle échoue. En cas d'erreur, I<errno> est positionnée à B<EINVAL>\ : la valeur de I<ptr> n'était pas un pointeur vers un bloc précédemment alloué par l'une des routines de la famille B<malloc>(3).

note: type: Plain text
en: The 3-argument version of B<cfree>()  as used by SCO conforms to the iBCSe2 standard: Intel386 Binary Compatibility Specification, Edition 2.
fr: La version à trois arguments de B<cfree>() est utilisée par SCO pour être conforme à la norme iBCSe2\ : «\ Intel386 Binary Compatibility Specification, Edition 2\ ».

note: type: TH
en: 2010-10-04
fr: 4 octobre 2010

note: type: Plain text
en: clearenv - clear the environment
fr: clearenv - Vider l'environnement

note: type: Plain text
en: B<clearenv>(): _SVID_SOURCE || _BSD_SOURCE
fr: B<clearenv>()\ : _SVID_SOURCE || _BSD_SOURCE

note: type: Plain text
en: The B<clearenv>()  function clears the environment of all name-value pairs and sets the value of the external variable I<environ> to NULL.
fr: La fonction B<clearenv>() efface de l'environnement toutes les paires «\ nom-valeur\ » et définit la variable externe I<environ> à NULL.

note: Most versions of UNIX return -1 on error, or do not even have errors. Glibc info and the Watcom C library document "a nonzero value". type: Plain text
en: The B<clearenv>()  function returns zero on success, and a nonzero value on failure.
fr: La fonction B<clearenv>() renvoie zéro en cas de succès et une valeur non nulle en cas d'échec.

note: type: Plain text
en: Not in libc4, libc5.  In glibc since glibc 2.0.
fr: Absente de la libc4 et de la libc5. Présente dans la glibc depuis la version\ 2.0.

note: type: Plain text
en: Various UNIX variants (DG/UX, HP-UX, QNX, ...).  POSIX.9 (bindings for FORTRAN77).  POSIX.1-1996 did not accept B<clearenv>()  and B<putenv>(3), but changed its mind and scheduled these functions for some later issue of this standard (cf. B.4.6.1).  However, POSIX.1-2001 adds only B<putenv>(3), and rejected B<clearenv>().
fr: Diverses variantes d'UNIX (DG/UX, HP-UX, QNX, ...). POSIX.9 (binding pour FORTRAN77). POSIX.1-1996 ne définissait pas B<clearenv>() et B<putenv>(3), mais, suite à un changement d'attitude, ces fonctions ont été programmées pour les versions futures de ce standard (cf. B.4.6.1). Néanmoins, POSIX.1-2001 ajouta seulement B<putenv>(3), et refusa B<clearenv>().

note: type: Plain text
en: Used in security-conscious applications.  If it is unavailable the assignment
fr: Cette fonction est utilisée dans les applications sensibilisées à la sécurité. Si elle n'est pas disponible, l'affectation

note: type: Plain text
en: will probably do.
fr: rendra sans doute le même service.

note: .LP HP-UX has a ENOMEM error return. type: Plain text
en: The DG/UX and Tru64 man pages write: If I<environ> has been modified by anything other than the B<putenv>(3), B<getenv>(3), or B<clearenv>()  functions, then B<clearenv>()  will return an error and the process environment will remain unchanged.
fr: Les pages de manuel DG/UX et Tru64 indiquent\ : si I<environ> a été modifiée par autre chose que les fonctions B<putenv>(3), B<getenv>(3), et B<clearenv>(), alors B<clearenv>() renverra une erreur et l'environnement du processus sera inchangé.

note: type: Plain text
en: drand48, erand48, lrand48, nrand48, mrand48, jrand48, srand48, seed48, lcong48 - generate uniformly distributed pseudo-random numbers
fr: drand48, erand48, lrand48, nrand48, mrand48, jrand48, srand48, seed48, lcong48 - Générer de nombres pseudoaléatoires uniformément distribués

note: .BR drand48 (), .BR erand48 (), .BR lrand48 (), .BR nrand48 (), .BR mrand48 (), .BR jrand48 (), .BR srand48 (), .BR seed48 (), .BR lcong48 (): type: Plain text
en: All functions shown above: _SVID_SOURCE || _XOPEN_SOURCE
fr: Pour toutes les fonctions ci-dessus\ : _SVID_SOURCE || _XOPEN_SOURCE

note: type: Plain text
en: These functions generate pseudo-random numbers using the linear congruential algorithm and 48-bit integer arithmetic.
fr: Ces fonctions génèrent des nombres pseudoaléatoires en utilisant un algorithme de congruence linéaire, et une arithmétique entière sur 48\ bits.

note: type: Plain text
en: The B<drand48>()  and B<erand48>()  functions return nonnegative double-precision floating-point values uniformly distributed between [0.0, 1.0).
fr: Les fonctions B<drand48>() et B<erand48>() renvoient des valeurs positives en virgule flottante double précision, uniformément distribuées dans l'intervalle [0.0, 1.0[.

note: type: Plain text
en: The B<lrand48>()  and B<nrand48>()  functions return nonnegative long integers uniformly distributed between 0 and 2^31.
fr: Les fonctions B<lrand48>() et B<nrand48>() renvoient des entiers longs positifs, uniformément distribués entre 0 et 2^31.

note: type: Plain text
en: The B<mrand48>()  and B<jrand48>()  functions return signed long integers uniformly distributed between -2^31 and 2^31.
fr: Les fonctions B<mrand48>() et B<jrand48>() renvoient des entiers longs signés, uniformément distribués entre -2^31 et 2^31.

note: type: Plain text
en: The B<srand48>(), B<seed48>()  and B<lcong48>()  functions are initialization functions, one of which should be called before using B<drand48>(), B<lrand48>()  or B<mrand48>().  The functions B<erand48>(), B<nrand48>()  and B<jrand48>()  do not require an initialization function to be called first.
fr: Les fonctions B<srand48>(), B<seed48>() et B<lcong48>() sont des fonctions d'initialisation. L'une d'entre elles doit être appelée avant d'utiliser les fonctions B<drand48>(), B<lrand48>() ou B<mrand48>(). Les fonctions B<erand48>(), B<nrand48>() et B<jrand48>() ne nécessitent pas de fonction d'initialisation.

note: type: Plain text
en: All the functions work by generating a sequence of 48-bit integers, I<Xi>, according to the linear congruential formula:
fr: Toutes ces fonctions engendrent une séquence d'entiers I<Xi>, sur 48\ bits, suivant la formule de congruence linéaire\ :

note: type: Plain text
en: B<Xn+1 = (aXn + c) mod m, where n E<gt>= 0>
fr: B<Xn+1 = (aXn + c) mod m, avec n E<gt>= 0>

note: type: Plain text
en: The parameter I<m> = 2^48, hence 48-bit integer arithmetic is performed.  Unless B<lcong48>()  is called, I<a> and I<c> are given by:
fr: Le paramètre I<m> vaut 2^48, ainsi l'arithmétique entière sur 48\ bits est respectée. Tant que B<lcong48>() n'est pas appelé, I<a> et I<c> valent\ :

note: type: Plain text
en: The value returned by any of the functions B<drand48>(), B<erand48>(), B<lrand48>(), B<nrand48>(), B<mrand48>()  or B<jrand48>()  is computed by first generating the next 48-bit I<Xi> in the sequence.  Then the appropriate number of bits, according to the type of data item to be returned, is copied from the high-order bits of I<Xi> and transformed into the returned value.
fr: Les valeurs renvoyées par les fonctions B<drand48>(), B<erand48>(), B<lrand48>(), B<nrand48>(), B<mrand48>() ou B<jrand48>() sont calculées en générant les I<Xi> suivant sur 48\ bits dans la séquence. Ensuite, le nombre de bits approprié au type de la valeur de retour est copié en partant des bits de poids forts de I<Xi>, et convertit dans la valeur renvoyée.

note: type: Plain text
en: The functions B<drand48>(), B<lrand48>()  and B<mrand48>()  store the last 48-bit I<Xi> generated in an internal buffer.  The functions B<erand48>(), B<nrand48>()  and B<jrand48>()  require the calling program to provide storage for the successive I<Xi> values in the array argument I<xsubi>.  The functions are initialized by placing the initial value of I<Xi> into the array before calling the function for the first time.
fr: Les fonctions B<drand48>(), B<lrand48>() et B<mrand48>() mémorisent le dernier I<Xi> sur 48\ bits créé dans un tampon interne. Les fonctions B<erand48>(), B<nrand48>() et B<jrand48>() nécessitent que le programme appelant fournisse un emplacement de stockage pour les valeurs successives de I<Xi>. Cet emplacement est le tableau correspondant à l'argument I<xsubi>. Ces fonctions sont initialisées en plaçant la valeur initiale de I<Xi> dans le tableau avant le premier appel.

note: type: Plain text
en: The initializer function B<srand48>()  sets the high order 32-bits of I<Xi> to the argument I<seedval>.  The low order 16-bits are set to the arbitrary value 0x330E.
fr: La fonction d'initialisation B<srand48>() définit les 32\ bits de poids fort de I<Xi> avec l'argument I<seedval>. Les 16\ bits de poids faibles sont initialisés avec la valeur arbitraire 0x330E.

note: type: Plain text
en: The initializer function B<seed48>()  sets the value of I<Xi> to the 48-bit value specified in the array argument I<seed16v>.  The previous value of I<Xi> is copied into an internal buffer and a pointer to this buffer is returned by B<seed48>().
fr: La fonction d'initialisation B<seed48>() définit la valeur de I<Xi> comme la valeur spécifiée dans le tableau I<seed16v>. La précédente valeur de I<Xi> est copiée dans un tampon interne et un pointeur vers ce tampon est renvoyé par B<seed48>().

note: type: Plain text
en: The initialization function B<lcong48>()  allows the user to specify initial values for I<Xi>, I<a> and I<c>.  Array argument elements I<param[0-2]> specify I<Xi>, I<param[3-5]> specify I<a>, and I<param[6]> specifies I<c>.  After B<lcong48>()  has been called, a subsequent call to either B<srand48>()  or B<seed48>()  will restore the standard values of I<a> and I<c>.
fr: La fonction d'initialisation B<lcong48>() permet à l'utilisateur de définir des valeurs initiales de I<Xi>, I<a> et I<c>. Les éléments I<param[0-2]> du tableau spécifient I<Xi>, I<param[3-5]> spécifient I<a> et I<param[6]> spécifie I<c>. Après un appel à B<lcong48>(), un appel ultérieur à B<srand48>() ou à B<seed48>() rétablira les valeurs normales de I<a> et I<c>.

note: type: Plain text
en: The B<drand48>(), B<erand48>(), B<lrand48>(), B<nrand48>(), B<mrand48>(), B<jrand48>(), B<srand48>(), B<seed48>(), and B<lcong48>()  functions record global state information for the random number generator, so they are not thread-safe.
fr: Les fonctions B<drand48>(), B<erand48>(), B<lrand48>(), B<nrand48>(), B<mrand48>(), B<jrand48>(), B<srand48>(), B<seed48>() et B<lcong48>() ne sont pas sûres dans un contexte multithread car elles enregistrent globalement l'état du générateur de nombre aléatoire.

note: type: Plain text
en: These functions are declared obsolete by SVID 3, which states that B<rand>(3)  should be used instead.
fr: Ces fonctions sont déclarées obsolètes par SVID\ 3, qui indique que B<rand>(3) devrait être utilisée à la place.

note: type: TH
en: 2013-09-09
fr: 9 septembre 2013

note: type: Plain text
en: drand48_r, erand48_r, lrand48_r, nrand48_r, mrand48_r, jrand48_r, srand48_r, seed48_r, lcong48_r - generate uniformly distributed pseudo-random numbers reentrantly
fr: drand48_r, erand48_r, lrand48_r, nrand48_r, mrand48_r, jrand48_r, srand48_r, seed48_r, lcong48_r - Générer des nombres pseudoaléatoires uniformément distribués de façon réentrante

note: .BR drand48_r (), .BR erand48_r (), .BR lrand48_r (), .BR nrand48_r (), .BR mrand48_r (), .BR jrand48_r (), .BR srand48_r (), .BR seed48_r (), .BR lcong48_r (): type: Plain text
en: All functions shown above: _SVID_SOURCE || _BSD_SOURCE || _XOPEN_SOURCE
fr: Pour toutes les fonctions ci-dessus\ : _SVID_SOURCE || _BSD_SOURCE || _XOPEN_SOURCE

note: type: Plain text
en: These functions are the reentrant analogs of the functions described in B<drand48>(3).  Instead of modifying the global random generator state, they use the supplied data I<buffer>.
fr: Ces fonctions sont les versions réentrantes des fonctions décrites dans B<drand48>(3). Au lieu de modifier l'état global du générateur aléatoire, elles utilisent les données fournies par I<buffer>.

note: type: Plain text
en: Before the first use, this struct must be initialized, for example, by filling it with zeros, or by calling one of the functions B<srand48_r>(), B<seed48_r>(), or B<lcong48_r>().
fr: Avant de les utiliser, cette structure doit être initialisée, par exemple, en la remplissant de 0, ou en appelant l'une des fonctions B<srand48_r>(), B<seed48_r>() ou B<lcong48_r>().

note: type: Plain text
en: The return value is 0.
fr: La valeur renvoyée est 0.

note: type: Plain text
en: The B<drand48_r>(), B<erand48_r>(), B<lrand48_r>(), B<nrand48_r>(), B<mrand48_r>(), B<jrand48_r>(), B<srand48_r>(), B<seed48_r>(), and B<lcong48_r>()  functions are thread-safe.
fr: Les fonctions B<drand48_r>(), B<erand48_r>(), B<lrand48_r>(), B<nrand48_r>(), B<mrand48_r>(), B<jrand48_r>(), B<srand48_r>(), B<seed48_r>() et B<lcong48_r>() sont sûres dans un contexte multithread.

note: type: Plain text
en: These functions are GNU extensions and are not portable.
fr: Ces fonctions sont des extensions GNU et ne sont pas portables.

note: type: TH
en: 2013-07-04
fr: 4 juillet 2013

note: type: Plain text
en: ecvt, fcvt - convert a floating-point number to a string
fr: ecvt, fcvt - Convertir des nombres réels en chaînes de caractères

note: type: Plain text
en: B<ecvt>(), B<fcvt>():
fr: B<ecvt>(), B<fcvt>() :

note: type: TP
en: Since glibc 2.12:
fr: Depuis la glibc 2.12 :

note: type: TP
en: Before glibc 2.12:
fr: Avant la glibc 2.12 :

note: type: Plain text
en: The B<ecvt>()  function converts I<number> to a null-terminated string of I<ndigits> digits (where I<ndigits> is reduced to a system-specific limit determined by the precision of a I<double>), and returns a pointer to the string.  The high-order digit is nonzero, unless I<number> is zero.  The low order digit is rounded.  The string itself does not contain a decimal point; however, the position of the decimal point relative to the start of the string is stored in I<*decpt>.  A negative value for I<*decpt> means that the decimal point is to the left of the start of the string.  If the sign of I<number> is negative, I<*sign> is set to a nonzero value, otherwise it is set to 0.  If I<number> is zero, it is unspecified whether I<*decpt> is 0 or 1.
fr: La fonction B<ecvt>() convertit I<number> en une chaîne de caractères terminée par un caractère nul, de I<ndigits> chiffres (I<ndigits> étant limité par une valeur spécifique au système, déterminée par la précision d'un I<double>). La fonction renvoie un pointeur sur cette chaîne. Le chiffre d'ordre le plus élevé est non nul, sauf si I<number> vaut zéro. Le chiffre d'ordre le plus faible est arrondi. La chaîne elle-même ne contient pas de point décimal, néanmoins la position du point décimal relativement au début de la chaîne est stockée dans I<*decpt>. Une valeur négative de I<*decpt> signifie que le point décimal est à gauche du début de la chaîne. Si le signe de I<number> est négatif, I<*sign> est défini avec une valeur non nulle, sinon il est mis à 0. Si I<number> est nul, il n'est pas précisé si I<*decpt> vaut zéro ou un.

note: type: Plain text
en: The B<fcvt>()  function is identical to B<ecvt>(), except that I<ndigits> specifies the number of digits after the decimal point.
fr: La fonction B<fcvt>() est identique à B<ecvt>(), à la différence que I<ndigits> indique le nombre de décimales après la virgule.

note: type: Plain text
en: Both the B<ecvt>()  and B<fcvt>()  functions return a pointer to a static string containing the ASCII representation of I<number>.  The static string is overwritten by each call to B<ecvt>()  or B<fcvt>().
fr: Les deux fonctions B<ecvt>() et B<fcvt>() renvoient un pointeur sur une chaîne de caractères statique contenant la représentation ASCII de I<number>. La chaîne statique est écrasée à chaque appel de B<ecvt>() ou B<fcvt>().

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

note: type: Plain text
en: SVr2; marked as LEGACY in POSIX.1-2001.  POSIX.1-2008 removes the specifications of B<ecvt>()  and B<fcvt>(), recommending the use of B<sprintf>(3)  instead (though B<snprintf>(3)  may be preferable).
fr: SVr2, marqué comme «\ LEGACY\ » dans POSIX.1-2001. POSIX.1-2008 supprime les spécifications de B<ecvt>() et B<fcvt>() et recommande à la place l'utilisation de B<sprintf>(3) (bien que B<snprintf>(3) soit préférable).

note: type: Plain text
en: Linux libc4 and libc5 specified the type of I<ndigits> as I<size_t>.  Not all locales use a point as the radix character ("decimal point").
fr: Les bibliothèques Linux, libc4 et libc5, déclaraient le type de I<ndigits> en I<size_t> et certaines localisations n'utilisent pas le point comme séparateur décimal.

note: type: Plain text
en: ecvt_r, fcvt_r, qecvt_r, qfcvt_r - convert a floating-point number to a string
fr: ecvt_r, fcvt_r, qecvt_r, qfcvt_r - Convertir un nombre flottant en chaîne de caractères

note: type: Plain text
en: B<ecvt_r>(), B<fcvt_r>(), B<qecvt_r>(), B<qfcvt_r>():
fr: B<ecvt_r>(), B<fcvt_r>(), B<qecvt_r>(), B<qfcvt_r>() :

note: type: Plain text
en: The functions B<ecvt_r>(), B<fcvt_r>(), B<qecvt_r>()  and B<qfcvt_r>()  are identical to B<ecvt>(3), B<fcvt>(3), B<qecvt>(3)  and B<qfcvt>(3), respectively, except that they do not return their result in a static buffer, but instead use the supplied I<buf> of size I<len>.  See B<ecvt>(3)  and B<qecvt>(3).
fr: Les fonctions B<ecvt_r>(), B<fcvt_r>(), B<qecvt_r>() et B<qfcvt_r>() sont respectivement identiques à B<ecvt>(3), B<fcvt>(3), B<qecvt>(3) et B<qfcvt>(3), sauf qu'elles ne renvoient pas leurs résultats dans un tampon statique, mais utilisent à la place le tampon spécifié, I<buf> de longueur I<len>. Consultez B<ecvt>(3) et B<qecvt>(3).

note: type: Plain text
en: These functions return 0 on success, and -1 otherwise.
fr: Ces fonctions renvoient 0 si elles réussissent, -1 sinon.

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

note: type: Plain text
en: These functions are obsolete.  Instead, B<sprintf>(3)  is recommended.
fr: Ces fonctions sont obsolètes. L'utilisation de B<sprintf>(3) est recommandée à la place de ces fonctions.

note: type: TH
en: 2014-03-25
fr: 25 mars 2014

note: type: Plain text
en: exit - cause normal process termination
fr: exit - Terminer normalement un processus

note: type: Plain text
en: The B<exit>()  function causes normal process termination and the value of I<status & 0377> is returned to the parent (see B<wait>(2)).
fr: La fonction B<exit>() termine normalement un processus et la valeur I<status & 0377> est envoyée au processus parent (consultez B<wait>(2)).

note: type: Plain text
en: All functions registered with B<atexit>(3)  and B<on_exit>(3)  are called, in the reverse order of their registration.  (It is possible for one of these functions to use B<atexit>(3)  or B<on_exit>(3)  to register an additional function to be executed during exit processing; the new registration is added to the front of the list of functions that remain to be called.)  If one of these functions does not return (e.g., it calls B<_exit>(2), or kills itself with a signal), then none of the remaining functions is called, and further exit processing (in particular, flushing of B<stdio>(3)  streams) is abandoned.  If a function has been registered multiple times using B<atexit>(3)  or B<on_exit>(3), then it is called as many times as it was registered.
fr: Toutes les fonctions enregistrées avec B<atexit>(3) et B<on_exit>(3) sont appelées dans l'ordre inverse de leur enregistrement. Il est possible pour l'une de ces fonctions d'utiliser B<atexit>(3) ou B<on_exit>(3) pour enregistrer une fonction supplémentaire à exécuter lors de la procédure de terminaison\ ; le nouvel enregistrement est ajouté au début de la liste des fonctions à appeler. Si l'une de ces fonctions ne rend pas la main (par exemple, car elle appelle B<_exit>(2) ou se tue avec un signal), alors aucune des fonctions suivantes de la liste n'est exécutée et le processus de terminaison est abandonné (en particulier, le vidage des flux B<stdio>(3)). Si une fonction a été enregistrée plusieurs fois avec B<atexit>(3) ou B<on_exit>(3), alors elle sera appelée aussi souvent qu'elle a été enregistrée.

note: type: Plain text
en: All open B<stdio>(3)  streams are flushed and closed.  Files created by B<tmpfile>(3)  are removed.
fr: Tous les flux ouverts du type B<stdio>(3) sont vidés et fermés. Les fichiers créés par B<tmpfile>(3) sont supprimés.

note: type: Plain text
en: The C standard specifies two constants, B<EXIT_SUCCESS> and B<EXIT_FAILURE>, that may be passed to B<exit>()  to indicate successful or unsuccessful termination, respectively.
fr: Le standard C spécifie deux constantes symboliques B<EXIT_SUCCESS> et B<EXIT_FAILURE> qui peuvent être passées à B<exit>() pour indiquer respectivement une terminaison sans ou avec échec.

note: type: Plain text
en: The B<exit>()  function does not return.
fr: La fonction B<exit>() ne revient jamais.

note: type: Plain text
en: The B<exit>()  function uses a global variable that is not protected, so it is not thread-safe.
fr: La fonction B<exit>() utilise une variable globale non protégée, et n’est donc pas sûre dans un contexte multithread.

note: type: Plain text
en: SVr4, 4.3BSD, POSIX.1-2001, C89, C99.
fr: SVr4, BSD\ 4.3, POSIX.1-2001, C89, C99

note: type: Plain text
en: It is undefined what happens if one of the functions registered using B<atexit>(3)  and B<on_exit>(3)  calls either B<exit>()  or B<longjmp>(3).  Note that a call to B<execve>(2)  removes registrations created using B<atexit>(3)  and B<on_exit>(3).
fr: Le résultat est indéfini si l'une des fonctions enregistrées avec B<atexit>(3) et B<on_exit>(3) appelle B<exit>() ou B<longjmp>(3). Remarquez qu'un appel d'B<execve>(2) supprime les enregistrements créés en utilisant B<atexit>(3) et B<on_exit>(3).

note: type: Plain text
en: The use of B<EXIT_SUCCESS> and B<EXIT_FAILURE> is slightly more portable (to non-UNIX environments) than the use of 0 and some nonzero value like 1 or -1.  In particular, VMS uses a different convention.
fr: L'utilisation d'B<EXIT_SUCCESS> et B<EXIT_FAILURE> est légèrement plus portable (vers des environnements non UNIX) que celle de zéro et d'une valeur non nulle comme 1 ou -1. En particulier, le système VMS utilise une convention différente.

note: type: Plain text
en: BSD has attempted to standardize exit codes; see the file I<E<lt>sysexits.hE<gt>>.
fr: BSD a tenté de standardiser les codes de sortie, consultez le fichier I<E<lt>sysexits.hE<gt>>.

note: type: Plain text
en: After B<exit>(), the exit status must be transmitted to the parent process.  There are three cases.  If the parent has set B<SA_NOCLDWAIT>, or has set the B<SIGCHLD> handler to B<SIG_IGN>, the status is discarded.  If the parent was waiting on the child, it is notified of the exit status.  In both cases the exiting process dies immediately.  If the parent has not indicated that it is not interested in the exit status, but is not waiting, the exiting process turns into a "zombie" process (which is nothing but a container for the single byte representing the exit status) so that the parent can learn the exit status when it later calls one of the B<wait>(2)  functions.
fr: Après B<exit>(), le code de retour doit être transmis au processus parent. Il y a trois cas. Si le parent a défini B<SA_NOCLDWAIT> ou s'il a défini le comportement de B<SIGCHLD> à B<SIG_IGN>, le code de retour est ignoré. Si le père était en attente de la fin de son fils, il reçoit le code de retour. Dans ces deux cas, le fils meurt immédiatement. Si le parent n'est pas en attente, mais n'a pas indiqué qu'il désire ignorer le code de retour, le processus fils devient un processus «\ zombie\ » (ce n'est rien d'autre qu'une coquille enveloppant le code de retour d'un octet), que le processus père pourra consultez ultérieurement grâce à l'une des fonctions B<wait>(2).

note: type: Plain text
en: If the implementation supports the B<SIGCHLD> signal, this signal is sent to the parent.  If the parent has set B<SA_NOCLDWAIT>, it is undefined whether a B<SIGCHLD> signal is sent.
fr: Si l'implémentation supporte le signal B<SIGCHLD>, celui-ci est envoyé au processus père. Si le père a défini B<SA_NOCLDWAIT>, il n'est pas précisé si B<SIGCHLD> est envoyé ou non.

note: type: Plain text
en: If the process is a session leader and its controlling terminal is the controlling terminal of the session, then each process in the foreground process group of this controlling terminal is sent a B<SIGHUP> signal, and the terminal is disassociated from this session, allowing it to be acquired by a new controlling process.
fr: Si le processus est un leader de session, et si son terminal de contrôle est le terminal de la session, alors chaque processus du groupe de processus en avant plan de ce terminal reçoit un signal B<SIGHUP>, et le terminal est dissocié de cette session, lui permettant d'être acquis par un nouveau processus de contrôle.

note: type: Plain text
en: If the exit of the process causes a process group to become orphaned, and if any member of the newly orphaned process group is stopped, then a B<SIGHUP> signal followed by a B<SIGCONT> signal will be sent to each process in this process group.  See B<setpgid>(2)  for an explanation of orphaned process groups.
fr: Si la fin du processus rend orphelin un groupe de processus, et si certains membres de ce groupe nouvellement orphelin sont arrêtés, alors tous les processus de ce groupe vont recevoir B<SIGHUP> suivi de B<SIGCONT>. Consultez B<setpgid>(2) pour plus d'informations sur les processus orphelins.

note: type: Plain text
en: gcvt - convert a floating-point number to a string
fr: gcvt - Conversion d'un réel en chaîne de caractères

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

note: type: Plain text
en: The B<gcvt>()  function converts I<number> to a minimal length null-terminated ASCII string and stores the result in I<buf>.  It produces I<ndigit> significant digits in either B<printf>(3)  F format or E format.
fr: La fonction B<gcvt>() convertit le réel I<number> en une chaîne de caractères de longueur minimale, et terminée par un caractère nul. Le résultat est stocké dans I<buf>. Elle produit I<ndigit> chiffres significatifs soit avec le format «\ F\ » de B<printf>(3), soit avec le format «\ E\ ».

note: type: Plain text
en: The B<gcvt>()  function returns the address of the string pointed to by I<buf>.
fr: La fonction B<gcvt>() renvoie l'adresse de la chaîne de caractères pointée par I<buf>.

note: type: Plain text
en: Marked as LEGACY in POSIX.1-2001.  POSIX.1-2008 removes the specification of B<gcvt>(), recommending the use of B<sprintf>(3)  instead (though B<snprintf>(3)  may be preferable).
fr: Marquée « LEGACY » dans POSIX.1-2001. POSIX.1-2008 supprime la spécification de B<gcvt>() et recommande à la place l'utilisation de B<sprintf>(3) (bien que B<snprintf>(3) soit préférable).

note: type: TH
en: 2014-04-08
fr: 8 avril 2014

note: type: Plain text
en: getauxval - retrieve a value from the auxiliary vector
fr: getauxval - Récupérer une valeur du vecteur auxiliaire

note: type: Plain text
en: The B<getauxval>()  function retrieves values from the auxiliary vector, a mechanism that the kernel's ELF binary loader uses to pass certain information to user space when a program is executed.
fr: La fonction B<getauxval>() récupère des valeurs du vecteur auxiliaire, un mécanisme que le chargeur de binaires ELF du noyau utilise pour passer certains renseignements à l'espace utilisateur quand un programme est exécuté.

note: type: Plain text
en: Each entry in the auxiliary vector consists of a pair of values: a type that identifies what this entry represents, and a value for that type.  Given the argument I<type>, B<getauxval>()  returns the corresponding value.
fr: Toutes les entrées du vecteur auxiliaire sont des paires de valeurs : un type qui identifie ce que l'entrée représente, et une valeur pour ce type. En fonction de l'argument I<type>, B<getauxval>() renvoie la valeur correspondante.

note: type: Plain text
en: The value returned for each I<type> is given in the following list.  Not all I<type> values are present on all architectures.
fr: Les valeurs renvoyées pour tous les types sont données dans la liste suivante. Les différentes valeurs de I<type> ne sont pas toutes présentes suivant l'architecture.

note: type: Plain text
en: The base address of the program interpreter (usually, the dynamic linker).
fr: L'adresse de base de l'interpréteur du programme (l'éditeur de liens dynamique en général).

note: type: Plain text
en: A string identifying the real platform; may differ from B<AT_PLATFORM> (PowerPC only).
fr: Une chaîne identifiant la plateforme réelle ; peut être différente de B<AT_PLATFORM> (PowerPC seulement).

note: type: Plain text
en: The frequency with which B<times>(2)  counts.  This value can also be obtained via I<sysconf(_SC_CLK_TCK)>.
fr: La fréquence utilisée par B<times>(2) pour compter. Cette valeur peut aussi être obtenue avec I<sysconf(_SC_CLK_TCK)>.

note: type: Plain text
en: The data cache block size.
fr: La taille du bloc de cache de données.

note: type: Plain text
en: The effective group ID of the thread.
fr: Le GID effectif du thread.

note: type: Plain text
en: The entry address of the executable.
fr: L'adresse d'entrée de l'exécutable.

note: type: Plain text
en: The effective user ID of the thread.
fr: L'UID effectif du thread.

note: type: Plain text
en: File descriptor of program.
fr: Le descripteur de fichier du programme.

note: type: Plain text
en: Pathname used to execute program.
fr: Le nom de chemin utilisé pour exécuter le programme.

note: type: Plain text
en: Flags (unused).
fr: Les attributs (inutilisé).

note: type: Plain text
en: Used FPU control word (SuperH architecture only).  This gives some information about the FPU initialization performed by the kernel.
fr: Le mot de contrôle FPU utilisé (architecture SuperH seulement). Cela donne quelques renseignements sur l'initialisation FPU réalisée par le noyau.

note: type: Plain text
en: The real group ID of the thread.
fr: Le GID réel du thread.

note: type: Plain text
en: A pointer to a multibyte mask of bits whose settings indicate detailed processor capabilities.  The contents of the bit mask are hardware dependent (for example, see the kernel source file I<arch/x86/include/asm/cpufeature.h> for details relating to the Intel x86 architecture).  A human-readable version of the same information is available via I</proc/cpuinfo>.
fr: Un pointeur vers un masque multioctet de bits dont les réglages indiquent des capacités processeurs détaillées. Le contenu du masque de bits dépend du matériel (consultez par exemple le fichier I<arch/x86/include/asm/cpufeature.h> des sources du noyau pour obtenir des précisions sur l'architecture x86). Une version lisible des mêmes renseignements est disponible dans I</proc/cpuinfo>.

note: .TP .BR AT_IGNORE .BR AT_IGNOREPPC .BR AT_NOTELF type: Plain text
en: The instruction cache block size.
fr: La taille du bloc de cache d'instructions.

note: type: Plain text
en: The system page size (the same value returned by I<sysconf(_SC_PAGESIZE)>).
fr: La taille de page du système (la même valeur que celle renvoyée par I<sysconf(_SC_PAGESIZE)>).

note: type: Plain text
en: The address of the program headers of the executable.
fr: L'adresse des en-têtes du programme de l'exécutable.

note: type: Plain text
en: The size of program header entry.
fr: La taille de l'entrée des en-têtes du programme.

note: type: Plain text
en: The number of program headers.
fr: Le nombre d'en-têtes du programme.

note: type: Plain text
en: A pointer to a string that identifies the hardware platform that the program is running on.  The dynamic linker uses this in the interpretation of I<rpath> values.
fr: Un pointeur vers une chaîne qui identifie la plate-forme matérielle sur laquelle le programme est exécuté. L'éditeur de liens dynamique utilise cela dans l'interprétation des valeurs I<rpath>.

note: type: Plain text
en: The address of sixteen bytes containing a random value.
fr: L'adresse de seize octets contenant une valeur aléatoire.

note: type: Plain text
en: Has a nonzero value if this executable should be treated securely.  Most commonly, a nonzero value indicates that the process is executing a set-user-ID or set-group-ID program; alternatively, a nonzero value may be triggered by a Linux Security Module.  When this value is nonzero, the dynamic linker disables the use of certain environment variables (see B<ld-linux.so>(8))  and glibc changes other aspects of its behavior.  (See also B<secure_getenv>(3).)
fr: Une valeur non nulle si l'exécutable devrait être traité de façon sécurisée. Le plus souvent, une valeur non nulle indique que le processus exécute un programme Set-UID ou Set-GID ; sinon, une valeur non nulle pourrait être provoquée par un module de sécurité Linux. Quand cette valeur est non nulle, l'éditeur de liens dynamique désactive l'utilisation de certaines variables d'environnement (consultez B<ld-linux.so>(8)) et glibc modifie d'autres facettes de son comportement (consultez aussi B<secure_getenv>(3)).

note: type: Plain text
en: The entry point to the system call function in the vDSO.  Not present/needed on all architectures (e.g., absent on x86-64).
fr: Le point d'entrée vers la fonction d'appel système dans le vDSO. N'est ni présent ni nécessaire sur toutes les architectures (par exemple absent sur x86-64).

note: type: Plain text
en: The address of a page containing the virtual Dynamic Shared Object (vDSO)  that the kernel creates in order to provide fast implementations of certain system calls.
fr: L'adresse d'une page contenant le vDSO (objet partagé dynamique virtuel, « virtual dynamic shared object ») que le noyau crée pour fournir des implémentations rapides de certains appels systèmes.

note: type: Plain text
en: The unified cache block size.
fr: La taille du bloc de cache unifié.

note: type: Plain text
en: The real user ID of the thread.
fr: L'UID réel du thread.

note: type: Plain text
en: On success, B<getauxval>()  returns the value corresponding to I<type>.  If I<type> is not found, 0 is returned.
fr: Si elle réussit, B<getauxval>() renvoie la valeur correspondant au I<type>. Si I<type> n'est pas trouvé, 0 est renvoyé.

note: type: Plain text
en: No errors are diagnosed.
fr: Aucune erreur n'est diagnostiquée.

note: type: Plain text
en: The B<getauxval>()  function was added to glibc in version 2.16.
fr: La fonction B<getauxval>() est disponible depuis la glibc 2.16.

note: type: Plain text
en: The B<getauxval>()  function is thread-safe.
fr: La fonction B<getauxval>() est sûre dans un contexte multithread.

note: type: Plain text
en: This function is a nonstandard glibc extension.
fr: Cette fonction est une extension non normalisée de la glibc.

note: type: Plain text
en: The primary consumer of the information in the auxiliary vector is the dynamic linker B<ld-linux.so>(8).  The auxiliary vector is a convenient and efficient shortcut that allows the kernel to communicate a certain set of standard information that the dynamic linker usually or always needs.  In some cases, the same information could be obtained by system calls, but using the auxiliary vector is cheaper.
fr: Le principal utilisateur des renseignements du vecteur auxiliaire est l'éditeur de liens dynamique B<ld-linux.so>(8). Le vecteur auxiliaire est un raccourci pratique et efficace qui permet au noyau de communiquer un certain jeu de renseignements standards dont l'éditeur de liens a souvent ou toujours besoin. Dans certains cas, les mêmes renseignements pourraient être obtenus à l'aide d'appels système, mais l'utilisation du vecteur auxiliaire est moins coûteuse.

note: type: Plain text
en: The auxiliary vector resides just above the argument list and environment in the process address space.  The auxiliary vector supplied to a program can be viewed by setting the B<LD_SHOW_AUXV> environment variable when running a program:
fr: Le vecteur auxiliaire réside juste au-dessus de la liste d'arguments et de l'environnement dans l'espace d'adresse du processus. Le vecteur auxiliaire fourni à un programme peut être affiché en définissant la variable d'environnement B<LD_SHOW_AUXV> lors de l'exécution d'un programme :

note: type: Plain text
en: The auxiliary vector of any process can (subject to file permissions)  be obtained via I</proc/PID/auxv>; see B<proc>(5)  for more information.
fr: Le vecteur auxiliaire de n'importe quel processus peut (en fonction des droits du fichier) être obtenu dans I</proc/PID/auxv>. Consultez B<proc>(5) pour obtenir de plus amples renseignements.

note: type: TH
en: 2012-08-14
fr: 14 août 2012

note: type: Plain text
en: getenv, secure_getenv - get an environment variable
fr: getenv, secure_getenv - Lire une variable d'environnement

note: type: Plain text
en: The B<getenv>()  function searches the environment list to find the environment variable I<name>, and returns a pointer to the corresponding I<value> string.
fr: La fonction B<getenv>() recherche dans la liste des variables d'environnement une variable nommée I<name>, et renvoie un pointeur sur la chaîne I<value> correspondante.

note: type: Plain text
en: The GNU-specific B<secure_getenv>()  function is just like B<getenv>()  except that it returns NULL in cases where "secure execution" is required.  Secure execution is required if one of the following conditions was true when the program run by the calling process was loaded:
fr: La fonction B<secure_getenv>() spécifique à GNU est simplement comme B<getenv>(), à la différence qu'elle renvoie NULL dans les cas où « secure execution » (exécution sécurisée) est nécessaire. L'exécution sécurisée est nécessaire si l'une des conditions suivantes était vraie quand le programme exécuté pour le processus appelant a été chargé :

note: type: Plain text
en: the process's effective user ID did not match its real user ID or the process's effective group ID did not match its real group ID (typically this is the result of executing a set-user-ID or set-group-ID program);
fr: l'UID effectif du processus ne correspondait pas son UID réel, ou le GID effectif du processus ne correspondait pas son GID réel (c'est typiquement le cas lors de l'exécution d'un programme Set-UID ou Set-GID) ;

note: type: Plain text
en: the effective capability bit was set on the executable file; or
fr: le bit de capacité effective a été défini sur le fichier exécutable ;

note: type: Plain text
en: the process has a nonempty permitted capability set.
fr: le processus a une capacité non vide permise définie.

note: type: Plain text
en: Secure execution may also required if triggered by some Linux security modules.
fr: L'exécution sécurisée pourrait aussi être nécessaire si elle est déclenchée par certains modules de sécurité Linux.

note: type: Plain text
en: The B<secure_getenv>()  function is intended for use in general-purpose libraries to avoid vulnerabilities that could occur if set-user-ID or set-group-ID programs accidentally trusted the environment.
fr: La fonction B<secure_getenv>() a pour but d'être utilisée dans les bibliothèques polyvalentes pour éviter les vulnérabilités qui pourraient survenir si des programmes Set-UID ou Set-GID faisaient accidentellement confiance à l'environnement.

note: type: Plain text
en: The B<getenv>()  function returns a pointer to the value in the environment, or NULL if there is no match.
fr: La fonction B<getenv>() renvoie un pointeur sur la valeur correspondante, dans l'environnement du processus, ou NULL s'il n'y a pas de correspondance.

note: type: Plain text
en: B<secure_getenv>()  first appeared in glibc 2.17.
fr: B<secure_getenv>() a été introduite dans la glibc dans sa version 2.17.

note: type: Plain text
en: B<getenv>(): SVr4, POSIX.1-2001, 4.3BSD, C89, C99.
fr: B<getenv>() : SVr4, POSIX.1-2001, BSD\ 4.3, C89, C99.

note: type: Plain text
en: B<secure_getenv>()  is a GNU extension.
fr: B<secure_getenv>() est une extension GNU.

note: type: Plain text
en: The strings in the environment list are of the form I<name=value>.
fr: Les chaînes dans la liste des variables d'environnement sont de la forme I<nom=valeur>.

note: type: Plain text
en: As typically implemented, B<getenv>()  returns a pointer to a string within the environment list.  The caller must take care not to modify this string, since that would change the environment of the process.
fr: Telle qu'elle est généralement implémentée, B<getenv>() renvoie un pointeur vers une chaîne de la liste d'environnement. L'appelant doit faire attention de ne pas modifier cette chaîne car cela modifierait l'environnement du processus.

note: type: Plain text
en: The implementation of B<getenv>()  is not required to be reentrant.  The string pointed to by the return value of B<getenv>()  may be statically allocated, and can be modified by a subsequent call to B<getenv>(), B<putenv>(3), B<setenv>(3), or B<unsetenv>(3).
fr: L'implémentation de B<getenv>() ne nécessite pas qu'elle soit réentrante. La chaîne pointée par la valeur de retour de B<getenv>() peut être allouée statiquement et peut être modifiée par un appel ultérieur à B<getenv>(), B<putenv>(3), B<setenv>(3) ou B<unsetenv>(3).

note: type: Plain text
en: The "secure execution" mode of B<secure_getenv>()  is controlled by the B<AT_SECURE> flag contained in the auxiliary vector passed from the kernel to user space.
fr: Le mode « secure execution » (exécution sécurisée) de B<secure_getenv>() est contrôlé par l'attribut B<AT_SECURE> contenu dans le vecteur auxiliaire passé du noyau à l'espace utilisateur.

note: type: TH
en: 2014-04-01
fr: 1er avril 2014

note: type: Plain text
en: getloadavg - get system load averages
fr: getloadavg - Obtenir les moyennes de la charge du système

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

note: type: Plain text
en: The B<getloadavg>()  function returns the number of processes in the system run queue averaged over various periods of time.  Up to I<nelem> samples are retrieved and assigned to successive elements of I<loadavg>[].  The system imposes a maximum of 3 samples, representing averages over the last 1, 5, and 15 minutes, respectively.
fr: La fonction B<getloadavg>() renvoie le nombre de processus présents dans la file des processus prêts du système. Ce nombre est une moyenne réalisée sur diverses périodes. Jusqu'à I<nelem> acquisitions sont réalisées et affectées aux éléments successifs de I<loadavg>[]. Le système impose un maximum de 3 échantillonnages, représentant des moyennes sur respectivement la dernière minute, les 5 dernières minutes et les 15 dernières minutes.

note: .SH HISTORY The BR getloadavg () function appeared in 4.3BSD Reno . type: Plain text
en: If the load average was unobtainable, -1 is returned; otherwise, the number of samples actually retrieved is returned.
fr: Si la charge moyenne n'a pas pu être obtenue, -1 est renvoyé\ ; sinon, le nombre d'acquisitions effectivement réalisées est renvoyé.

note: type: Plain text
en: This function is available in glibc since version 2.2.
fr: Cette fonction est disponible dans la glibc depuis la version\ 2.2.

note: type: Plain text
en: The B<getloadavg>()  function is thread-safe.
fr: La fonction B<getloadavg>() est sûre dans un contexte multithread.

note: mdoc seems to have a bug - there must be no newline here type: Plain text
en: Not in POSIX.1-2001.  Present on the BSDs and Solaris.
fr: Absent de POSIX.1-2001. Présent sur les systèmes BSD et Solaris.

note: type: Plain text
en: getsubopt - parse suboption arguments from a string
fr: getsubopt - Parcourir les arguments des sous-options depuis une chaîne

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

note: type: Plain text
en: || /* Since glibc 2.12: */ _POSIX_C_SOURCE\ E<gt>=\ 200809L
fr: || /* Depuis la glibc 2.12 : */ _POSIX_C_SOURCE\ E<gt>=\ 200809L

note: type: Plain text
en: B<getsubopt>()  parses the list of comma-separated suboptions provided in I<optionp>.  (Such a suboption list is typically produced when B<getopt>(3)  is used to parse a command line; see for example the I<-o> option of B<mount>(8).)  Each suboption may include an associated value, which is separated from the suboption name by an equal sign.  The following is an example of the kind of string that might be passed in I<optionp>:
fr: B<getsubopt>() parcourt la liste des sous-options séparées par des virgules fournie dans I<optionp> (une liste de sous-options est typiquement créée lorsque B<getopt>(3) est utilisée pour parcourir une ligne de commande\ ; consultez par exemple l'option I<-o> de B<mount>(8)). Chaque sous-option peut être associée à une valeur qui est séparée de son nom par un signe égal. La suite est un exemple de ce type de chaîne qui peut être passé à I<optionp>\ :

note: type: Plain text
en: The I<tokens> argument is a pointer to a NULL-terminated array of pointers to the tokens that B<getsubopt>()  will look for in I<optionp>.  The tokens should be distinct, null-terminated strings containing at least one character, with no embedded equal signs or commas.
fr: L'argument I<tokens> est un pointeur vers un tableau de pointeurs (terminé par NULL) vers les marqueurs que B<getsubopt>() recherche dans I<optionp>. Les marqueurs doivent être distincts, contenant des chaînes terminées par un caractère nul d'au moins un caractère, sans signe égal ou virgule.

note: type: Plain text
en: Each call to B<getsubopt>()  returns information about the next unprocessed suboption in I<optionp>.  The first equal sign in a suboption (if any) is interpreted as a separator between the name and the value of that suboption.  The value extends to the next comma, or (for the last suboption) to the end of the string.  If the name of the suboption matches a known name from I<tokens>, and a value string was found, B<getsubopt>()  sets I<*valuep> to the address of that string.  The first comma in I<optionp> is overwritten with a null byte, so I<*valuep> is precisely the "value string" for that suboption.
fr: Chaque appel à B<getsubopt>() renvoie une information sur la prochaine sous-option contenue dans I<optionp> qui n'a pas été traitée. Le premier signal égal (s'il existe) est interprété comme un séparateur entre un nom et une valeur de sous-option. La valeur se termine à la prochaine virgule ou (pour la dernière sous-option) à la fin de la chaîne. Si le nom d'une sous-option correspond à un nom de I<tokens> et qu'une chaîne de valeur est trouvée, B<getsubopt>() définit I<*valuep> à l'adresse de cette chaîne. La première virgule in I<optionp> est surpassée par un octet nul, ainsi I<*valuep> est exactement «\ la chaîne de valeur\ » de cette sous-option.

note: type: Plain text
en: If the suboption is recognized, but no value string was found, I<*valuep> is set to NULL.
fr: Si la sous-option est reconnue, mais qu'aucune chaîne de valeur n'existe, I<*valuep> est défini à NULL.

note: type: Plain text
en: When B<getsubopt>()  returns, I<optionp> points to the next suboption, or to the null byte (\(aq\e0\(aq) at the end of the string if the last suboption was just processed.
fr: Lorsque B<getsubopt>() renvoie, I<optionp> pointe vers la prochaine sous-option, ou vers l'octet nul (« \e0 ») en fin de chaîne, si la dernière sous-option vient juste d'être traitée.

note: type: Plain text
en: If the first suboption in I<optionp> is recognized, B<getsubopt>()  returns the index of the matching suboption element in I<tokens>.  Otherwise, -1 is returned and I<*valuep> is the entire I<name>B<[=>I<value>B<]> string.
fr: Si la première sous-option de I<optionp> est reconnue, B<getsubopt>() renvoie l'index de l'élément de I<tokens> correspondant à la sous-option. Sinon, -1 est renvoyé et I<*valuep> correspond à la chaîne I<nom>B<[=>I<valeur>B<]>.

note: type: Plain text
en: Since I<*optionp> is changed, the first suboption before the call to B<getsubopt>()  is not (necessarily) the same as the first suboption after B<getsubopt>().
fr: Puisque I<*optionp> est modifié, la première sous-option avant l'appel à B<getsubopt>() n'est pas nécessairement la même qu'après.

note: type: Plain text
en: The B<getsubopt>()  function is thread-safe.
fr: La fonction B<getsubopt>() est sûre dans un contexte multithread.

note: type: Plain text
en: Since B<getsubopt>()  overwrites any commas it finds in the string I<*optionp>, that string must be writable; it cannot be a string constant.
fr: Puisque B<getsubopt>() réécrit toutes les virgules trouvées dans la chaîne I<*optionp>, cette chaîne doit être accessible en écriture, elle ne peut pas être une chaîne constante.

note: type: Plain text
en: The following program expects suboptions following a "-o" option.
fr: Le programme suivant attend des sous-options après l'option «\ -o\ ».

note: type: TH
en: 2013-12-12
fr: 12 décembre 2013

note: type: Plain text
en: malloc, free, calloc, realloc - allocate and free dynamic memory
fr: malloc, free, calloc, realloc - Allocation et libération dynamiques de mémoire

note: glibc does this: type: Plain text
en: The B<malloc>()  function allocates I<size> bytes and returns a pointer to the allocated memory.  I<The memory is not initialized>.  If I<size> is 0, then B<malloc>()  returns either NULL, or a unique pointer value that can later be successfully passed to B<free>().
fr: La fonction B<malloc>() alloue I<size> octets, et renvoie un pointeur sur la mémoire allouée. I<Le contenu de la zone de mémoire n'est pas initialisé>. Si I<size> est nulle, B<malloc> renvoie soit NULL ou un unique pointeur qui pourra être passé ultérieurement à B<free>() avec succès.

note: type: Plain text
en: The B<free>()  function frees the memory space pointed to by I<ptr>, which must have been returned by a previous call to B<malloc>(), B<calloc>()  or B<realloc>().  Otherwise, or if I<free(ptr)> has already been called before, undefined behavior occurs.  If I<ptr> is NULL, no operation is performed.
fr: La fonction B<free>() libère l'espace mémoire pointé par I<ptr>, qui a été obtenu lors d'un appel antérieur à B<malloc>(), B<calloc>() ou B<realloc>(). Si le pointeur I<ptr> n'a pas été obtenu par l'un de ces appels, ou s'il a déjà été libéré avec I<free(ptr)>, le comportement est indéterminé. Si I<ptr> est NULL, aucune opération n'est effectuée.

note: glibc does this: type: Plain text
en: The B<calloc>()  function allocates memory for an array of I<nmemb> elements of I<size> bytes each and returns a pointer to the allocated memory.  The memory is set to zero.  If I<nmemb> or I<size> is 0, then B<calloc>()  returns either NULL, or a unique pointer value that can later be successfully passed to B<free>().
fr: La fonction B<calloc>() alloue la mémoire nécessaire pour un tableau de I<nmemb> éléments de I<size> octets, et renvoie un pointeur vers la mémoire allouée. Cette zone est remplie avec des zéros. Si I<nmemb> ou si I<size> est nulle, B<calloc> renvoie soit NULL ou un unique pointeur qui pourra être passé ultérieurement à B<free>() avec succès.

note: type: Plain text
en: The B<realloc>()  function changes the size of the memory block pointed to by I<ptr> to I<size> bytes.  The contents will be unchanged in the range from the start of the region up to the minimum of the old and new sizes.  If the new size is larger than the old size, the added memory will I<not> be initialized.  If I<ptr> is NULL, then the call is equivalent to I<malloc(size)>, for all values of I<size>; if I<size> is equal to zero, and I<ptr> is not NULL, then the call is equivalent to I<free(ptr)>.  Unless I<ptr> is NULL, it must have been returned by an earlier call to B<malloc>(), B<calloc>()  or B<realloc>().  If the area pointed to was moved, a I<free(ptr)> is done.
fr: La fonction B<realloc>() modifie la taille du bloc de mémoire pointé par I<ptr> à la taille de I<size> octets. Le contenu de la mémoire entre la zone de départ et la plus petite taille entre la nouvelle et l'ancienne taille n'est pas modifié. Si la nouvelle taille est plus grande que l'ancienne taille, le contenu de la zone de mémoire nouvellement allouée n'est pas initialisé. Si I<ptr> est NULL, l'appel est équivalent à I<malloc(size)>, pour toute valeur de I<size> ; si I<size> vaut zéro et I<ptr> est non NULL, l'appel est équivalent à I<free(ptr)>. Si I<ptr> est NULL, il doit avoir été obtenu par un appel antérieur à B<malloc>(), B<calloc>() ou B<realloc>(). Si la zone pointée était déplacée, un I<free(ptr)> est effectué.

note: type: Plain text
en: The B<malloc>()  and B<calloc>()  functions return a pointer to the allocated memory, which is suitably aligned for any built-in type.  On error, these functions return NULL.  NULL may also be returned by a successful call to B<malloc>()  with a I<size> of zero, or by a successful call to B<calloc>()  with I<nmemb> or I<size> equal to zero.
fr: Les fonctions B<malloc>() et B<calloc>() renvoient un pointeur vers la mémoire allouée, qui est correctement alignée pour n'importe quel type intégré. Si elles échouent, elles renvoient NULL. NULL peut également être renvoyé par un appel réussi à B<malloc>() avec un paramètre I<size> égal à zéro, ou par un appel réussi de B<calloc>() avec I<nmemb> ou I<size> égal à zéro.

note: type: Plain text
en: The B<free>()  function returns no value.
fr: La fonction B<free>() ne renvoie pas de valeur.

note: type: Plain text
en: The B<realloc>()  function returns a pointer to the newly allocated memory, which is suitably aligned for any built-in type and may be different from I<ptr>, or NULL if the request fails.  If I<size> was equal to 0, either NULL or a pointer suitable to be passed to B<free>()  is returned.  If B<realloc>()  fails, the original block is left untouched; it is not freed or moved.
fr: La fonction B<realloc>() renvoie un pointeur sur la mémoire nouvellement allouée, qui est correctement alignée pour n'importe quel type intégré, et qui peut être différent de I<ptr>, ou B<NULL> si la demande échoue. Si I<size> vaut zéro, realloc renvoie NULL ou un pointeur acceptable pour B<free>(). Si B<realloc>() échoue, le bloc mémoire original reste intact, il n'est ni libéré ni déplacé.

note: type: Plain text
en: By default, Linux follows an optimistic memory allocation strategy.  This means that when B<malloc>()  returns non-NULL there is no guarantee that the memory really is available.  In case it turns out that the system is out of memory, one or more processes will be killed by the OOM killer.  For more information, see the description of I</proc/sys/vm/overcommit_memory> and I</proc/sys/vm/oom_adj> in B<proc>(5), and the Linux kernel source file I<Documentation/vm/overcommit-accounting>.
fr: Par défaut, Linux suit une stratégie d'allocation optimiste. Ceci signifie que lorsque B<malloc>() renvoie une valeur non NULL, il n'y a aucune garantie que la mémoire soit véritablement disponible. Dans le cas où le système manque de mémoire, un ou plusieurs processus seront tués par l'infâme «\ OOM killer\ » (gestionnaire de mémoire). Pour plus d'informations, consultez la description de I</proc/sys/vm/overcommit_memory> et I</proc/sys/vm/oom_adj> dans B<proc>(5), ainsi que le fichier I<Documentation/vm/overcommit-accounting> des sources du noyau Linux.

note: type: Plain text
en: Normally, B<malloc>()  allocates memory from the heap, and adjusts the size of the heap as required, using B<sbrk>(2).  When allocating blocks of memory larger than B<MMAP_THRESHOLD> bytes, the glibc B<malloc>()  implementation allocates the memory as a private anonymous mapping using B<mmap>(2).  B<MMAP_THRESHOLD> is 128 kB by default, but is adjustable using B<mallopt>(3).  Allocations performed using B<mmap>(2)  are unaffected by the B<RLIMIT_DATA> resource limit (see B<getrlimit>(2)).
fr: En général, B<malloc>() alloue la mémoire depuis le tas, et ajuste la taille du tas en conséquence avec B<sbrk>(2). Lorsque les bloques de mémoire alloués sont plus larges que B<MMAP_THRESHOLD> octets, l'implémentation de la glibc de B<malloc> alloue la mémoire selon un projection anonyme privée avec B<mmap>(2). B<MMAP_THRESHOLD> vaut 128\ Ko par défaut et il est ajustable avec B<mallopt>(3). Les allocations réalisées avec B<mmap>(2) ne sont pas affectées par la limitation de ressource B<RLIMIT_DATA> (consultez B<getrlimit>(2)).

note: type: Plain text
en: To avoid corruption in multithreaded applications, mutexes are used internally to protect the memory-management data structures employed by these functions.  In a multithreaded application in which threads simultaneously allocate and free memory, there could be contention for these mutexes.  To scalably handle memory allocation in multithreaded applications, glibc creates additional I<memory allocation arenas> if mutex contention is detected.  Each arena is a large region of memory that is internally allocated by the system (using B<brk>(2)  or B<mmap>(2)), and managed with its own mutexes.
fr: Pour éviter les corruptions d'applications multithreadées, les mutex sont utilisés en interne pour protéger les structures de données de gestion de mémoire utilisées dans ces fonctions. Dans une application multithreadée où les threads allouent et libèrent la mémoire en même temps, ces mutex risquent d'entrer en conflit. Pour gérer l'allocation de mémoire de façon évolutive dans les applications multithreadées, la glibc crée des I<domaines d'allocation mémoire> si un conflit de mutex est détecté. Chaque domaine est un grand espace de mémoire qui est alloué en interne par le système (en utilisant B<brk>(2) ou B<mmap>(2)), et géré avec ses propres mutex.

note: type: Plain text
en: The UNIX 98 standard requires B<malloc>(), B<calloc>(), and B<realloc>()  to set I<errno> to B<ENOMEM> upon failure.  Glibc assumes that this is done (and the glibc versions of these routines do this); if you use a private malloc implementation that does not set I<errno>, then certain library routines may fail without having a reason in I<errno>.
fr: Le standard UNIX 98 nécessite que B<malloc>(), B<calloc>() et B<realloc>() positionnent I<errno> à B<ENOMEM> en cas d'échec. La glibc suppose qu'il en est ainsi (et les versions glibc de ces routines le font). Si vous utilisez une implémentation personnelle de malloc qui ne positionne pas I<errno>, certaines routines de bibliothèques peuvent échouer sans donner de raison dans I<errno>.

note: type: Plain text
en: Crashes in B<malloc>(), B<calloc>(), B<realloc>(), or B<free>()  are almost always related to heap corruption, such as overflowing an allocated chunk or freeing the same pointer twice.
fr: Lorsqu'un programme échoue durant un appel à B<malloc>(), B<calloc>(), B<realloc>() ou B<free>(), ceci est presque toujours le signe d'une corruption du tas. Ceci survient généralement en cas de débordement d'un bloc mémoire alloué, ou en libérant deux fois le même pointeur.

note: type: Plain text
en: Recent versions of Linux libc (later than 5.4.23) and glibc (2.x)  include a B<malloc>()  implementation which is tunable via environment variables.  For details, see B<mallopt>(3).
fr: Les dernières versions de libc Linux (depuis 5.4.23) et de glibc (2.x) contiennent une implémentation de B<malloc>() qui est personnalisable à l'aide des variables d'environnement. Pour plus de précisions, consultez B<mallopt>(3).

note: type: Plain text
en: mblen - determine number of bytes in next multibyte character
fr: mblen - Déterminer la taille du prochain caractère multioctet

note: type: Plain text
en: If I<s> is not NULL, the B<mblen>()  function inspects at most I<n> bytes of the multibyte string starting at I<s> and extracts the next complete multibyte character.  It uses a static anonymous shift state known only to the B<mblen>()  function.  If the multibyte character is not the null wide character, it returns the number of bytes that were consumed from I<s>.  If the multibyte character is the null wide character, it returns 0.
fr: Si I<s> n'est pas un pointeur NULL, la fonction B<mblen>() inspecte au plus I<n> octets de la chaîne multioctet commençant à l'adresse I<s> et extrait le caractère multioctet complet suivant. Elle utilise un état de décalage statique anonyme,  uniquement connu de la fonction B<mblen>(). Si le caractère multioctet n'est pas le caractère large nul, elle renvoie le nombre d'octets consommés de I<s>. Si c'est le caractère large nul, elle renvoie 0.

note: type: Plain text
en: If the I<n> bytes starting at I<s> do not contain a complete multibyte character, B<mblen>()  returns -1.  This can happen even if I<n> is greater than or equal to I<MB_CUR_MAX>, if the multibyte string contains redundant shift sequences.
fr: Si les I<n> octets commençant à l'adresse I<s> ne contiennent pas un caractère multioctet complet, B<mblen>() renvoie -1. Ceci peut arriver même si I<n> est supérieur ou égal à I<MB_CUR_MAX>, si la chaîne multioctet contient des séquences de décalages redondantes.

note: type: Plain text
en: If the multibyte string starting at I<s> contains an invalid multibyte sequence before the next complete character, B<mblen>()  also returns -1.
fr: Si la chaîne multioctet commençant en I<s> contient une séquence invalide avant le prochain caractère complet, B<mblen>() renvoie aussi -1.

note: The Dinkumware doc and the Single UNIX specification say this, but glibc doesn't implement this. type: Plain text
en: If I<s> is NULL, the B<mblen>()  function resets the shift state, known to only this function, to the initial state, and returns nonzero if the encoding has nontrivial shift state, or zero if the encoding is stateless.
fr: Si I<s> est un pointeur NULL, la fonction B<mblen>() réinitialise l'état de décalage (connue d'elle seule), et renvoie une valeur non nulle si le codage a un état de décalage non trivial, ou zéro si le codage est sans état.

note: type: Plain text
en: The B<mblen>()  function returns the number of bytes parsed from the multibyte sequence starting at I<s>, if a non-null wide character was recognized.  It returns 0, if a null wide character was recognized.  It returns -1, if an invalid multibyte sequence was encountered or if it couldn't parse a complete multibyte character.
fr: La fonction B<mblen>() renvoie le nombre d'octets analysés dans la séquence multioctet commençant en I<s>, si un caractère large non nul a été reconnu. Elle renvoie zéro, si un caractère large nul a été trouvé. Elle renvoie -1 si une séquence multioctet incorrecte ou un caractère multioctet incomplet a été rencontrés.

note: type: Plain text
en: The B<mblen>()  function is not thread-safe.
fr: La fonction B<mblen>() n'est pas sûre dans un contexte multithread.

note: type: Plain text
en: The behavior of B<mblen>()  depends on the B<LC_CTYPE> category of the current locale.
fr: Le comportement de B<mblen>() dépend de la catégorie B<LC_CTYPE> de la localisation en cours.

note: type: Plain text
en: The function B<mbrlen>(3)  provides a better interface to the same functionality.
fr: La fonction B<mbrlen>(3) fournit une meilleure interface pour la même fonctionnalité.

note: type: TH
en: 2014-03-18
fr: 18 mars 2014

note: type: Plain text
en: mbstowcs - convert a multibyte string to a wide-character string
fr: mbstowcs - Convertir une chaîne de caractères multioctets en une chaîne de caractères larges

note: type: Plain text
en: If I<dest> is not NULL, the B<mbstowcs>()  function converts the multibyte string I<src> to a wide-character string starting at I<dest>.  At most I<n> wide characters are written to I<dest>.  The conversion starts in the initial state.  The conversion can stop for three reasons:
fr: Si I<dest> n'est pas un pointeur NULL, la fonction B<mbstowcs>() convertit la chaîne multioctet I<src> en chaîne de caractères larges I<dest>. Elle écrira au plus I<n> caractères larges dans I<dest>. L'état de conversion est initialisé. La conversion peut s'arrêter pour l'une des trois raisons suivantes\ :

note: type: Plain text
en: An invalid multibyte sequence has been encountered.  In this case, I<(size_t)\ -1> is returned.
fr: Une séquence multioctet incorrecte a été rencontrée. Dans ce cas, elle renvoie I<(size_t)\ -1>.

note: type: Plain text
en: I<n> non-L\(aq\e0\(aq wide characters have been stored at I<dest>.  In this case, the number of wide characters written to I<dest> is returned, but the shift state at this point is lost.
fr: I<n> caractères larges non nuls ont été stockés dans I<dest>. Dans ce cas, le nombre de caractères écrits dans I<dest> est renvoyé, mais l'état de décalage en ce point est perdu.

note: type: Plain text
en: The multibyte string has been completely converted, including the terminating null wide character (\(aq\e0\(aq).  In this case, the number of wide characters written to I<dest>, excluding the terminating null wide character, is returned.
fr: La chaîne multioctet a été complètement convertie, y compris le caractère nul final («\ \e0\ »). Dans ce cas, le nombre de caractères larges écrits dans I<dest>, sans compter le caractère nul final, est renvoyé.

note: type: Plain text
en: The programmer must ensure that there is room for at least I<n> wide characters at I<dest>.
fr: Le programmeur doit s'assurer qu'il y a assez de place pour au moins I<n> caractères larges dans I<dest>.

note: type: Plain text
en: If I<dest> is NULL, I<n> is ignored, and the conversion proceeds as above, except that the converted wide characters are not written out to memory, and that no length limit exists.
fr: Si I<dest> est NULL, I<n> est ignoré, et la conversion se présente comme au-dessus, excepté que les caractères larges ne sont pas écrits en mémoire et qu'aucune limite de longueur n'existe.

note: type: Plain text
en: In order to avoid the case 2 above, the programmer should make sure I<n> is greater than or equal to I<mbstowcs(NULL,src,0)+1>.
fr: Afin d'éviter la situation numéro 2 ci-dessus, le programmeur doit s'assurer que I<n> est supérieur ou égal a I<mbstowcs(NULL,src,0)+1>.

note: type: Plain text
en: The B<mbstowcs>()  function returns the number of wide characters that make up the converted part of the wide-character string, not including the terminating null wide character.  If an invalid multibyte sequence was encountered, I<(size_t)\ -1> is returned.
fr: La fonction B<mbstowcs>() renvoie le nombre de caractères larges qui constituent la partie convertie de la chaîne, sans compter le caractère nul final. Si une séquence multioctet incorrecte est rencontrée, elle renvoie I<(size_t)\ -1>.

note: type: Plain text
en: The behavior of B<mbstowcs>()  depends on the B<LC_CTYPE> category of the current locale.
fr: Le comportement de B<mbstowcs>() dépend de la catégorie B<LC_CTYPE> de la localisation en cours.

note: type: Plain text
en: The function B<mbsrtowcs>(3)  provides a better interface to the same functionality.
fr: La fonction B<mbsrtowcs>(3) fournit une meilleure interface pour la même fonctionnalité.

note: type: Plain text
en: The program below illustrates the use of B<mbstowcs>(), as well as some of the wide character classification functions.  An example run is the following:
fr: Le programme ci-dessous illustre l’utilisation de B<mbstowcs>(), ainsi que de certaines fonctions de classification pour les caractères larges. Voici un exemple de son exécution.

note: type: Plain text
en: $ ./t_mbstowcs de_DE.UTF-8 Grüße!
    Length of source string (excluding terminator):
        8 bytes
        6 multibyte characters
fr: $ ./t_mbstowcs de_DE.UTF-8 Grüße!
    Taille de la chaîne source (sans le caractère final) :
        8 octets
        6 caractères multioctets

note: type: Plain text
en: Wide character string is: Grüße! (6 characters)
        G alpha upper
        r alpha lower
        ü alpha lower
        ß alpha lower
        e alpha lower
        ! !alpha
fr: La chaîne de caractères larges est : Grüße! (6 caractères)
        G alpha majuscule
        r alpha minuscule
        ü alpha minuscule
        ß alpha minuscule
        e alpha minuscule
        ! !alpha

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

note: type: Plain text
en: int
    main(int argc, char *argv[])
    {
        size_t mbslen;      /* Number of multibyte characters in source */
        wchar_t *wcs;       /* Pointer to converted wide character string */
        wchar_t *wp;
fr: int
    main(int argc, char *argv[])
    {
        size_t mbslen;      /* Nombre de caractères multioctets dans
                               la source */
        wchar_t *wcs;       /* Pointeur vers la chaîne convertie de
                               caractères larges */
        wchar_t *wp;

note: type: Plain text
en:     if (argc E<lt> 3) {
            fprintf(stderr, "Usage: %s E<lt>localeE<gt> E<lt>stringE<gt>\en", argv[0]);
            exit(EXIT_FAILURE);
        }
fr:     if (argc E<lt> 3) {
            fprintf(stderr, "Utilisation : %s E<lt>localeE<gt> E<lt>chaîneE<gt>\en", argv[0]);
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     /* Apply the specified locale */
fr:     /* Appliquer les paramètres régionaux indiqués */

note: type: Plain text
en:     /* Calculate the length required to hold argv[2] converted to
           a wide character string */
fr:     /* Calculer la taille nécessaire pour stocker argv[2] convertie en
           chaîne de caractères larges */

note: type: Plain text
en:     /* Describe the source string to the user */
fr:     /* Décrire la chaîne source à l’utilisateur */

note: type: Plain text
en:     printf("Length of source string (excluding terminator):\en");
        printf("    %zu bytes\en", strlen(argv[2]));
        printf("    %zu multibyte characters\en\en", mbslen);
fr:     printf("Taille de la chaîne source (sans le caractère final) :\en");
        printf("    %zu octets\en", strlen(argv[2]));
        printf("    %zu caractères multioctet\en\en", mbslen);

note: type: Plain text
en:     /* Allocate wide character string of the desired size.  Add 1
           to allow for terminating null wide character (L\(aq\e0\(aq). */
fr:     /* Allouer une chaîne de caractères larges de la taille voulue. 
           Ajouter 1 pour accepter le caractère nul final large (L\(aq\e0\(aq). */

note: type: Plain text
en:     /* Convert the multibyte character string in argv[2] to a
           wide character string */
fr:     /* Convertir la chaîne de caractères multioctets de argv[2]
           en une chaîne de caractères larges */

note: type: Plain text
en:     printf("Wide character string is: %ls (%zu characters)\en",
                wcs, mbslen);
fr:     printf("La chaîne de caractères larges est : %ls (%zu caractères)\en",
                wcs, mbslen);

note: type: Plain text
en:     /* Now do some inspection of the classes of the characters in
           the wide character string */
fr:     /* Inspecter un peu les classes des caractères dans la chaîne
           de caractères larges */

note: type: Plain text
en:         if (iswalpha(*wp)) {
                if (iswupper(*wp))
                    printf("upper ");
fr:         if (iswalpha(*wp)) {
                if (iswupper(*wp))
                    printf("majuscule ");

note: type: Plain text
en:             if (iswlower(*wp))
                    printf("lower ");
            }
fr:             if (iswlower(*wp))
                    printf("minuscule ");
            }

note: type: Plain text
en: mbtowc - convert a multibyte sequence to a wide character
fr: mbtowc - Convertir une séquences multioctet en caractères larges

note: type: Plain text
en: The main case for this function is when I<s> is not NULL and I<pwc> is not NULL.  In this case, the B<mbtowc>()  function inspects at most I<n> bytes of the multibyte string starting at I<s>, extracts the next complete multibyte character, converts it to a wide character and stores it at I<*pwc>.  It updates an internal shift state known only to the B<mbtowc>()  function.  If I<s> does not point to a null byte (\(aq\e0\(aq), it returns the number of bytes that were consumed from I<s>, otherwise it returns 0.
fr: L'utilisation habituelle de cette fonction est avec I<s> et I<pwc> tous deux différents NULL. Dans ce cas, la fonction B<mbtowc>() examine au plus I<n> octets de la chaîne multioctet commençant à l'adresse I<s>, extrait le prochain caractère multioctet complet, le convertit en caractère large et le stocke dans I<*pwc>. Elle met à jour l'état interne de décalage, connu d'elle seule. Si I<s> ne pointe pas sur un octet nul («\ \e0\ »), elle renvoie le nombre d'octets qui ont été consommés dans I<s>, sinon, elle renvoie zéro.

note: type: Plain text
en: If the I<n> bytes starting at I<s> do not contain a complete multibyte character, or if they contain an invalid multibyte sequence, B<mbtowc>()  returns -1.  This can happen even if I<n> E<gt>= I<MB_CUR_MAX>, if the multibyte string contains redundant shift sequences.
fr: Si les I<n> octets débutants en I<s> ne contiennent pas un caractère multioctet complet, ou s'il s'agit d'une séquence incorrecte, B<mbtowc>() renvoie -1. Ceci peut se produire même si I<n> est supérieur ou égal à B<MB_CUR_MAX>, si la chaîne multioctet contient des séquences de décalage redondantes.

note: type: Plain text
en: A different case is when I<s> is not NULL but I<pwc> is NULL.  In this case, the B<mbtowc>()  function behaves as above, except that it does not store the converted wide character in memory.
fr: Un autre cas possible se présent si I<s> est non NULL, mais I<pwc> est NULL. Dans ce cas, la fonction B<mbtowc>() se comporte comme ci-dessus, mais ne stocke par le caractère large en mémoire.

note: The Dinkumware doc and the Single UNIX specification say this, but glibc doesn't implement this. type: Plain text
en: A third case is when I<s> is NULL.  In this case, I<pwc> and I<n> are ignored.  The B<mbtowc>()  function resets the shift state, only known to this function, to the initial state, and returns nonzero if the encoding has nontrivial shift state, or zero if the encoding is stateless.
fr: Un troisième cas est possible si I<s> est NULL. Alors, I<pwc> et I<n> sont ignorés. La fonction B<mbtowc>() réinitialise l'état de décalage, qu'elle seule connaît, et renvoie une valeur non nulle si l'encodage à un état de décalage non trivial, ou zéro si l'encodage est sans état.

note: type: Plain text
en: If I<s> is not NULL, the B<mbtowc>()  function returns the number of consumed bytes starting at I<s>, or 0 if I<s> points to a null byte, or -1 upon failure.
fr: Si I<s> est non NULL, la fonction B<mbtowc>() renvoie le nombre d'octets consommés à partir de I<s>, ou zéro si I<s> pointe sur un octet nul, ou encore -1 en cas d'erreur.

note: type: Plain text
en: If I<s> is NULL, the B<mbtowc>()  function returns nonzero if the encoding has nontrivial shift state, or zero if the encoding is stateless.
fr: Si I<s> est NULL, la fonction B<mbtowc>() renvoie une valeur non nulle si l'encodage a un état de décalage non trivial, ou zéro si l'encodage est sans état.

note: type: Plain text
en: The behavior of B<mbtowc>()  depends on the B<LC_CTYPE> category of the current locale.
fr: Le comportement de B<mbtowc>() dépend de la catégorie B<LC_CTYPE> de la localisation en cours.

note: type: Plain text
en: This function is not multithread safe.  The function B<mbrtowc>(3)  provides a better interface to the same functionality.
fr: Cette fonction n'est pas sûre en contexte multithread. La fonction B<mbrtowc>(3) fournit une meilleure interface pour la même fonctionnalité.

note: type: TH
en: 2010-09-26
fr: 26 septembre 2010

note: type: Plain text
en: mkdtemp - create a unique temporary directory
fr: mkdtemp - Création d'un répertoire temporaire unique

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

note: type: Plain text
en: || /* Since glibc 2.10: */
fr: || /* Depuis la glibc 2.10 : */

note: type: Plain text
en: The B<mkdtemp>()  function generates a uniquely named temporary directory from I<template>.  The last six characters of I<template> must be XXXXXX and these are replaced with a string that makes the directory name unique.  The directory is then created with permissions 0700.  Since it will be modified, I<template> must not be a string constant, but should be declared as a character array.
fr: La fonction B<mkdtemp>() crée un répertoire temporaire de nom unique à partir de I<template>. Les six derniers caractères de I<template> doivent être XXXXXX et ces derniers sont remplacés par une chaîne qui rend le nom du répertoire unique. Le répertoire est alors créé avec les permissions 0700. Comme il sera modifié, I<template> ne doit pas être une chaîne constante, mais doit être déclaré en tant que tableau de caractères.

note: type: Plain text
en: The B<mkdtemp>()  function returns a pointer to the modified template string on success, and NULL on failure, in which case I<errno> is set appropriately.
fr: La fonction B<mkdtemp>() renvoie un pointeur vers la chaîne template modifiée en cas de succès, et renvoie NULL en cas d'échec. Dans ce dernier cas, I<errno> est positionnée en conséquence.

note: type: Plain text
en: The last six characters of I<template> were not XXXXXX.  Now I<template> is unchanged.
fr: Les six derniers caractères de I<template> ne sont pas XXXXXX. I<template> n'est pas modifiée.

note: type: Plain text
en: Also see B<mkdir>(2)  for other possible values for I<errno>.
fr: Se reporter également à B<mkdir>(2) pour les autres valeurs possibles de I<errno>.

note: type: Plain text
en: Available since glibc 2.1.91.
fr: Disponible depuis la glibc\ 2.1.91.

note: As at 2006, this function is being considered for a revision of POSIX.1 Also in NetBSD 1.4. type: Plain text
en: POSIX.1-2008.  This function is present on the BSDs.
fr: POSIX.1-2008. Cette fonction est présente sur les BSD.

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

note: type: Plain text
en: mkstemp, mkostemp, mkstemps, mkostemps - create a unique temporary file
fr: mkstemp, mkostemp, mkstemps, mkostemps - Créer un fichier temporaire unique

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

note: type: Plain text
en: || /* Since glibc 2.12: */ _POSIX_C_SOURCE\ E<gt>=\ 200112L
fr: || /* Depuis la glibc 2.12 : */ _POSIX_C_SOURCE\ E<gt>=\ 200112L

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

note: type: Plain text
en: B<mkstemps>(): _BSD_SOURCE || _SVID_SOURCE
fr: B<mkstemps>()\ : _BSD_SOURCE || _SVID_SOURCE

note: type: Plain text
en: B<mkostemps>(): _GNU_SOURCE
fr: B<mkostemps>()\ : _GNU_SOURCE

note: type: Plain text
en: The B<mkstemp>()  function generates a unique temporary filename from I<template>, creates and opens the file, and returns an open file descriptor for the file.
fr: La fonction B<mkstemp>() engendre un nom de fichier temporaire unique, à partir du motif I<template>, crée et ouvre le fichier, et renvoie un descripteur de fichier ouvert pour ce fichier.

note: type: Plain text
en: The last six characters of I<template> must be "XXXXXX" and these are replaced with a string that makes the filename unique.  Since it will be modified, I<template> must not be a string constant, but should be declared as a character array.
fr: Les 6 derniers caractères de I<template> doivent être XXXXXX, et ils seront remplacés par une chaîne rendant le nom de fichier unique. Comme il sera modifié, I<template> ne doit pas être une chaîne constante, mais un tableau de caractères.

note: type: Plain text
en: The file is created with permissions 0600, that is, read plus write for owner only.  The returned file descriptor provides both read and write access to the file.  The file is opened with the B<open>(2)  B<O_EXCL> flag, guaranteeing that the caller is the process that creates the file.
fr: Le fichier est créé en mode 0600, c'est-à-dire en lecture et écriture pour le propriétaire seulement. Le descripteur de fichier renvoyé fournit les accès en lecture et en écriture sur le fichier. Le fichier est ouvert avec l'attribut B<O_EXCL> de B<open>(2), garantissant que l'appelant soit le processus qui ait créé le fichier.

note: Reportedly, FreeBSD type: Plain text
en: The B<mkostemp>()  function is like B<mkstemp>(), with the difference that the following bits\(emwith the same meaning as for B<open>(2)\(emmay be specified in I<flags>: B<O_APPEND>, B<O_CLOEXEC>, and B<O_SYNC>.  Note that when creating the file, B<mkostemp>()  includes the values B<O_RDWR>, B<O_CREAT>, and B<O_EXCL> in the I<flags> argument given to B<open>(2); including these values in the I<flags> argument given to B<mkostemp>()  is unnecessary, and produces errors on some systems.
fr: La fonction B<mkostemp>() agit comme B<mkstemp>(), à la différence que les bits suivants — avec la même signification que pour B<open>(2) — peuvent être définis dans I<flags> : B<O_APPEND>, B<O_CLOEXEC> et B<O_SYNC>. Remarquez qu’en créant le fichier, B<mkostemp>() contient les valeurs B<O_RDWR>, B<O_CREAT> et B<O_EXCL> dans l’argument I<flags> donné à B<open>(2) ; inclure ces valeurs dans l’argument I<flags> donné à B<mkostemp>() n’est pas nécessaire et produit des erreurs sur certains systèmes.

note: type: Plain text
en: The B<mkstemps>()  function is like B<mkstemp>(), except that the string in I<template> contains a suffix of I<suffixlen> characters.  Thus, I<template> is of the form I<prefixXXXXXXsuffix>, and the string XXXXXX is modified as for B<mkstemp>().
fr: La fonction B<mkstemps>() agit comme B<mkstemp>(), sauf que la chaîne dans I<template> contient un suffixe de I<suffixlen> caractères. Ainsi, I<template> est de la forme I<préfixeXXXXXXsuffixe>, et la chaîne XXXXXX est modifiée comme dans B<mkstemp>().

note: type: Plain text
en: The B<mkostemps>()  function is to B<mkstemps>()  as B<mkostemp>()  is to B<mkstemp>().
fr: La fonction B<mkostemps>() est à B<mkstemps>() ce que B<mkostemp>() est à B<mkstemp>().

note: type: Plain text
en: On success, these functions return the file descriptor of the temporary file.  On error, -1 is returned, and I<errno> is set appropriately.
fr: Si elles réussissent, ces fonctions renvoient le descripteur du fichier temporaire créé ou -1 si elles échouent, auquel cas I<errno> contient le code d'erreur.

note: type: Plain text
en: Could not create a unique temporary filename.  Now the contents of I<template> are undefined.
fr: Impossible de créer un nom de fichier unique. Le contenu I<template> est imprévisible.

note: type: Plain text
en: For B<mkstemp>()  and B<mkostemp>(): The last six characters of I<template> were not XXXXXX; now I<template> is unchanged.
fr: Pour B<mkstemp>() et B<mkostemp>() : les six derniers caractères de I<template> ne sont pas XXXXXX ; I<template> n'est pas modifiée.

note: type: Plain text
en: For B<mkstemps>()  and B<mkostemps>(): I<template> is less than I<(6 + suffixlen)> characters long, or the last 6 characters before the suffix in I<template> were not XXXXXX.
fr: Pour B<mkstemps>() et B<mkostemps>() : I<template> a une longueur inférieure à I<(6 + suffixlen)>, ou les 6 derniers caractères avant le suffixe ne sont pas XXXXXX.

note: type: Plain text
en: These functions may also fail with any of the errors described for B<open>(2).
fr: Ces fonctions peuvent également échouer avec chacune des erreurs décrites pour B<open>(2).

note: type: Plain text
en: B<mkostemp>()  is available since glibc 2.7.  B<mkstemps>()  and B<mkostemps>()  are available since glibc 2.11.
fr: B<mkostemp>() est disponible depuis la glibc 2.7. B<mkstemps>() et B<mkostemps>() sont disponibles depuis la glibc 2.11.

note: type: Plain text
en: B<mkstemp>(): 4.3BSD, POSIX.1-2001.
fr: B<mkstemp>()\ : 4.3BSD, POSIX.1-2001.

note: mkstemps() appears to be at least on the BSDs, Mac OS X, Solaris, and Tru64. type: Plain text
en: B<mkstemps>(): unstandardized, but appears on several other systems.
fr: B<mkstemps>()\ : non standard, mais existe sur plusieurs autres systèmes.

note: type: Plain text
en: B<mkostemp>()  and B<mkostemps>(): are glibc extensions.
fr: B<mkostemp>() et B<mkostemps>() sont des extensions de la glibc.

note: type: Plain text
en: In glibc versions 2.06 and earlier, the file is created with permissions 0666, that is, read and write for all users.  This old behavior may be a security risk, especially since other UNIX flavors use 0600, and somebody might overlook this detail when porting programs.  POSIX.1-2008 adds a requirement that the file be created with mode 0600.
fr: Dans la version 2.06 de la glibc et auparavant, le fichier était créé en mode 0666, c'est-à-dire en lecture et écriture pour tous les utilisateurs. Cet ancien comportement est un trou de sécurité potentiel, surtout depuis que les autres dérivés UNIX utilisent le mode 0600 et quelqu'un risque d'oublier ce détail en effectuant un portage de programme. POSIX.1-2008 ajoute l'obligation de créer ce fichier en mode 0600.

note: type: Plain text
en: More generally, the POSIX specification of B<mkstemp>()  does not say anything about file modes, so the application should make sure its file mode creation mask (see B<umask>(2))  is set appropriately before calling B<mkstemp>()  (and B<mkostemp>()).
fr: Plus généralement, la spécification POSIX de B<mkstemp>() ne dit rien des modes des fichiers, ainsi les applications doivent s'assurer que la valeur du masque de mode de création de fichiers (consultez B<umask>(2)) est correcte avant d'appeler B<mkstemp>() (et B<mkostemp>()).

note: type: Plain text
en: The prototype for B<mktemp>()  is in I<E<lt>unistd.hE<gt>> for libc4, libc5, glibc1; glibc2 follows POSIX.1 and has the prototype in I<E<lt>stdlib.hE<gt>>.
fr: Le prototype de B<mktemp>() se trouve dans I<E<lt>unistd.hE<gt>> pour libc4, libc5, glibc1. Glibc2 suit POSIX.1 et possède le prototype dans I<E<lt>stdlib.hE<gt>>.

note: type: TH
en: 2014-02-27
fr: 27 février 2014

note: type: Plain text
en: mktemp - make a unique temporary filename
fr: mktemp - Créer un nom de fichier temporaire unique

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

note: type: Plain text
en: I<Never use this function>; see NOTES.
fr: I<N'utilisez jamais cette fonction>. Consultez la section B<NOTES>.

note: type: Plain text
en: The B<mktemp>()  function generates a unique temporary filename from I<template>.  The last six characters of I<template> must be XXXXXX and these are replaced with a string that makes the filename unique.  Since it will be modified, I<template> must not be a string constant, but should be declared as a character array.
fr: La fonction B<mktemp>() crée un nom de fichier temporaire unique, en utilisant le motif I<template>. Les 6 derniers caractères de I<template> doivent être XXXXXX, et ils seront remplacés par une chaîne rendant le nom de fichier unique. Comme il sera modifié, I<template> ne doit pas être une chaîne constante, mais un tableau de caractères.

note: type: Plain text
en: The B<mktemp>()  function always returns I<template>.  If a unique name was created, the last six bytes of I<template> will have been modified in such a way that the resulting name is unique (i.e., does not exist already)  If a unique name could not be created, I<template> is made an empty string, and I<errno> is set to indicate the error.
fr: La fonction B<mktemp>() renvoie toujours I<template>. Si un nom unique est crée, les six derniers octets de I<template> seront modifiés afin que le nom résultant soit unique. Si un nom unique ne peut être créé, I<template> est une chaîne vide et I<errno> contient le code d'erreur.

note: type: Plain text
en: The last six characters of I<template> were not XXXXXX.
fr: Les 6 derniers caractères de I<template> ne sont pas XXXXXX.

note: type: Plain text
en: 4.3BSD, POSIX.1-2001.  POSIX.1-2008 removes the specification of B<mktemp>().
fr: BSD 4.3, POSIX.1-2001. POSIX.1-2008 supprime la spécification de B<mktemp>().

note: type: Plain text
en: The prototype is in I<E<lt>unistd.hE<gt>> for libc4, libc5, glibc1; glibc2 follows the Single UNIX Specification and has the prototype in I<E<lt>stdlib.hE<gt>>.
fr: Le prototype se trouve dans I<E<lt>unistd.hE<gt>> pour libc4, libc5, glibc1. glibc2 suit les spécifications Single UNIX et place le prototype dans I<E<lt>stdlib.hE<gt>>.

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: Never use B<mktemp>().  Some implementations follow 4.3BSD and replace XXXXXX by the current process ID and a single letter, so that at most 26 different names can be returned.  Since on the one hand the names are easy to guess, and on the other hand there is a race between testing whether the name exists and opening the file, every use of B<mktemp>()  is a security risk.  The race is avoided by B<mkstemp>(3).
fr: Évitez d'utiliser B<mktemp>(). Certaines implémentations suivent BSD\ 4.3, et remplacent XXXXXX par le numéro du processus et une lettre, ce qui donne 26 noms différents possibles. Comme d'une part ces noms sont faciles à deviner, et d'autre part il existe une condition de concurrence entre le test d'existence du nom et l'ouverture du fichier, chaque invocation de B<mktemp>() est un trou de sécurité. Les conditions de concurrences sont évitées par B<mkstemp>(3).

note: type: Plain text
en: B<mkstemp>(3), B<tempnam>(3), B<tmpfile>(3), B<tmpnam>(3)
fr: B<mkstemp>(3), B<tempnam>(3), B<tmpfile>(3). B<tmpnam>(3)

note: type: Plain text
en: on_exit - register a function to be called at normal process termination
fr: on_exit - Programmer une fonction à appeler à la fin normale du programme

note: type: Plain text
en: B<int on_exit(void (*>I<function>B<)(int , void *), void *>I<arg>B<);>
fr: B<int on_exit(void (*>I<fonction>B<)(int , void *), void *>I<arg>B<);>

note: type: Plain text
en: B<on_exit>(): _BSD_SOURCE || _SVID_SOURCE
fr: B<on_exit>() : _BSD_SOURCE || _SVID_SOURCE

note: type: Plain text
en: The B<on_exit>()  function registers the given I<function> to be called at normal process termination, whether via B<exit>(3)  or via return from the program's I<main>().  The I<function> is passed the status argument given to the last call to B<exit>(3)  and the I<arg> argument from B<on_exit>().
fr: La fonction B<on_exit>() enregistre la I<fonction>() pour qu'elle soit appelée lors de la fin normale du programme, soit par l'appel à B<exit>(3), soit lors du retour de la fonction I<main>(). La I<fonction>() reçoit le dernier paramètre de d'état transmis à B<exit>(3) et le paramètre I<arg> transmis à B<on_exit>().

note: type: Plain text
en: The B<on_exit>()  function returns the value 0 if successful; otherwise it returns a nonzero value.
fr: La fonction B<on_exit>() renvoie 0 si elle réussit\ ; sinon elle renvoie une valeur non nulle.

note: type: Plain text
en: This function comes from SunOS 4, but is also present in libc4, libc5 and glibc.  It no longer occurs in Solaris (SunOS 5).  Avoid this function, and use the standard B<atexit>(3)  instead.
fr: Cette fonction provient de SunOS 4, mais est également présente dans libc4, libc5 et les glibc. Elle n'apparaît plus dans Solaris (SunOS 5). Évitez d'utiliser cette fonction pour lui préférer la fonction standard B<atexit>(3).

note: type: TH
en: 2013-04-19
fr: 19 avril 2013

note: type: Plain text
en: putenv - change or add an environment variable
fr: putenv - Ajouter ou modifier une variable d'environnement

note: type: Plain text
en: B<putenv>(): _SVID_SOURCE || _XOPEN_SOURCE
fr: B<putenv>() : _SVID_SOURCE || _XOPEN_SOURCE

note: type: Plain text
en: The B<putenv>()  function adds or changes the value of environment variables.  The argument I<string> is of the form I<name>=I<value>.  If I<name> does not already exist in the environment, then I<string> is added to the environment.  If I<name> does exist, then the value of I<name> in the environment is changed to I<value>.  The string pointed to by I<string> becomes part of the environment, so altering the string changes the environment.
fr: La fonction B<putenv>() ajoute ou modifie la valeur d'une variable d'environnement. L'argument I<string> est une chaîne de caractères de la forme I<nom>=I<valeur>. Si I<nom> n'existe pas dans l'environnement, la variable est ajoutée. Si I<nom> existe, alors la valeur de la variable d'environnement I<nom> est remplacée par I<valeur>. La chaîne pointée par I<string> devient partie intégrante de l'environnement, ainsi une modification de cette chaîne change l'environnement.

note: type: Plain text
en: The B<putenv>()  function returns zero on success, or nonzero if an error occurs.  In the event of an error, I<errno> is set to indicate the cause.
fr: La fonction B<putenv>() renvoie 0 si elle réussit. En cas d'erreur, une valeur non nulle est renvoyée et I<errno> contient le code d'erreur.

note: type: Plain text
en: Insufficient space to allocate new environment.
fr: Pas assez de mémoire.

note: type: Plain text
en: SVr4, POSIX.1-2001, 4.3BSD.
fr: SVr4, POSIX.1-2001, BSD 4.3.

note: type: Plain text
en: The B<putenv>()  function is not required to be reentrant, and the one in libc4, libc5 and glibc 2.0 is not, but the glibc 2.1 version is.
fr: La fonction B<putenv>() n'a pas besoin d'être réentrante, celles des bibliothèques libc4, libc5, et glibc 2.0 ne le sont pas, contrairement à celle de la glibc 2.1.

note: type: Plain text
en: Description for libc4, libc5, glibc: If the argument I<string> is of the form I<name>, and does not contain an \(aq=\(aq character, then the variable I<name> is removed from the environment.  If B<putenv>()  has to allocate a new array I<environ>, and the previous array was also allocated by B<putenv>(), then it will be freed.  In no case will the old storage associated to the environment variable itself be freed.
fr: Description pour libc4, libc5 et glibc\ : Si la chaîne I<string> est de la forme I<nom>, sans contenir de signe «\ =\ », la variable du I<nom> indiqué est supprimée de l'environnement. Si B<putenv>() doit allouer un nouveau tableau I<environ>, et si le tableau précédent avait déjà été alloué par B<putenv>(), alors il sera libéré. En aucun cas, l'espace correspondant aux chaînes d'environnement proprement dites ne sera libéré.

note: type: Plain text
en: The libc4 and libc5 and glibc 2.1.2 versions conform to SUSv2: the pointer I<string> given to B<putenv>()  is used.  In particular, this string becomes part of the environment; changing it later will change the environment.  (Thus, it is an error is to call B<putenv>()  with an automatic variable as the argument, then return from the calling function while I<string> is still part of the environment.)  However, glibc 2.0-2.1.1 differs: a copy of the string is used.  On the one hand this causes a memory leak, and on the other hand it violates SUSv2.  This has been fixed in glibc 2.1.2.
fr: Les versions des bibliothèques libc4, libc5 et glibc 2.1.2 se conforment aux spécifications SUSv2\ : le pointeur I<string> transmis à B<putenv>() est utilisé. En particulier, la chaîne devient partie intégrante de l'environnement\ ; si on la modifie par la suite, l'environnement est modifié (c'est donc une erreur d'appeler B<putenv>() avec une variable automatique en argument puis de revenir de la fonction alors que la chaîne est toujours dans l'environnement). Toutefois, les glibc 2.0 - 2.1.1 diffèrent\ : une copie de la chaîne est effectuée. D'une part cela crée une fuite mémoire, d'autre part on viole les spécifications SUSv2. Ceci a donc été corrigé dans la glibc 2.1.2.

note: type: Plain text
en: The 4.4BSD version, like glibc 2.0, uses a copy.
fr: La version BSD\ 4.4, comme celle de la glibc 2.0, effectue aussi une copie.

note: type: Plain text
en: SUSv2 removes the I<const> from the prototype, and so does glibc 2.1.3.
fr: Dans les spécifications SUSv2, le I<const> a été supprimé du prototype. C'est aussi le cas dans glibc 2.1.3.

note: type: TH
en: 2014-03-11
fr: 11 mars 2014

note: type: Plain text
en: qecvt, qfcvt, qgcvt - convert a floating-point number to a string
fr: qecvt, qfcvt, qgcvt - Conversion de nombres réels en chaînes

note: type: Plain text
en: B<char *qecvt(long double >I<number>B<, int >I<ndigits>B<, int *>I<decpt>B<,> B<int *>I<sign>B<);>
fr: B<char *qecvt(long double >I<nombre>B<, int >I<nb_chiffres>B<, int *>I<decpt>B<,> B<int *>I<sign>B<);>

note: type: Plain text
en: B<char *qfcvt(long double >I<number>B<, int >I<ndigits>B<, int *>I<decpt>B<,> B<int *>I<sign>B<);>
fr: B<char *qfcvt(long double >I<nombre>B<, int >I<nb_chiffres>B<, int *>I<decpt>B<,> B<int *>I<sign>B<);>

note: type: Plain text
en: B<char *qgcvt(long double >I<number>B<, int >I<ndigit>B<, char *>I<buf>B<);>
fr: B<char *qgcvt(long double >I<nombre>B<, int >I<nb_chiffres>B<, char *>I<buf>B<);>

note: type: Plain text
en: B<qecvt>(), B<qfcvt>(), B<qgcvt>(): _SVID_SOURCE
fr: B<qecvt>(), B<qfcvt>(), B<qgcvt>() : _SVID_SOURCE

note: type: Plain text
en: The functions B<qecvt>(), B<qfcvt>()  and B<qgcvt>()  are identical to B<ecvt>(3), B<fcvt>(3)  and B<gcvt>(3)  respectively, except that they use a I<long double> argument I<number>.  See B<ecvt>(3)  and B<gcvt>(3).
fr: Les fonctions B<qecvt>(), B<qfcvt>() et B<qgcvt>() sont identiques à B<ecvt>(3), B<fcvt>(3) et B<gcvt>(3) respectivement, excepté qu'elles prennent un nombre au format I<long double> via l'argument I<nombre>. Consultez B<ecvt>(3) et B<gcvt>(3).

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

note: type: Plain text
en: The B<qgcvt>()  function is thread-safe.
fr: La fonction B<qgcvt>() est sûre dans un contexte multithread.

note: type: Plain text
en: SVr4.  Not seen in most common UNIX implementations, but occurs in SunOS.  Not supported by libc4 and libc5.  Supported by glibc.
fr: SVr4. Ces fonctions sont absentes de la majorité des implémentations UNIX, à l'exception notable de SunOS. Elles ne sont pas supportées par libc4 et libc5 mais le sont par la glibc.

note: type: Plain text
en: These functions are obsolete.  Instead, B<snprintf>(3)  is recommended.
fr: Ces fonctions sont obsolètes. L'utilisation de B<snprintf>(3) est recommandée à la place de ces fonctions.

note: type: TH
en: 2014-01-18
fr: 18 janvier 2014

note: type: Plain text
en: rand, rand_r, srand - pseudo-random number generator
fr: rand, rand_r, srand - Générateur de nombres pseudoaléatoires

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

note: type: Plain text
en: The B<rand>()  function returns a pseudo-random integer in the range 0 to B<RAND_MAX> inclusive (i.e., the mathematical range [0,\ B<RAND_MAX>]).
fr: La fonction B<rand>() renvoie un entier pseudoaléatoire entre 0 et B<RAND_MAX>, bornes incluses (c'est-à-dire dans l'intervalle [0, B<RAND_MAX>]).

note: type: Plain text
en: The B<srand>()  function sets its argument as the seed for a new sequence of pseudo-random integers to be returned by B<rand>().  These sequences are repeatable by calling B<srand>()  with the same seed value.
fr: La fonction B<srand>() utilise son argument comme «\ graine\ » pour la génération d'une nouvelle séquence de nombres pseudoaléatoires, qui seront fournis par B<rand>(). Ces séquences sont reproductibles en appelant B<srand>() avec la même valeur de graine.

note: type: Plain text
en: If no seed value is provided, the B<rand>()  function is automatically seeded with a value of 1.
fr: Si aucune graine originale n'est fournie, la fonction B<rand>() commence en utilisant la valeur 1.

note: type: Plain text
en: The function B<rand>()  is not reentrant or thread-safe, since it uses hidden state that is modified on each call.  This might just be the seed value to be used by the next call, or it might be something more elaborate.  In order to get reproducible behavior in a threaded application, this state must be made explicit; this can be done using the reentrant function B<rand_r>().
fr: La fonction B<rand>() n'est ni réentrante ni sûre en contexte multithread, car elle utilise un état interne modifié à chaque appel. Il peut s'agir simplement de la valeur de graine aléatoire pour l'appel suivant, ou il peut s'agir de quelque chose de plus compliqué. Afin d'obtenir un comportement reproductible dans une application multithread, cet état doit être stocké dans une variable fournie explicitement ; cela peut être fait en utilisant la fonction réentrante B<rand_r>().

note: type: Plain text
en: Like B<rand>(), B<rand_r>()  returns a pseudo-random integer in the range [0,\ B<RAND_MAX>].  The I<seedp> argument is a pointer to an I<unsigned int> that is used to store state between calls.  If B<rand_r>()  is called with the same initial value for the integer pointed to by I<seedp>, and that value is not modified between calls, then the same pseudo-random sequence will result.
fr: Comme B<rand>(), B<rand_r>() renvoie un entier pseudoaléatoire dans l'intervalle [0,\ B<RAND_MAX>]. L'argument I<seedp> est un pointeur vers un I<unsigned int> qui est utilisé pour stocker l'état entre des appels successifs. Si la fonction B<rand_r>() est appelée avec la même valeur initiale pour l'entier pointé par I<seedp>, et que cette valeur n'est pas modifiée entre les appels, alors la même séquence pseudoaléatoire sera générée.

note: type: Plain text
en: The value pointed to by the I<seedp> argument of B<rand_r>()  provides only a very small amount of state, so this function will be a weak pseudo-random generator.  Try B<drand48_r>(3)  instead.
fr: La valeur pointée par l'argument I<seedp> de B<rand_r>() ne fournit qu'une donnée très petite pour stocker la valeur d'état, cette fonction sera donc un générateur pseudoaléatoire faible. Essayez donc B<drand48_r>(3) à sa place.

note: type: Plain text
en: The B<rand>()  and B<rand_r>()  functions return a value between 0 and B<RAND_MAX> (inclusive).  The B<srand>()  function returns no value.
fr: Les fonctions B<rand>() et B<rand_r>() renvoient un nombre entier entre 0 et B<RAND_MAX>, bornes incluses. La fonction B<srand>() ne renvoie aucune valeur.

note: type: Plain text
en: The functions B<rand>()  and B<srand>()  conform to SVr4, 4.3BSD, C89, C99, POSIX.1-2001.  The function B<rand_r>()  is from POSIX.1-2001.  POSIX.1-2008 marks B<rand_r>()  as obsolete.
fr: Les fonctions B<rand>() et B<srand>() sont conformes à SVr4, BSD\ 4.3, C89, C99, POSIX.1-2001. La fonction B<rand_r>() vient de POSIX.1-2001. POSIX.1-2008 marque B<rand_r>() comme étant obsolète.

note: type: Plain text
en: The versions of B<rand>()  and B<srand>()  in the Linux C Library use the same random number generator as B<random>(3)  and B<srandom>(3), so the lower-order bits should be as random as the higher-order bits.  However, on older B<rand>()  implementations, and on current implementations on different systems, the lower-order bits are much less random than the higher-order bits.  Do not use this function in applications intended to be portable when good randomness is needed.  (Use B<random>(3)  instead.)
fr: Les versions de B<rand>() et B<srand>() de la bibliothèque C de Linux utilisent le même générateur de nombres aléatoires que B<random>(3) et B<srandom>(3), ainsi les bits de poids faibles sont tout aussi imprévisibles que les bits de poids forts. Ceci n'est pas le cas avec les anciennes implémentations de B<rand>() ou d'actuelles implémentations sur des systèmes différents, où les bits de poids faibles n'étaient pas «\ aussi aléatoires\ » que ceux de poids forts. N'utilisez pas cette fonction dans des applications conçues pour être portables et lorsqu'un bon caractère aléatoire est nécessaire. (Utilisez plutôt B<random>(3))

note: type: Plain text
en: POSIX.1-2001 gives the following example of an implementation of B<rand>()  and B<srand>(), possibly useful when one needs the same sequence on two different machines.
fr: POSIX.1-2001 fournit l'exemple suivant d'une implémentation de B<rand>() et B<srand>(), potentiellement utile lorsqu'on a besoin de la même séquence sur deux machines différentes.

note: type: Plain text
en: static unsigned long next = 1;
fr: static unsigned long suivant = 1;

note: type: Plain text
en: /* RAND_MAX assumed to be 32767 */
    int myrand(void) {
        next = next * 1103515245 + 12345;
        return((unsigned)(next/65536) % 32768);
    }
fr: /* RAND_MAX supposé être égal à 32767 */
    int mon_rand(void) {
        suivant = suivant * 1103515245 + 12345;
        return((unsigned)(suivant/65536) % 32768);
    }

note: type: Plain text
en: void mysrand(unsigned int seed) {
        next = seed;
    }
fr: void mon_srand(unsigned int graine) {
        suivant = graine;
    }

note: type: Plain text
en: The following program can be used to display the pseudo-random sequence produced by B<rand>()  when given a particular seed.
fr: Le programme suivant peut être utilisé pour afficher la séquence pseudoaléatoire produite par B<rand>() avec une graine donnée.

note: type: Plain text
en: random, srandom, initstate, setstate - random number generator
fr: random, srandom, initstate, setstate - Générateur de nombres aléatoires

note: type: Plain text
en: B<random>(), B<srandom>(), B<initstate>(), B<setstate>():
fr: B<random>(), B<srandom>(), B<initstate>(), B<setstate>() :

note: type: Plain text
en: The B<random>()  function uses a nonlinear additive feedback random number generator employing a default table of size 31 long integers to return successive pseudo-random numbers in the range from 0 to B<RAND_MAX>.  The period of this random number generator is very large, approximately I<16\ *\ ((2^31)\ -\ 1)>.
fr: La fonction B<random>() utilise un générateur de nombre aléatoire non linéaire (« non-linear additive feedback random number generator ») utilisant une table par défaut de 31 entiers longs pour renvoyer successivement des nombres pseudoaléatoires entre 0 et B<RAND_MAX>. La période de ce générateur est très grande, approximativement I<16\ *\ ((2^31)\ -\ 1)>.

note: type: Plain text
en: The B<srandom>()  function sets its argument as the seed for a new sequence of pseudo-random integers to be returned by B<random>().  These sequences are repeatable by calling B<srandom>()  with the same seed value.  If no seed value is provided, the B<random>()  function is automatically seeded with a value of 1.
fr: La fonction B<srandom>() utilise son argument comme «\ graine\ » pour engendrer une nouvelle séquence de nombre pseudoaléatoires qui seront fournis lors des appels à B<random>(). Ces séquences sont reproductibles en invoquant B<srandom>() avec la même graine. Si aucune graine n'est fournie, La fonction B<random>() utilise automatiquement une graine originale de valeur 1.

note: type: Plain text
en: The B<initstate>()  function allows a state array I<state> to be initialized for use by B<random>().  The size of the state array I<n> is used by B<initstate>()  to decide how sophisticated a random number generator it should use\(emthe larger the state array, the better the random numbers will be.  I<seed> is the seed for the initialization, which specifies a starting point for the random number sequence, and provides for restarting at the same point.
fr: La fonction B<initstate>() permet d'initialiser une table d'états I<state> pour l'utiliser avec B<random>(). La taille I<n> de la table est utilisée par B<initstate>() pour déterminer le niveau de sophistication du générateur de nombre aléatoires. Plus grande est la table d'état, meilleurs seront les nombres aléatoires. I<seed> est la graine utilisée pour l'initialisation, indiquant un point de départ pour la séquence de nombres, et permet de redémarrer au même endroit.

note: type: Plain text
en: The B<setstate>()  function changes the state array used by the B<random>()  function.  The state array I<state> is used for random number generation until the next call to B<initstate>()  or B<setstate>().  I<state> must first have been initialized using B<initstate>()  or be the result of a previous call of B<setstate>().
fr: La fonction B<setstate>() modifie la table d'états utilisée par la fonction B<random>(). La table d'état I<state> est alors utilisée comme générateur de nombres aléatoires jusqu'au prochain appel de B<initstate>() ou B<setstate>(). I<state> doit d'abord être initialisée avec B<initstate>() ou être le résultat d'un appel précédent à B<setstate>()

note: type: Plain text
en: The B<random>()  function returns a value between 0 and B<RAND_MAX>.  The B<srandom>()  function returns no value.
fr: La fonction B<random>() renvoie une valeur entre 0 et B<RAND_MAX>. La fonction B<srandom>() ne renvoie pas de valeur.

note: type: Plain text
en: The B<initstate>()  function returns a pointer to the previous state array.  On error, I<errno> is set to indicate the cause.
fr: La fonction B<initstate>() renvoie un pointeur sur la table d'états précédente. En cas d'échec, I<errno> contient le code d'erreur.

note: type: Plain text
en: On success, B<setstate>()  returns a pointer to the previous state array.  On error, it returns NULL, with I<errno> set to indicate the cause of the error.
fr: La fonction B<setstate>() renvoie un pointeur sur la table d'états précédente. En cas d'échec, NULL est renvoyé et I<errno> contient le code d'erreur.

note: type: Plain text
en: The I<state> argument given to B<setstate>()  was NULL.
fr: Le paramètre I<state> de B<setstate>() était NULL.

note: type: Plain text
en: A state array of less than 8 bytes was specified to B<initstate>().
fr: Une table d'états de moins de 8\ octets a été fournie à B<initstate>().

note: type: Plain text
en: The B<random>(), B<srandom>(), B<initstate>(), and B<setstate>()  functions are thread-safe.
fr: Les fonctions B<random>(), B<srandom>(), B<initstate>() et B<setstate>() sont sûre dans un contexte multithread.

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

note: type: Plain text
en: Current "optimal" values for the size of the state array I<n> are 8, 32, 64, 128, and 256 bytes; other amounts will be rounded down to the nearest known amount.  Using less than 8 bytes will cause an error.
fr: Actuellement, les valeurs optimales I<n>, pour la taille de la table d'états sont 8, 32, 64, 128, et 256\ octets. Les autres valeurs seront arrondies à la taille la plus proche. Essayer d'utiliser moins de 8\ octets déclenche une erreur.

note: type: Plain text
en: This function should not be used in cases where multiple threads use B<random>()  and the behavior should be reproducible.  Use B<random_r>(3)  for that purpose.
fr: Cette fonction ne devrait pas être utilisée si plusieurs threads utilisent B<random>() et si le comportement doit être reproductible. Utilisez B<random_r>(3) dans ce cas.

note: type: Plain text
en: Random-number generation is a complex topic.  I<Numerical Recipes in C: The Art of Scientific Computing> (William H. Press, Brian P. Flannery, Saul A. Teukolsky, William T. Vetterling; New York: Cambridge University Press, 2007, 3rd ed.)  provides an excellent discussion of practical random-number generation issues in Chapter 7 (Random Numbers).
fr: La génération de nombres aléatoires est un sujet complexe. I<Numerical Recipes in C: The Art of Scientific Computing> (William H. Press, Brian P. Flannery, Saul A. Teukolsky, William T. Vetterling; New York: Cambridge University Press, 2007, 3rd ed.) fournit une excellente discussion sur les problèmes pratiques de génération de noms aléatoires dans le chapitre 7 (Random Numbers).

note: type: Plain text
en: For a more theoretical discussion which also covers many practical issues in depth, see Chapter 3 (Random Numbers) in Donald E. Knuth's I<The Art of Computer Programming>, volume 2 (Seminumerical Algorithms), 2nd ed.; Reading, Massachusetts: Addison-Wesley Publishing Company, 1981.
fr: Pour une discussion plus théorique, qui aborde également en profondeur d'autres domaines, voir le chapitre 3 (Random Numbers) du livre de Donald E. Knuth I<The Art of Computer Programming>, volume 2 (Seminumerical Algorithms), 2nd ed.; Reading, Massachusetts: Addison-Wesley Publishing Company, 1981.

note: http://sourceware.org/bugzilla/show_bug.cgi?id=15380 type: Plain text
en: According to POSIX, B<initstate>()  should return NULL on error.  In the glibc implementation, I<errno> is (as specified) set on error, but the function does not return NULL.
fr: D'après POSIX, B<initstate>() devrait renvoyer NULL en cas d'erreur. Dans la mise en œuvre de la glibc, I<errno> est renseigné en cas d'erreur comme spécifié, mais la fonction ne renvoie pas NULL

note: type: Plain text
en: random_r, srandom_r, initstate_r, setstate_r - reentrant random number generator
fr: random_r, srandom_r, initstate_r, setstate_r - Générateur de nombres aléatoires réentrant

note: type: Plain text
en: B<random_r>(), B<srandom_r>(), B<initstate_r>(), B<setstate_r>():
fr: B<random_r>(), B<srandom_r>(), B<initstate_r>(), B<setstate_r>() :

note: type: Plain text
en: These functions are the reentrant equivalents of the functions described in B<random>(3).  They are suitable for use in multithreaded programs where each thread needs to obtain an independent, reproducible sequence of random numbers.
fr: Ces fonctions sont les équivalents réentrants des fonctions décrites dans B<random>(3). Elles sont appropriées à l'utilisation dans des programmes multithreadés où chaque thread doit pouvoir obtenir une séquence indépendante et reproductible de nombres aléatoires.

note: type: Plain text
en: The B<random_r>()  function is like B<random>(3), except that instead of using state information maintained in a global variable, it uses the state information in the argument pointed to by I<buf>.  The generated random number is returned in the argument I<result>.
fr: La fonction B<random_r>() est identique à B<random>(3), excepté qu'au lieu d'utiliser l'information d'état maintenue dans une variable globale, elle utilise l'information d'état située dans l'argument pointé par I<buf>. Le nombre aléatoire généré est renvoyé dans l'argument I<result>.

note: type: Plain text
en: The B<srandom_r>()  function is like B<srandom>(3), except that it initializes the seed for the random number generator whose state is maintained in the object pointed to by I<buf>, instead of the seed associated with the global state variable.
fr: La fonction B<srandom_r>() est identique à B<srandom>(3), excepté qu'elle initialise la graine du générateur de nombre aléatoire dont l'état est maintenu dans l'objet pointé par I<buf>, au lieu de la graine associée à la variable d'état globale.

note: type: Plain text
en: The B<initstate_r>()  function is like B<initstate>(3)  except that it initializes the state in the object pointed to by I<buf>, rather than initializing the global state variable.
fr: La fonction B<initstate_r>() est identique à B<initstate>(3) excepté qu'elle initialise l'état dans l'objet pointé par I<buf>, plutôt que d'initialiser la variable d'état globale.

note: type: Plain text
en: The B<setstate_r>()  function is like B<setstate>(3)  except that it modifies the state in the object pointer to by I<buf>, rather than modifying the global state variable.
fr: La fonction B<setstate_r>() est identique à B<setstate>(3) excepté qu'elle modifie l'état dans l'objet pointé par I<buf>, plutôt que de modifier la variable d'état globale.

note: type: Plain text
en: All of these functions return 0 on success.  On error, -1 is returned, with I<errno> set to indicate the cause of the error.
fr: Toutes ces fonctions renvoient 0 en cas de succès. En cas d'erreur, -1 est renvoyé et I<errno> contient le code de l'erreur.

note: type: Plain text
en: A state array of less than 8 bytes was specified to B<initstate_r>().
fr: Une table d'états de moins de 8\ octets a été fournie à B<initstate_r>().

note: type: Plain text
en: The I<statebuf> or I<buf> argument to B<setstate_r>()  was NULL.
fr: Le paramètre I<statebuf> ou I<buf> de B<setstate_r>() était NULL.

note: type: Plain text
en: The I<buf> or I<result> argument to B<random_r>()  was NULL.
fr: Le paramètre I<buf> ou I<result> de B<random_r>() était NULL.

note: type: Plain text
en: The B<random_r>(), B<srandom_r>(), B<initstate_r>(), and B<setstate_r>()  functions are thread-safe.
fr: Les fonctions B<random_r>(), B<srandom_r>(), B<initstate_r>() et B<setstate_r>() sont sûres dans un contexte multithread.

note: These functions appear to be on Tru64, but don't seem to be on Solaris, HP-UX, or FreeBSD. type: Plain text
en: These functions are nonstandard glibc extensions.
fr: Ces fonctions sont des extensions non standard de la glibc.

note: type: Plain text
en: rpmatch - determine if the answer to a question is affirmative or negative
fr: rpmatch - Déterminer si la réponse à une question est affirmative ou négative

note: type: Plain text
en: B<int rpmatch(const char *>I<response>B<);>
fr: B<int rpmatch(const char *>I<réponse>B<);>

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

note: type: Plain text
en: B<rpmatch>()  handles a user response to yes or no questions, with support for internationalization.
fr: B<rpmatch>() gère une réponse d'un utilisateur à une question oui ou non, avec support pour l'internationalisation.

note: type: Plain text
en: I<response> should be a null-terminated string containing a user-supplied response, perhaps obtained with B<fgets>(3)  or B<getline>(3).
fr: I<réponse> doit être une chaîne de caractères, terminée par le caractère nul, contenant une réponse fournie par un utilisateur, peut-être obtenue avec B<fgets>(3) ou B<getline>(3).

note: type: Plain text
en: The user's language preference is taken into account per the environment variables B<LANG>, B<LC_MESSAGES>, and B<LC_ALL>, if the program has called B<setlocale>(3)  to effect their changes.
fr: La préférence de langue de l'utilisateur est prise en compte par les variables d'environnement B<LANG>, B<LC_MESSAGES> et B<LC_ALL> si le programme a appelé B<setlocale>(3) pour effectuer leurs modifications.

note: type: Plain text
en: Regardless of the locale, responses matching B<^[Yy]> are always accepted as affirmative, and those matching B<^[Nn]> are always accepted as negative.
fr: Quels que soient les paramètres régionaux, les réponses correspondant à B<^[Yy]> sont toujours acceptées comme affirmatives, et celles correspondant à B<^[Nn]> sont toujours acceptées comme négatives.

note: type: Plain text
en: After examining I<response>, B<rpmatch>()  returns 0 for a recognized negative response ("no"), 1 for a recognized positive response ("yes"), and -1 when the value of I<response> is unrecognized.
fr: Après l'examen de I<réponse>, B<rpmatch>() renvoie 0 dans le cas d'une réponse négative («\ Non\ »), 1 dans le cas d'une réponse affirmative («\ Oui\ »), et -1 si la valeur de I<réponse> n'est pas reconnue.

note: type: Plain text
en: A return value of -1 may indicate either an invalid input, or some other error.  It is incorrect to only test if the return value is nonzero.
fr: Une valeur de retour de -1 indique soit une entrée invalide, soit une autre erreur. Il n'est pas correct de ne tester que la non nullité de la valeur de retour.

note: type: Plain text
en: B<rpmatch>()  can fail for any of the reasons that B<regcomp>(3)  or B<regexec>(3)  can fail; the cause of the error is not available from I<errno> or anywhere else, but indicates a failure of the regex engine (but this case is indistinguishable from that of an unrecognized value of I<response>).
fr: B<rpmatch>() peut échouer pour les mêmes raisons que B<regcomp>(3) ou B<regexec>(3) échouerait\ ; la cause de l'erreur n'est pas disponible dans I<errno> ou ailleurs mais indique un échec du moteur d'expressions rationnelles (mais ce cas ne peut pas être distingué de celui d'une valeur de I<réponse> non reconnue).

note: It is available on at least AIX 5.1 and FreeBSD 6.0. type: Plain text
en: B<rpmatch>()  is not required by any standard, but is available on a few other systems.
fr: B<rpmatch>() n'est requise par aucun standard mais est disponible sur quelques autres systèmes.

note: type: Plain text
en: The B<rpmatch>()  implementation looks at only the first character of I<response>.  As a consequence, "nyes" returns 0, and "ynever; not in a million years" returns 1.  It would be preferable to accept input strings much more strictly, for example (using the extended regular expression notation described in B<regex>(7)): B<^([yY]|yes|YES)$> and B<^([nN]|no|NO)$>.
fr: L'implémentation de B<rpmatch>() ne regarde que le premier caractère de I<réponse>. En conséquence, «\ noui\ » renvoie 0 et «\ ynon, jamais, pas dans un million d'années\ » renvoie 1. Il serait préférable d'accepter des chaînes de manière plus stricte, par exemple (en utilisant la notation des expressions rationnelles étendues décrites dans B<regex>(7))\ : B<^([yY]|yes|YES)$> et B<^([nN]|no|NO)$>.

note: type: Plain text
en: The following program displays the results when B<rpmatch>()  is applied to the string given in the program's command-line argument.
fr: Le programme exemple suivant affiche les résultats lorsque B<rpmatch>() est appliqué à la chaîne fournie comme argument de la ligne de commande du programme.

note: type: Plain text
en: int
    main(int argc, char *argv[])
    {
        if (argc != 2 || strcmp(argv[1], "--help") == 0) {
            fprintf(stderr, "%s response\en", argv[0]);
            exit(EXIT_FAILURE);
        }
fr: int
    main(int argc, char *argv[])
    {
        if (argc != 2 || strcmp(argv[1], "--help") == 0) {
            fprintf(stderr, "%s réponse\en", argv[0]);
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     setlocale(LC_ALL, "");
        printf("rpmatch() returns: %d\en", rpmatch(argv[1]));
        exit(EXIT_SUCCESS);
    }
fr:     setlocale(LC_ALL, "");
        printf("rpmatch() a renvoyé\ : %d\en", rpmatch(argv[1]));
        exit(EXIT_SUCCESS);
    }

note: type: TH
en: 2013-10-11
fr: 11 octobre 2013

note: type: Plain text
en: setenv - change or add an environment variable
fr: setenv, unsetenv - Changer ou ajouter une variable d'environnement

note: type: Plain text
en: B<setenv>(), B<unsetenv>():
fr: B<setenv>(), B<unsetenv>() :

note: type: Plain text
en: The B<setenv>()  function adds the variable I<name> to the environment with the value I<value>, if I<name> does not already exist.  If I<name> does exist in the environment, then its value is changed to I<value> if I<overwrite> is nonzero; if I<overwrite> is zero, then the value of I<name> is not changed (and B<setenv>()  returns a success status).  This function makes copies of the strings pointed to by I<name> and I<value> (by contrast with B<putenv>(3)).
fr: La fonction B<setenv>() ajoute la variable I<name> dans l'environnement, en lui attribuant la valeur I<value>, si I<name> n'existe pas encore. Si I<name> existe déjà dans l'environnement, alors sa valeur est modifiée en I<value> si I<overwrite> est non nul\ ; si I<overwrite> vaut zéro, la valeur de I<name> n'est pas modifiée, et B<setenv>() renvoie un code de succès. Cette fonction crée des copies des chaînes pointées par I<name> et I<value> (contrairement à B<putenv>(3)).

note: type: Plain text
en: The B<unsetenv>()  function deletes the variable I<name> from the environment.  If I<name> does not exist in the environment, then the function succeeds, and the environment is unchanged.
fr: La fonction B<unsetenv>() efface la variable I<name> de l'environnement. Si I<name> n'existe pas dans l'environnement, la fonction réussit et l'environnement n'est pas modifié.

note: type: Plain text
en: The B<setenv>()  function returns zero on success, or -1 on error, with I<errno> set to indicate the cause of the error.
fr: La fonction B<setenv>() renvoie zéro si elle réussit, et -1 si elle échoue, auquel cas I<errno> contient le code de l'erreur.

note: type: Plain text
en: The B<unsetenv>()  function returns zero on success, or -1 on error, with I<errno> set to indicate the cause of the error.
fr: La fonction B<unsetenv>() renvoie zéro si elle réussit, et -1 si elle échoue, auquel cas I<errno> contient le code de l'erreur.

note: type: Plain text
en: I<name> is NULL, points to a string of length 0, or contains an \(aq=\(aq character.
fr: I<name> est NULL, pointe vers une chaîne de taille nulle ou contient un caractère «\ =\ ».

note: type: Plain text
en: Insufficient memory to add a new variable to the environment.
fr: Pas assez de mémoire pour ajouter une nouvelle variable à l'environnement.

note: type: Plain text
en: POSIX.1-2001 does not require B<setenv>()  or B<unsetenv>()  to be reentrant.
fr: POSIX.1-2001 n'impose pas que B<setenv>() et B<unsetenv>() soient réentrantes.

note: type: Plain text
en: Prior to glibc 2.2.2, B<unsetenv>()  was prototyped as returning I<void>; more recent glibc versions follow the POSIX.1-2001-compliant prototype shown in the SYNOPSIS.
fr: Avant la glibc 2.2.2, B<unsetenv>() était prototypée pour retourner I<void>\ ; les versions de la glibc plus récentes suivent le prototype conforme à POSIX.1-2001 comme montré dans le SYNOPSIS.

note: type: Plain text
en: POSIX.1-2001 specifies that if I<name> contains an \(aq=\(aq character, then B<setenv>()  should fail with the error B<EINVAL>; however, versions of glibc before 2.3.4 allowed an \(aq=\(aq sign in I<name>.
fr: POSIX.1-2001 indique que si I<name> contient un caractère «\ =\ », alors B<setenv>() devrait échouer avec l'erreur B<EINVAL>\ ; toutefois, les versions antérieures à la glibc 2.3.4 autorisaient l'utilisation du caractère «\ =\ » dans I<name>.

note: type: Plain text
en: strtod, strtof, strtold - convert ASCII string to floating-point number
fr: strtod, strtof, strtold - Convertir une chaîne ASCII en nombre à virgule flottante

note: type: Plain text
en: B<strtof>(), B<strtold>():
fr: B<strtof>(), B<strtold>()\ :

note: type: Plain text
en: The B<strtod>(), B<strtof>(), and B<strtold>()  functions convert the initial portion of the string pointed to by I<nptr> to I<double>, I<float>, and I<long double> representation, respectively.
fr: Les fonctions B<strtod>(), B<strtof>() et B<strtold>() convertissent la portion initiale de la chaîne pointée par I<nptr> en un réel de type I<double>, I<float>, et I<long double> respectivement.

note: type: Plain text
en: The expected form of the (initial portion of the) string is optional leading white space as recognized by B<isspace>(3), an optional plus (\(aq+\(aq) or minus sign (\(aq-\(aq) and then either (i) a decimal number, or (ii) a hexadecimal number, or (iii) an infinity, or (iv) a NAN (not-a-number).
fr: La (portion initiale de la) chaîne attendue est de la forme suivante\ : des espaces éventuels en tête, ou des caractères interprétés comme tels par B<isspace>(3), un éventuel signe plus («\ +\ ») ou moins («\ -\ »), et ensuite soit (i) un nombre décimal, soit (ii) un nombre hexadécimal, soit (iii) un infini, soit (iv) un non nombre NAN (not-a-number).

note: type: Plain text
en: A I<decimal number> consists of a nonempty sequence of decimal digits possibly containing a radix character (decimal point, locale-dependent, usually \(aq.\(aq), optionally followed by a decimal exponent.  A decimal exponent consists of an \(aqE\(aq or \(aqe\(aq, followed by an optional plus or minus sign, followed by a nonempty sequence of decimal digits, and indicates multiplication by a power of 10.
fr: Un I<nombre décimal> consiste en une séquence non vide de chiffres décimaux, pouvant contenir un point décimal (dépendant de la localisation, mais habituellement «\ .\ »), suivi éventuellement d'un exposant décimal. Ce dernier est constitué d'un «\ E\ » ou «\ e\ » suivi éventuellement du signe plus ou du signe moins, puis une séquence non vide de chiffres décimaux, indiquant la multiplication par une puissance de 10.

note: type: Plain text
en: A I<hexadecimal number> consists of a "0x" or "0X" followed by a nonempty sequence of hexadecimal digits possibly containing a radix character, optionally followed by a binary exponent.  A binary exponent consists of a \(aqP\(aq or \(aqp\(aq, followed by an optional plus or minus sign, followed by a nonempty sequence of decimal digits, and indicates multiplication by a power of 2.  At least one of radix character and binary exponent must be present.
fr: Un I<nombre hexadécimal> commence «\ 0x\ » ou «\ 0X\ », suivi d'une séquence non vide de chiffres hexadécimaux, pouvant contenir un point décimal suivi éventuellement d'un exposant binaire. Ce dernier est constitué d'un «\ P\ » ou «\ p\ » suivi éventuellement du signe plus ou du signe moins, puis une séquence non vide de chiffres décimaux, indiquant la multiplication par une puissance de 2. Il ne peut y avoir plus d'un point ou d'un exposant binaire.

note: type: Plain text
en: An I<infinity> is either "INF" or "INFINITY", disregarding case.
fr: Un I<infini> est soit «\ INF\ », soit «\ INFINITY\ », sans tenir compte des différences entre majuscules et minuscules.

note: From glibc 2.8's stdlib/strtod_l.c: We expect it to be a number which is put in the mantissa of the number. type: Plain text
en: A I<NAN> is "NAN" (disregarding case) optionally followed by \(aq(\(aq, a sequence of characters, followed by \(aq)\(aq.  The character string specifies in an implementation-dependent way the type of NAN.
fr: Un I<non-nombre> est «\ NAN\ » (sans différences majuscules/minuscules) suivi éventuellement par «\ (\ », une séquence de caractères, et «\ )\ ». La chaîne de caractères indique le type de non nombre de manière dépendant de l'implémentation.

note: type: Plain text
en: These functions return the converted value, if any.
fr: Ces fonctions renvoient la valeur convertie si c'est possible.

note: type: Plain text
en: If I<endptr> is not NULL, a pointer to the character after the last character used in the conversion is stored in the location referenced by I<endptr>.
fr: Si I<endptr> n'est pas NULL, un pointeur sur le caractère suivant le dernier caractère converti est stocké dans l'emplacement pointé par I<endptr>.

note: type: Plain text
en: If no conversion is performed, zero is returned and the value of I<nptr> is stored in the location referenced by I<endptr>.
fr: Si aucune conversion n'est possible, la fonction renvoie zéro, et la valeur de I<nptr> est stockée dans I<endptr>.

note: type: Plain text
en: If the correct value would cause overflow, plus or minus B<HUGE_VAL> (B<HUGE_VALF>, B<HUGE_VALL>)  is returned (according to the sign of the value), and B<ERANGE> is stored in I<errno>.  If the correct value would cause underflow, zero is returned and B<ERANGE> is stored in I<errno>.
fr: Si la valeur convertie déclenche un débordement (overflow), la fonction renvoie plus ou moins B<HUGE_VAL> (B<HUGE_VALF>, B<HUGE_VALL>) et I<errno> contient le code d'erreur B<ERANGE>. Si la valeur convertie déclenche un débordement inférieur (underflow), la fonction renvoie 0, et I<errno> contient le code d'erreur B<ERANGE>.

note: type: Plain text
en: Overflow or underflow occurred.
fr: Débordement.

note: type: Plain text
en: The B<strtod>(), B<strtof>(), and B<strtold>()  functions are thread-safe with exceptions.  These functions can be safely used in multithreaded applications, as long as B<setlocale>(3)  is not called to change the locale during their execution.
fr: Les fonctions B<strtod>(), B<strtof>() et B<strtold>() sont sûres dans un contexte multithread avec exceptions. Elles peuvent être utilisées de manière sûre tant que B<setlocale>(3) n'est pas appelée pour modifier les paramètres régionaux pendant leur exécution.

note: type: Plain text
en: C89 describes B<strtod>(), C99 describes the other two functions.
fr: C89 décrit B<strtod>(). C99 décrit les deux autres fonctions.

note: type: Plain text
en: Since 0 can legitimately be returned on both success and failure, the calling program should set I<errno> to 0 before the call, and then determine if an error occurred by checking whether I<errno> has a nonzero value after the call.
fr: Comme la valeur 0 peut légitimement être renvoyée à la fois en cas de succès et d'échec, le programme appelant doit positionner I<errno> à 0 avant l'appel, et déterminer si une erreur s'est produite en regardant si I<errno> a une valeur non nulle après l'appel.

note: type: Plain text
en: See the example on the B<strtol>(3)  manual page; the use of the functions described in this manual page is similar.
fr: Consultez l'exemple dans la page de manuel B<strtol>(3)\ ; l'utilisation des fonctions décrites dans cette page de manuel est identique.

note: type: Plain text
en: strtoimax, strtoumax - convert string to integer
fr: strtoimax, strtoumax - Convertir une chaîne de caractères en entier

note: type: Plain text
en: These functions are just like B<strtol>(3)  and B<strtoul>(3), except that they return a value of type I<intmax_t> and I<uintmax_t>, respectively.
fr: Ces fonctions sont similaires à B<strtol>(3) et B<strtoul>(3), excepté qu'elles retournent respectivement une valeur de type I<intmax_t> et I<uintmax_t>.

note: type: Plain text
en: On success, the converted value is returned.  If nothing was found to convert, zero is returned.  On overflow or underflow B<INTMAX_MAX> or B<INTMAX_MIN> or B<UINTMAX_MAX> is returned, and I<errno> is set to B<ERANGE>.
fr: En cas de succès, la valeur convertie est renvoyée. Si rien n'a pu être converti, zéro est renvoyé. En cas de débordement supérieur (overflow) ou inférieur (underflow), une des valeurs B<INTMAX_MAX>, B<INTMAX_MIN> ou B<UINTMAX_MAX> est renvoyée, et I<errno> contient B<ERANGE>.

note: type: Plain text
en: The B<strtoimax>()  and B<strtoumax>()  functions are thread-safe with exceptions.  These functions can be safely used in multithreaded applications, as long as B<setlocale>(3)  is not called to change the locale during their execution.
fr: Les fonctions B<strtoimax>() et B<strtoumax>() sont sûres dans un contexte multithread avec exceptions. Elles peuvent être utilisées de manière sûre tant que B<setlocale>(3) n'est pas appelée pour modifier les paramètres régionaux pendant leur exécution.

note: type: Plain text
en: strtol, strtoll, strtoq - convert a string to a long integer
fr: strtol, strtoll, strtoq - Convertir une chaîne en un entier long

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

note: type: Plain text
en: The B<strtol>()  function converts the initial part of the string in I<nptr> to a long integer value according to the given I<base>, which must be between 2 and 36 inclusive, or be the special value 0.
fr: La fonction B<strtol>() convertit la chaîne I<nptr> en un entier long en fonction de l'argument I<base>, qui doit être dans l'intervalle 2 à 36 (bornes comprises), ou avoir la valeur spéciale 0.

note: type: Plain text
en: The string may begin with an arbitrary amount of white space (as determined by B<isspace>(3))  followed by a single optional \(aq+\(aq or \(aq-\(aq sign.  If I<base> is zero or 16, the string may then include a "0x" prefix, and the number will be read in base 16; otherwise, a zero I<base> is taken as 10 (decimal) unless the next character is \(aq0\(aq, in which case it is taken as 8 (octal).
fr: La chaîne peut commencer par un nombre quelconque d'espaces ou de caractères interprétés comme tels par B<isspace>(3). Un signe éventuel «\ +\ » ou «\ -\ » peut suivre. Si I<base> vaut 0 ou 16, la chaîne peut inclure un préfixe «\ 0x\ » et le nombre sera interprété en base 16. Sinon, une I<base> valant zéro est interprétée comme 10 (décimale) sauf si le caractère suivant est «\ 0\ », auquel cas la base est 8 (octale).

note: type: Plain text
en: The remainder of the string is converted to a I<long int> value in the obvious manner, stopping at the first character which is not a valid digit in the given base.  (In bases above 10, the letter \(aqA\(aq in either uppercase or lowercase represents 10, \(aqB\(aq represents 11, and so forth, with \(aqZ\(aq representing 35.)
fr: Le reste de la chaîne est converti en une valeur I<long int>, en s'arrêtant au premier caractère qui ne soit pas un chiffre valide dans cette base. Dans les bases supérieures à 10, la lettre «\ A\ » (majuscule ou minuscule) représente 10, «\ B\ » représente 11, et ainsi de suite jusqu'à «\ Z\ » représentant 35.

note: type: Plain text
en: If I<endptr> is not NULL, B<strtol>()  stores the address of the first invalid character in I<*endptr>.  If there were no digits at all, B<strtol>()  stores the original value of I<nptr> in I<*endptr> (and returns 0).  In particular, if I<*nptr> is not \(aq\e0\(aq but I<**endptr> is \(aq\e0\(aq on return, the entire string is valid.
fr: Si I<endptr> n'est pas NULL, B<strtol>() stocke l'adresse du premier caractère invalide dans I<*endptr>. S'il n'y avait aucun chiffre valide, B<strtol>() stocke la valeur originale de I<nptr> dans I<*endptr> (et renvoie 0). En particulier, si I<*nptr> n'est pas «\ \e0\ » et si I<**endptr> vaut «\ \e0\ » en retour, la chaîne entière est valide.

note: type: Plain text
en: The B<strtoll>()  function works just like the B<strtol>()  function but returns a long long integer value.
fr: La fonction B<strtoll>() travaille comme B<strtol>() mais renvoie une valeur entière de type "long long".

note: type: Plain text
en: The B<strtol>()  function returns the result of the conversion, unless the value would underflow or overflow.  If an underflow occurs, B<strtol>()  returns B<LONG_MIN>.  If an overflow occurs, B<strtol>()  returns B<LONG_MAX>.  In both cases, I<errno> is set to B<ERANGE>.  Precisely the same holds for B<strtoll>()  (with B<LLONG_MIN> and B<LLONG_MAX> instead of B<LONG_MIN> and B<LONG_MAX>).
fr: La fonction B<strtol>() renvoie le résultat de la conversion, à moins qu'un débordement supérieur (overflow) ou inférieur (underflow) se produise. Si un dépassement inférieur se produit, B<strtol>() renvoie B<LONG_MIN>. Si un dépassement supérieur se produit, B<strtol>() renvoie B<LONG_MAX>. Dans les deux cas, I<errno> contient le code d'erreur B<ERANGE>. La même chose est vraie pour B<strtoll>() avec B<LLONG_MIN> et B<LLONG_MAX> à la place de B<LONG_MIN> et B<LONG_MAX>.

note: type: Plain text
en: (not in C99)  The given I<base> contains an unsupported value.
fr: (pas dans C99) La I<base> indiquée n'est pas supportée.

note: type: Plain text
en: The resulting value was out of range.
fr: La valeur retournée est hors limites.

note: type: Plain text
en: The implementation may also set I<errno> to B<EINVAL> in case no conversion was performed (no digits seen, and 0 returned).
fr: L'implémentation peut aussi mettre I<errno> à B<EINVAL> si aucune conversion n'a été réalisée (pas de chiffres trouvés, et renvoyé zéro).

note: type: Plain text
en: The B<strtol>(), B<strtoll>(), and B<strtoq>()  functions are thread-safe with exceptions.  These functions can be safely used in multithreaded applications, as long as B<setlocale>(3)  is not called to change the locale during their execution.
fr: Les fonctions B<strtol>(), B<strtoll>() et B<strtoq>() sont sûres dans un contexte multithread avec exceptions. Elles peuvent être utilisées de manière sûre tant que B<setlocale>(3) n'est pas appelée pour modifier les paramètres régionaux pendant leur exécution.

note: type: Plain text
en: B<strtol>()  conforms to SVr4, 4.3BSD, C89, C99, and POSIX.1-2001, and B<strtoll>()  to C99 and POSIX.1-2001.
fr: B<strtol>() est conforme à SVr4, BSD\ 4.3, C89, C99 et POSIX.1-2001, et B<strtoll>() à C99 et POSIX.1-2001.

note: type: Plain text
en: Since B<strtol>()  can legitimately return 0, B<LONG_MAX>, or B<LONG_MIN> (B<LLONG_MAX> or B<LLONG_MIN> for B<strtoll>())  on both success and failure, the calling program should set I<errno> to 0 before the call, and then determine if an error occurred by checking whether I<errno> has a nonzero value after the call.
fr: Comme B<strtol>() peut légitimement renvoyer 0, B<LONG_MAX> ou B<LONG_MIN> (B<LLONG_MAX> ou B<LLONG_MIN> pour B<strtoll>()) à la fois en cas de succès et d'échec, le programme appelant doit positionner I<errno> à 0 avant l'appel, et déterminer si une erreur s'est produite en vérifiant si I<errno> a une valeur non nulle après l'appel.

note: type: Plain text
en: According to POSIX.1-2001, in locales other than the "C" and "POSIX", these functions may accept other, implementation-defined numeric strings.
fr: POSIX.1-2001 spécifie que dans le cas de locales autres que « C » et « POSIX », ces fonctions peuvent accepter chaînes numériques propres à l'implémentation.

note: type: Plain text
en: BSD also has
fr: BSD a aussi

note: type: Plain text
en: with completely analogous definition.  Depending on the wordsize of the current architecture, this may be equivalent to B<strtoll>()  or to B<strtol>().
fr: avec une définition exactement analogue. Suivant l'architecture, cela peut être équivalent à B<strtoll>() ou B<strtol>().

note: type: Plain text
en: The program shown below demonstrates the use of B<strtol>().  The first command-line argument specifies a string from which B<strtol>()  should parse a number.  The second (optional) argument specifies the base to be used for the conversion.  (This argument is converted to numeric form using B<atoi>(3), a function that performs no error checking and has a simpler interface than B<strtol>().)  Some examples of the results produced by this program are the following:
fr: Le programme suivant montre l'utilisation de B<strtol>(). Le premier argument de la ligne de commande spécifie une chaîne dans laquelle B<strtol>() analysera un nombre. Le second argument, optionnel, spécifie la base à utiliser pour la conversion. (Cet argument est converti sous forme numérique avec B<atoi>(3), une fonction qui n'effectue aucune vérification d'erreur et qui a une interface plus simple que B<strtol>()). Voici plusieurs exemples de résultats produits par ce programme\ :

note: type: Plain text
en: $B< ./a.out 123>
    strtol() returned 123
    $B< ./a.out \(aq    123\(aq>
    strtol() returned 123
    $B< ./a.out 123abc>
    strtol() returned 123
    Further characters after number: abc
    $B< ./a.out 123abc 55>
    strtol: Invalid argument
    $B< ./a.out \(aq\(aq>
    No digits were found
    $B< ./a.out 4000000000>
    strtol: Numerical result out of range
fr: $B< ./a.out 123>
    strtol() a renvoyé 123
    $B< ./a.out \(aq    123\(aq>
    strtol() a renvoyé 123
    $B< ./a.out 123abc>
    strtol() a renvoyé 123
    Caractères trouvés après le nombre : abc
    $B< ./a.out 123abc 55>
    strtol: Invalid argument
    $B< ./a.out \(aq\(aq>
    Pas de chiffre trouvé
    $B< ./a.out 4000000000>
    strtol: Numerical result out of range

note: type: Plain text
en:     errno = 0;    /* To distinguish success/failure after call */
        val = strtol(str, &endptr, base);
fr:     errno = 0;    /* Pour distinguer la réussite/échec après l'appel */
        val = strtol(str, &endptr, base);

note: type: Plain text
en:     /* Check for various possible errors */
fr:     /* Vérification de certaines erreurs possibles */

note: type: Plain text
en:     if (endptr == str) {
            fprintf(stderr, "No digits were found\en");
            exit(EXIT_FAILURE);
        }
fr:     if (endptr == str) {
            fprintf(stderr, "Pas de chiffre trouvé\en");
            exit(EXIT_FAILURE);
        }

note: type: Plain text
en:     /* If we got here, strtol() successfully parsed a number */
fr:     /* Si nous sommes ici, strtol() a analysé un nombre avec succès */

note: type: Plain text
en:     printf("strtol() returned %ld\en", val);
fr:     printf("strtol() a renvoyé %ld\en", val);

note: type: Plain text
en:     if (*endptr != \(aq\e0\(aq)        /* Not necessarily an error... */
            printf("Further characters after number: %s\en", endptr);
fr:     if (*endptr != \(aq\e0\(aq)        /* Pas nécessairement une erreur... */
            printf("Caractères trouvés après le nombre : %s\en", endptr);

note: type: Plain text
en: strtoul, strtoull, strtouq - convert a string to an unsigned long integer
fr: strtoul, strtoull, strtouq - Convertir une chaîne en entier long non signé

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

note: type: Plain text
en: The B<strtoul>()  function converts the initial part of the string in I<nptr> to an I<unsigned long int> value according to the given I<base>, which must be between 2 and 36 inclusive, or be the special value 0.
fr: La fonction B<strtoul>() convertit le début de la chaîne I<nptr> en une valeur de type I<unsigned long int> en fonction de l'argument I<base>, qui doit être dans l'intervalle 2 à 36 (bornes comprises), ou avoir la valeur spéciale 0.

note: type: Plain text
en: The remainder of the string is converted to an I<unsigned long int> value in the obvious manner, stopping at the first character which is not a valid digit in the given base.  (In bases above 10, the letter \(aqA\(aq in either uppercase or lowercase represents 10, \(aqB\(aq represents 11, and so forth, with \(aqZ\(aq representing 35.)
fr: Le reste de la chaîne est converti en une valeur de type I<unsigned long int>, en s'arrêtant au premier caractère qui ne soit pas un chiffre valable. Dans les bases supérieures à 10, la lettre «\ A\ » (majuscule ou minuscule) représente 10, «\ B\ » représente 11, et ainsi de suite jusqu'à «\ Z\ » représentant 35.

note: type: Plain text
en: If I<endptr> is not NULL, B<strtoul>()  stores the address of the first invalid character in I<*endptr>.  If there were no digits at all, B<strtoul>()  stores the original value of I<nptr> in I<*endptr> (and returns 0).  In particular, if I<*nptr> is not \(aq\e0\(aq but I<**endptr> is \(aq\e0\(aq on return, the entire string is valid.
fr: Si I<endptr> n'est pas NULL, B<strtoul>() stocke l'adresse du premier caractère invalide dans I<*endptr>. S'il n'y avait aucun chiffre valide, B<strtoul>() stocke la valeur originale de I<nptr> dans I<*endptr> (et renvoie 0). En particulier, si I<*nptr> n'est pas \(aq\e0\(aq et si I<**endptr> vaut \(aq\e0\(aq en retour, la chaîne entière est valide.

note: type: Plain text
en: The B<strtoull>()  function works just like the B<strtoul>()  function but returns an I<unsigned long long int> value.
fr: La fonction B<strtoull>() travaille comme B<strtoul>() mais renvoie une valeur entière de type I<unsigned long long int>.

note: type: Plain text
en: The B<strtoul>()  function returns either the result of the conversion or, if there was a leading minus sign, the negation of the result of the conversion represented as an unsigned value, unless the original (nonnegated) value would overflow; in the latter case, B<strtoul>()  returns B<ULONG_MAX> and sets I<errno> to B<ERANGE>.  Precisely the same holds for B<strtoull>()  (with B<ULLONG_MAX> instead of B<ULONG_MAX>).
fr: La fonction B<strtoul>() renvoie soit le résultat de la conversion, soit, s'il y avait un signe moins, l'opposé du résultat de la conversion représentée comme une valeur non signée, à moins que la valeur originale provoque un débordement, auquel cas B<strtoul>() renvoie B<ULONG_MAX> et I<errno> contient le code d'erreur B<ERANGE>. La même chose est vraie pour B<strtoull>() avec B<ULLONG_MAX> à la place de B<ULONG_MAX>.

note: type: Plain text
en: The B<strtoul>(), B<strtoull>(), and B<strtouq>()  functions are thread-safe with exceptions.  These functions can be safely used in multithreaded applications, as long as B<setlocale>(3)  is not called to change the locale during their execution.
fr: Les fonctions B<strtoul>(), B<strtoull>() et B<strtouq>() sont sûres dans un contexte multithread avec exceptions. Elles peuvent être utilisées de manière sûre tant que B<setlocale>(3) n'est pas appelée pour modifier les paramètres régionaux pendant leur exécution.

note: type: Plain text
en: B<strtoul>()  conforms to SVr4, C89, C99, and POSIX-2001, and B<strtoull>()  to C99 and POSIX.1-2001.
fr: B<strtoul>() est conforme à SVr4, C89, C99 et POSIX-2001, et B<strtoull>() à C99 et POSIX.1-2001.

note: type: Plain text
en: Since B<strtoul>()  can legitimately return 0 or B<ULONG_MAX> (B<ULLONG_MAX> for B<strtoull>())  on both success and failure, the calling program should set I<errno> to 0 before the call, and then determine if an error occurred by checking whether I<errno> has a nonzero value after the call.
fr: Comme B<strtoul>() peut légitimement renvoyer 0 ou B<ULONG_MAX> (B<ULLONG_MAX> pour B<strtoull>()) à la fois en cas de succès et d'échec, le programme appelant doit positionner I<errno> à 0 avant l'appel, et déterminer si une erreur s'est produite en regardant si I<errno> a une valeur non nulle après l'appel.

note: type: Plain text
en: In locales other than the "C" locale, other strings may be accepted.  (For example, the thousands separator of the current locale may be supported.)
fr: Dans des localisations autre que «\ C\ », d'autres chaînes peuvent être acceptées. Par exemple, un signe séparateur de milliers pour la localisation actuelle peut être accepté.

note: type: Plain text
en: with completely analogous definition.  Depending on the wordsize of the current architecture, this may be equivalent to B<strtoull>()  or to B<strtoul>().
fr: avec une définition exactement analogue. Suivant l'architecture, cela peut être équivalent à B<strtoull>() ou B<strtoul>().

note: type: Plain text
en: Negative values are considered valid input and are silently converted to the equivalent I<unsigned long int> value.
fr: Des valeurs négatives sont considérées comme valides, et sont converties en une valeur de type I<unsigned long int> équivalente sans avertissement.

note: type: TH
en: 2010-09-10
fr: 10 septembre 2010

note: type: Plain text
en: system - execute a shell command
fr: system - Exécuter une commande shell

note: type: Plain text
en: B<system>()  executes a command specified in I<command> by calling B</bin/sh -c> I<command>, and returns after the command has been completed.  During execution of the command, B<SIGCHLD> will be blocked, and B<SIGINT> and B<SIGQUIT> will be ignored.
fr: La fonction B<system>() exécute la commande indiquée dans I<command> en appelant B</bin/sh -c> I<command>, et revient après l'exécution complète de la commande. Durant cette exécution, le signal B<SIGCHLD> est bloqué, et les signaux B<SIGINT> et B<SIGQUIT> sont ignorés.

note: type: Plain text
en: The value returned is -1 on error (e.g., B<fork>(2)  failed), and the return status of the command otherwise.  This latter return status is in the format specified in B<wait>(2).  Thus, the exit code of the command will be I<WEXITSTATUS(status)>.  In case I</bin/sh> could not be executed, the exit status will be that of a command that does I<exit(127)>.
fr: La valeur renvoyée est -1 en cas d'erreur (par exemple échec de B<fork>(2)) ou le code de retour de la commande en cas de succès. Ce dernier code est dans le format indiqué dans B<wait>(2). Ainsi, le retour de la commande sera I<WEXITSTATUS(status)>. Dans le cas où I</bin/sh> ne peut pas être exécuté, le code de retour sera identique à celui d'une commande effectuant un I<exit(127)>.

note: type: Plain text
en: If the value of I<command> is NULL, B<system>()  returns nonzero if the shell is available, and zero if not.
fr: Si la valeur de I<command> est NULL, B<system>() renvoie une valeur non nulle si le shell est accessible, et zéro sinon.

note: type: Plain text
en: B<system>()  does not affect the wait status of any other children.
fr: B<system>() n'affecte pas l'état d'attente des autres processus fils.

note: type: Plain text
en: If the B<_XOPEN_SOURCE> feature test macro is defined (before including I<any> header files), then the macros described in B<wait>(2)  (B<WEXITSTATUS>(), etc.) are made available when including I<E<lt>stdlib.hE<gt>>.
fr: Si la macro de test de fonctionnalité B<_XOPEN_SOURCE> est définie (avant d'inclure I<tout> fichier d'en\(hytête), les macros décrites dans B<wait>(2) (B<WEXITSTATUS>(), etc.) sont disponibles en incluant I<E<lt>stdlib.hE<gt>>.

note: type: Plain text
en: As mentioned, B<system>()  ignores B<SIGINT> and B<SIGQUIT>.  This may make programs that call it from a loop uninterruptible, unless they take care themselves to check the exit status of the child.  E.g.
fr: Comme mentionné plus haut, B<system>() ignore B<SIGINT> et B<SIGQUIT>. Un programme qui l'appelle en boucle risque de ne pas pouvoir être interrompu, à moins qu'il ne vérifie le code de retour du fils, par exemple

note: type: Plain text
en:     while (something) {
            int ret = system("foo");
fr:     while (qqchose) {
            int ret = system("foo");

note: type: Plain text
en: Do not use B<system>()  from a program with set-user-ID or set-group-ID privileges, because strange values for some environment variables might be used to subvert system integrity.  Use the B<exec>(3)  family of functions instead, but not B<execlp>(3)  or B<execvp>(3).  B<system>()  will not, in fact, work properly from programs with set-user-ID or set-group-ID privileges on systems on which I</bin/sh> is bash version 2, since bash 2 drops privileges on startup.  (Debian uses a modified bash which does not do this when invoked as B<sh>.)
fr: N'utilisez jamais B<system>() dans un programme avec les privilèges Set-UID ou Set-GID. Des variables d'environnement avec des valeurs étranges peuvent être utilisées pour corrompre l'intégrité du système. Utilisez les fonctions de la famille B<exec>(3) à la place, mais pas B<execlp>(3) ni B<execvp>(3). B<system>() ne fonctionnera pas correctement avec les programmes ayant des privilèges fournis par les bits Set-UID ou Set-GID sur les systèmes où I</bin/sh> est bash version 2, car celui-ci rejette les privilèges au démarrage (Debian utilise une version modifiée de bash où ce comportement est abandonné si on l'invoque sous le nom B<sh>).

note: type: Plain text
en: In versions of glibc before 2.1.3, the check for the availability of I</bin/sh> was not actually performed if I<command> was NULL; instead it was always assumed to be available, and B<system>()  always returned 1 in this case.  Since glibc 2.1.3, this check is performed because, even though POSIX.1-2001 requires a conforming implementation to provide a shell, that shell may not be available or executable if the calling program has previously called B<chroot>(2)  (which is not specified by POSIX.1-2001).
fr: Avec les versions de la glibc antérieures à 2.1.3, la vérification de la disponibilité de I</bin/sh> n'était pas faite lorsque I<command> était NULL. Il était toujours supposé être disponible, et B<system>() renvoyait toujours 1 dans ce cas. Depuis glibc 2.1.3, cette vérification est effectuée, car, même si POSIX.1-2001 impose aux implémentations conformes de fournir un shell, ce shell peut ne pas être opérationnel si le programme appelant a auparavant appelé B<chroot>(2) (ce qui n'est pas spécifié dans POSIX.1-2001).

note: type: Plain text
en: It is possible for the shell command to return 127, so that code is not a sure indication that the B<execve>(2)  call failed.
fr: Il est possible qu'une commande shell renvoie 127, ainsi le code de retour n'est pas une indication sûre de l'échec de B<execve>(2).

note: type: TH
en: 2014-02-01
fr: 1er février 2014

note: type: Plain text
en: vDSO - overview of the virtual ELF dynamic shared object
fr: vDSO - Panorama de l’objet partagé dynamique ELF virtuel

note: type: Plain text
en: The "vDSO" (virtual dynamic shared object) is a small shared library that the kernel automatically maps into the address space of all user-space applications.  Applications usually do not need to concern themselves with these details as the vDSO is most commonly called by the C library.  This way you can code in the normal way using standard functions and the C library will take care of using any functionality that is available via the vDSO.
fr: Le « vDSO » (objet partagé dynamique virtuel, « virtual dynamic shared object ») est une petite bibliothèque partagée que le noyau projette automatiquement dans l’espace d’adresses de toutes les applications en espace utilisateur. Les applications n’ont normalement pas besoin de s’occuper elles-mêmes de ces détails puisque le vDSO est d’habitude appelée par la bibliothèque C. Ainsi, vous pouvez écrire du code normalement en utilisant les fonctions standards et la bibliothèque C s’occupera d’utiliser toutes les fonctionnalités disponibles par l’intermédiaire du vDSO.

note: type: Plain text
en: Why does the vDSO exist at all? There are some system calls the kernel provides that user-space code ends up using frequently, to the point that such calls can dominate overall performance.  This is due both to the frequency of the call as well as the context-switch overhead that results from exiting user space and entering the kernel.
fr: Pourquoi le vDSO existe ? Certains appels système fournis par le noyau finissent par être utilisés fréquemment par le code en espace utilisateur, au point que ces appels peuvent avoir une emprise excessive sur les performances. C’est à la fois dû à la fréquence des appels qu’aux nombreux changements de contexte à force de sortir de l’espace utilisateur pour entrer dans le noyau.

note: type: Plain text
en: The rest of this documentation is geared toward the curious and/or C library writers rather than general developers.  If you're trying to call the vDSO in your own application rather than using the C library, you're most likely doing it wrong.
fr: La suite de cette documentation est orientée pour les curieux et les auteurs de la bibliothèque C plutôt que pour les développeurs généraux. Si vous essayez d’appeler la vDSO dans vos propres applications plutôt que d’utiliser la bibliothèque C, vous faites sans doute fausse route.

note: type: SS
en: Example background
fr: Contexte exemple

note: type: Plain text
en: Making system calls can be slow.  In x86 32-bit systems, you can trigger a software interrupt (I<int $0x80>)  to tell the kernel you wish to make a system call.  However, this instruction is expensive: it goes through the full interrupt-handling paths in the processor's microcode as well as in the kernel.  Newer processors have faster (but backward incompatible) instructions to initiate system calls.  Rather than require the C library to figure out if this functionality is available at run time, the C library can use functions provided by the kernel in the vDSO.
fr: Réaliser des appels système peut être lent. Dans les systèmes 32 bits x86, vous pouvez déclencher une interruption logicielle (I<int $0x80>) pour indiquer au noyau que vous voulez faire un appel système. Cependant, cette instruction est coûteuse : elle passe par tous les chemins complets de traitement des interruptions dans le microcode du processeur ainsi que dans le noyau. Les nouveaux processeurs ont des instructions plus rapides (mais non rétrocompatibles) pour initier les appels système. Plutôt que forcer la bibliothèque C à vérifier si cette fonctionnalité est disponible au moment de l’exécution, la bibliothèque C peut utiliser les fonctions fournies par le noyau dans le vDSO.

note: type: Plain text
en: Note that the terminology can be confusing.  On x86 systems, the vDSO function used to determine the preferred method of making a system call is named "__kernel_vsyscall", but on x86_64, the term "vsyscall" also refers to an obsolete way to ask the kernel what time it is or what CPU the caller is on.
fr: Remarquez que cette terminologie peut être source de confusion. Sur les systèmes x86, la fonction vDSO utilisée pour déterminer la méthode préférée pour réaliser un appel système est appelée « __kernel_vsyscall » alors que sous x86_64, le terme « vsyscall » se réfère aussi à une façon obsolète de demander au noyau l’heure ou le processeur sur lequel est l’appelant.

note: type: Plain text
en: One frequently used system call is B<gettimeofday>(2).  This system call is called both directly by user-space applications as well as indirectly by the C library.  Think timestamps or timing loops or polling\(emall of these frequently need to know what time it is right now.  This information is also not secret\(emany application in any privilege mode (root or any unprivileged user) will get the same answer.  Thus the kernel arranges for the information required to answer this question to be placed in memory the process can access.  Now a call to B<gettimeofday>(2)  changes from a system call to a normal function call and a few memory accesses.
fr: Un appel système fréquemment utilisé est B<gettimeofday>(2). Cet appel système est appelé à la fois directement par les applications en espace utilisateur et indirectement par la bibliothèque C. Remarquez que les horodatages, boucles temporelles ou scrutations — qui ont tous fréquemment besoin de savoir l’heure exacte. Ce n’est pas non plus un secret — de n’importe quelle application dans n’importe quel mode (superutilisateur ou utilisateur normal) auront tous la même réponse. Alors le noyau s’arrange pour que les informations nécessaires pour répondre à cette question soient placées dans la mémoire accessible au processus. Ainsi un appel de B<gettimeofday>(2) est transformé d’un appel système en un appel normal de fonction, avec un peu d’accès mémoire.

note: type: SS
en: Finding the vDSO
fr: Trouver le vDSO

note: type: Plain text
en: The base address of the vDSO (if one exists) is passed by the kernel to each program in the initial auxiliary vector (see B<getauxval>(3)), via the B<AT_SYSINFO_EHDR> tag.
fr: L’adresse de base du vDSO (s’il existe) est passée par le noyau à tous les programmes dans le vecteur auxiliaire initial (consultez B<getauxval>(3)) à l’aide du type B<AT_SYSINFO_EHDR>.

note: type: Plain text
en: You must not assume the vDSO is mapped at any particular location in the user's memory map.  The base address will usually be randomized at run time every time a new process image is created (at B<execve>(2)  time).  This is done for security reasons, to prevent "return-to-libc" attacks.
fr: Vous ne devez pas supposer que le vDSO est projeté à un endroit particulier de la projection en mémoire de l’utilisateur. L’adresse de base sera normalement aléatoire au moment de l’exécution à chaque fois qu’une nouvelle image de processus est créée (au moment de B<execve>(2)). C’est ainsi pour des raisons de sécurité, afin d’éviter les attaques de « retour vers libc ».

note: type: Plain text
en: For some architectures, there is also an B<AT_SYSINFO> tag.  This is used only for locating the vsyscall entry point and is frequently omitted or set to 0 (meaning it's not available).  This tag is a throwback to the initial vDSO work (see I<History> below) and its use should be avoided.
fr: Pour certaines architectures, un type B<AT_SYSINFO> est aussi présent. Il n’est utilisé que pour localiser le point d’entrée vsyscall et est souvent omis ou défini à 0 (signifiant qu’il n’est pas disponible). Ce type est un rappel du fonctionnement initial de vDSO (consultez I<Historique> ci-dessous) et son utilisation devrait être évitée.

note: type: SS
en: File format
fr: Format de fichier

note: type: Plain text
en: Since the vDSO is a fully formed ELF image, you can do symbol lookups on it.  This allows new symbols to be added with newer kernel releases, and allows the C library to detect available functionality at run time when running under different kernel versions.  Oftentimes the C library will do detection with the first call and then cache the result for subsequent calls.
fr: Puisque le vDSO est une image ELF complète, vous pouvez y rechercher des symboles. Cela permet d’ajouter de nouveaux symboles avec les versions de noyau plus récentes et permet à la bibliothèque C de détecter les fonctionnalités disponibles au moment de l’exécution lors de l’exécution sous différentes versions de noyau. D’habitude, la bibliothèque C fera la détection lors du premier appel puis mettra en cache le résultat pour les appels suivants.

note: type: Plain text
en: All symbols are also versioned (using the GNU version format).  This allows the kernel to update the function signature without breaking backward compatibility.  This means changing the arguments that the function accepts as well as the return value.  Thus, when looking up a symbol in the vDSO, you must always include the version to match the ABI you expect.
fr: Tous les appels sont aussi versionnés (en utilisant le format de version GNU). Cela permet au noyau de mettre à jour la signature de fonction sans casser la rétrocompatibilité. Cela signifie modifier les arguments acceptés par la fonction et la valeur de retour. Ainsi, lors de la recherche de symboles dans le vDSO, vous devez toujours inclure la version pour correspondre à l’ABI attendue.

note: type: Plain text
en: Typically the vDSO follows the naming convention of prefixing all symbols with "__vdso_" or "__kernel_" so as to distinguish them from other standard symbols.  For example, the "gettimeofday" function is named "__vdso_gettimeofday".
fr: Typiquement, la vDSO suit la convention de nommage de préfixer tous les symboles par « __vdso_ » ou « __kernel_ » afin de les distinguer des autres symboles standards. Par exemple, la fonction « gettimeofday » est nommée « __vdso_gettimeofday ».

note: type: Plain text
en: You use the standard C calling conventions when calling any of these functions.  No need to worry about weird register or stack behavior.
fr: Utilisez les conventions d’appel C standard pour appeler n’importe laquelle de ces fonctions. Pas la peine de vous embêter avec les registres bizarres ou les comportements de pile.

note: type: Plain text
en: When you compile the kernel, it will automatically compile and link the vDSO code for you.  You will frequently find it under the architecture-specific directory:
fr: Lors de la compilation du noyau, le code vDSO est compilé et lié automatiquement. Il se trouve souvent dans le répertoire spécifique à l’architecture :

note: type: SS
en: vDSO names
fr: Noms vDSO

note: type: Plain text
en: The name of the vDSO varies across architectures.  It will often show up in things like glibc's B<ldd>(1)  output.  The exact name should not matter to any code, so do not hardcode it.
fr: Le nom du vDSO dépend des architectures. Il est souvent visible dans des endroits comme la sortie de B<ldd>(1) de la glibc. Le nom exact ne devrait affecter aucun code, donc pas la peine de le coder en dur.

note: type: tbl table
en: user ABI	vDSO name
fr: ABI utilisateur	nom vDSO

note: type: SH
en: ARCHITECTURE-SPECIFIC NOTES
fr: NOTES SPÉCIFIQUES AUX ARCHITECTURES

note: type: Plain text
en: The subsections below provide architecture-specific notes on the vDSO.
fr: Les sous-sections suivantes fournissent des notes spécifiques aux architectures sur le vDSO.

note: type: Plain text
en: Note that the vDSO that is used is based on the ABI of your user-space code and not the ABI of the kernel.  Thus, for example, when you run an i386 32-bit ELF binary, you'll get the same vDSO regardless of whether you run it under an i386 32-bit kernel or under an x86_64 64-bit kernel.  Therefore, the name of the user-space ABI should be used to determine which of the sections below is relevant.
fr: Remarquez que le vDSO utilisé est basé sur l’ABI du code en espace utilisateur et non sur l’ABI du noyau. Ainsi, par exemple, si vous exécutez un binaire ELF 32 bits i386, vous obtiendrez le même vDSO que vous l’exécutiez avec un noyau 32 bits i386 ou avec un noyau 64 bits x86_64. Par conséquent, le nom de l’ABI en espace utilisateur devrait être utilisé pour déterminer la section suivante adéquate.

note: type: SS
en: ARM functions
fr: Fonctions ARM

note: See linux/arch/arm/kernel/entry-armv.S See linux/Documentation/arm/kernel_user_helpers.txt type: Plain text
en: The ARM port has a code page full of utility functions.  Since it's just a raw page of code, there is no ELF information for doing symbol lookups or versioning.  It does provide support for different versions though.
fr: Le portage ARM a une page de code pleine de fonctions utilitaires. Puisque ce n’est qu’une page de code brut, aucune information ELF n’existe pour faire de la recherche de symboles ou du versionnement. Elle fournit cependant une prise en charge pour plusieurs versions.

note: type: Plain text
en: For information on this code page, it's best to refer to the kernel documentation as it's extremely detailed and covers everything you need to know: I<Documentation/arm/kernel_user_helpers.txt>.
fr: Pour des renseignements sur cette page de code, mieux vaut consulter la documentation du noyau puisqu’elle est extrêmement détaillée et couvre tous ce que vous devez savoir : I<Documentation/arm/kernel_user_helpers.txt>.

note: type: SS
en: aarch64 functions
fr: Fonctions aarch64

note: See linux/arch/x86/vdso/vdso32.lds.S type: Plain text
en: The table below lists the symbols exported by the vDSO.
fr: Le tableau suivant indique les symboles exportés par le vDSO.

note: type: tbl table
en: symbol	version
fr: symbole	version

note: type: SS
en: bfin (Blackfin) functions
fr: Fonctions bfin (Blackfin)

note: See linux/arch/blackfin/kernel/fixed_code.S See http://docs.blackfin.uclinux.org/doku.php?id=linux-kernel:fixed-code type: Plain text
en: As this CPU lacks a memory management unit (MMU), it doesn't set up a vDSO in the normal sense.  Instead, it maps at boot time a few raw functions into a fixed location in memory.  User-space applications then call directly into that region.  There is no provision for backward compatibility beyond sniffing raw opcodes, but as this is an embedded CPU, it can get away with things\(emsome of the object formats it runs aren't even ELF based (they're bFLT/FLAT).
fr: Comme ce processeur n’a pas d’unité de gestion mémoire (MMU), il ne définit pas de vDSO au sens usuel. À la place, il projette au démarrage quelques fonctions brutes à un endroit spécifique de la mémoire. Les applications en espace utilisateur appellent ensuite directement dans cette zone. Aucune mesure de rétrocompatibilité n’est prise à part en sniffant les codes opératoires bruts, mais comme il s’agit d’un processeur embarqué, il peut s’en sortir impunément – certains formats d’objet qu’il exécute ne sont même pas basés sur ELF (ils sont bFLT/FLAT).

note: type: Plain text
en: For information on this code page, it's best to refer to the public documentation:
fr: Pour des renseignements sur cette page de code, mieux vaut consulter la documentation publique :

note: type: SS
en: ia64 (Itanium) functions
fr: Fonctions ia64 (Itanium)

note: type: Plain text
en: The Itanium port is somewhat tricky.  In addition to the vDSO above, it also has "light-weight system calls" (also known as "fast syscalls" or "fsys").  You can invoke these via the I<__kernel_syscall_via_epc> vDSO helper.  The system calls listed here have the same semantics as if you called them directly via B<syscall>(2), so refer to the relevant documentation for each.  The table below lists the functions available via this mechanism.
fr: Le portage Itanium est un peu périlleux. En plus du vDSO ci-dessus, il a aussi des « appels système légers » (aussi appelés « appels système rapides » ou « fsys »). Ils peuvent être appelés en à l’aide de l’assistant vDSO I<__kernel_syscall_via_epc>. Les appels système indiqués ici ont la même sémantique que si vous les appeliez directement à l’aide de B<syscall>(2), donc consultez la documentation adéquate pour chacun d’entre eux. Le tableau suivant indique les fonctions disponibles par ce mécanisme.

note: type: tbl table
en: function
fr: fonction

note: type: SS
en: parisc (hppa) functions
fr: Fonctions parisc (hppa)

note: See linux/arch/parisc/kernel/syscall.S See linux/Documentation/parisc/registers type: Plain text
en: The parisc port has a code page full of utility functions called a gateway page.  Rather than use the normal ELF auxiliary vector approach, it passes the address of the page to the process via the SR2 register.  The permissions on the page are such that merely executing those addresses automatically executes with kernel privileges and not in user space.  This is done to match the way HP-UX works.
fr: Le portage parisc à une page de code pleine de fonctions utilitaires appelée une page passerelle. Plutôt que d’utiliser l’approche classique du vecteur auxiliaire ELF, il passe l’adresse de la page au processus à l’aide du registre SR2. Les permissions sur la page sont telles qu’exécuter simplement ces adresses s’exécute automatiquement avec les droits du noyau et pas en espace utilisateur. C’est ainsi afin de correspondre au mode de fonctionnement HP-UX.

note: type: Plain text
en: Since it's just a raw page of code, there is no ELF information for doing symbol lookups or versioning.  Simply call into the appropriate offset via the branch instruction, for example:
fr: Puisque ce n’est qu’une page de code brut, aucune information ELF n’existe pour faire de la recherche de symboles ou du versionnement. Appelez simplement l’adresse adéquate à l’aide de l’instruction de branche, par exemple :

note: type: Plain text
en:     ble E<lt>offsetE<gt>(%sr2, %r0)
fr:     ble E<lt>adresseE<gt>(%sr2, %r0)

note: type: tbl table
en: offset	function
fr: adresse	fonction

note: type: SS
en: ppc/32 functions
fr: Fonctions ppc/32

note: See linux/arch/powerpc/kernel/vdso32/vdso32.lds.S type: Plain text
en: The table below lists the symbols exported by the vDSO.  The functions marked with a I<*> are available only when the kernel is a PowerPC64 (64-bit) kernel.
fr: Le tableau suivant indique les symboles exportés par le vDSO. Les fonctions marquées avec un I<*> ne sont disponibles que si le noyau est PowerPC64 (64 bits).

note: type: SS
en: ppc/64 functions
fr: Fonctions ppc/64

note: type: SS
en: s390 functions
fr: Fonctions s390

note: type: SS
en: s390x functions
fr: Fonctions s390x

note: type: SS
en: sh (SuperH) functions
fr: Fonctions sh (SuperH)

note: type: SS
en: i386 functions
fr: Fonctions i386

note: type: SS
en: x86_64 functions
fr: Fonctions x86_64

note: See linux/arch/x86/vdso/vdso.lds.S type: Plain text
en: The table below lists the symbols exported by the vDSO.  All of these symbols are also available without the "__vdso_" prefix, but you should ignore those and stick to the names below.
fr: Le tableau suivant indique les symboles exportés par le vDSO. Tous ces symboles sont aussi disponibles sans le préfixe « __vdso_ », mais vous devriez les ignorer et vous cantonner aux noms suivants.

note: type: SS
en: x86/x32 functions
fr: Fonctions x86/x32

note: type: SS
en: History
fr: Historique

note: type: Plain text
en: The vDSO was originally just a single function\(emthe vsyscall.  In older kernels, you might see that name in a process's memory map rather than "vdso".  Over time, people realized that this mechanism was a great way to pass more functionality to user space, so it was reconceived as a vDSO in the current format.
fr: Le vDSO n’était à l’origine qu’une seule fonction — le vsyscall. Dans les anciens noyaux, ce nom pourrait être vu dans une projection en mémoire de processus à la place de « vdso ». Le temps passant, les gens ont réalisé que ce mécanisme était un excellent moyen pour passer plus de fonctionnalités à l’espace utilisateur, il a donc été reconçu en tant que vDSO au format actuel.

note: type: Plain text
en: The documents, examples, and source code in the Linux source code tree:
fr: Les documents, exemples et le code source dans l’arborescence du code source de Linux :

note: type: Plain text
en: Documentation/ABI/stable/vdso
    Documentation/ia64/fsys.txt
    Documentation/vDSO/* (includes examples of using the vDSO)
fr: Documentation/ABI/stable/vdso
    Documentation/ia64/fsys.txt
    Documentation/vDSO/* (contient des exemples d’utilisation du vDSO)

note: type: Plain text
en: wcstombs - convert a wide-character string to a multibyte string
fr: wcstombs - Convertir une chaîne de caractères étendus en chaîne de caractères multioctets

note: type: Plain text
en: If I<dest> is not NULL, the B<wcstombs>()  function converts the wide-character string I<src> to a multibyte string starting at I<dest>.  At most I<n> bytes are written to I<dest>.  The conversion starts in the initial state.  The conversion can stop for three reasons:
fr: Si I<dest> n'est pas un pointeur NULL, la fonction B<wcstombs>() convertit la chaîne de caractères larges I<src> vers la séquence multioctet située en I<dest>. Au plus I<n> octets seront écrits dans I<dest>. La conversion débute dans l'état initial. La conversion peut se terminer pour trois raisons\ :

note: type: Plain text
en: 1. A wide character has been encountered that can not be represented as a multibyte sequence (according to the current locale).  In this case, I<(size_t)\ -1> is returned.
fr: 1. Un caractère large que l'on ne peut pas représenter par une séquence multioctet (dans la locale utilisée) a été rencontré. Dans ce cas, la fonction renverra I<(size_t)\ -1>.

note: type: Plain text
en: 2. The length limit forces a stop.  In this case, the number of bytes written to I<dest> is returned, but the shift state at this point is lost.
fr: 2. La limite de longueur force l'arrêt. Dans ce cas, le nombre d'octets écrits dans I<dest> est renvoyé, mais l'état de décalage est perdu.

note: type: Plain text
en: 3. The wide-character string has been completely converted, including the terminating null wide character (L\(aq\e0\(aq).  In this case, the conversion ends in the initial state.  The number of bytes written to I<dest>, excluding the terminating null byte (\(aq\e0\(aq), is returned.
fr: 3. La chaîne de caractères larges a été complètement convertie, y compris le L\(aq\e0\(aq final. Dans ce cas, la conversion se termine dans l'état initial. La fonction renvoie le nombre d'octets écrits dans I<dest>, sans compter l'octet nul («\ \e0\ ») final.

note: type: Plain text
en: The programmer must ensure that there is room for at least I<n> bytes at I<dest>.
fr: Le programmeur doit s'assurer qu'il y a assez de place pour au moins I<n> octets au minimum dans I<dest>.

note: type: Plain text
en: If I<dest> is NULL, I<n> is ignored, and the conversion proceeds as above, except that the converted bytes are not written out to memory, and no length limit exists.
fr: Si I<dest> est NULL, la longueur I<n> est ignorée, et la conversion se déroule comme précédemment, sauf que les octets convertis ne sont pas écrits en mémoire et qu’aucune limite de longueur n’existe en destination.

note: type: Plain text
en: In order to avoid the case 2 above, the programmer should make sure I<n> is greater than or equal to I<wcstombs(NULL,src,0)+1>.
fr: Pour éviter le cas 2 ci-dessus, le programmeur doit s'assurer que I<n> est supérieur ou égal à I<wcstombs(NULL,src,0)+1>.

note: type: Plain text
en: The B<wcstombs>()  function returns the number of bytes that make up the converted part of a multibyte sequence, not including the terminating null byte.  If a wide character was encountered which could not be converted, I<(size_t)\ -1> is returned.
fr: La fonction B<wcstombs>() renvoie le nombre d'octets constituant la partie convertie d’une séquence multioctet, sans compter l'octet NULL final. Si elle rencontre un caractère large qu'elle ne peut convertir, elle renvoie I<(size_t)\ -1>.

note: type: Plain text
en: The behavior of B<wcstombs>()  depends on the B<LC_CTYPE> category of the current locale.
fr: Le comportement de B<wcstombs>() dépend de la catégorie B<LC_CTYPE> de la locale utilisée.

note: type: Plain text
en: The function B<wcsrtombs>(3)  provides a thread safe interface to the same functionality.
fr: La fonction B<wcsrtombs>(3) fournit une interface sûre en contexte multithread pour la même fonctionnalité.

note: type: Plain text
en: wctomb - convert a wide character to a multibyte sequence
fr: wctomb - Convertir un caractère large en séquence multioctet

note: type: Plain text
en: If I<s> is not NULL, the B<wctomb>()  function converts the wide character I<wc> to its multibyte representation and stores it at the beginning of the character array pointed to by I<s>.  It updates the shift state, which is stored in a static anonymous variable known only to the B<wctomb>()  function, and returns the length of said multibyte representation, that is, the number of bytes written at I<s>.
fr: Si I<s> n'est pas NULL, la fonction B<wctomb>() convertit le caractère large I<wc> dans sa représentation multioctet et le stocke au début de la chaîne de caractères pointée par I<s>. Elle met à jour l'état de décalage, variable statique anonyme connue uniquement d'elle-même, et renvoie la longueur de la représentation multioctet, c'est-à-dire le nombre d'octets écrits dans I<s>.

note: type: Plain text
en: The programmer must ensure that there is room for at least B<MB_CUR_MAX> bytes at I<s>.
fr: Le programmeur doit s'assurer qu'il y a assez de place pour au moins B<MB_CUR_MAX> octets au moins dans I<s>.

note: The Dinkumware doc and the Single UNIX specification say this, but glibc doesn't implement this. type: Plain text
en: If I<s> is NULL, the B<wctomb>()  function resets the shift state, known only to this function, to the initial state, and returns nonzero if the encoding has nontrivial shift state, or zero if the encoding is stateless.
fr: Si I<s> est NULL, la fonction B<wctomb>() réinitialise l'état de décalage, connu seulement de cette fonction, à sa valeur initiale et renvoie une valeur non nulle si l'encodage a un état de décalage non trivial, ou zéro si l'encodage est sans état.

note: type: Plain text
en: If I<s> is not NULL, the B<wctomb>()  function returns the number of bytes that have been written to the byte array at I<s>.  If I<wc> can not be represented as a multibyte sequence (according to the current locale), -1 is returned.
fr: Si I<s> n'est pas NULL, la fonction B<wctomb>() renvoie le nombre d'octets qui ont été écrits dans le tableau d'octets à l'adresse I<s>. Si I<wc> ne peut pas être représenté par une séquence multioctet (d'après la locale utilisée), elle renvoie -1.

note: type: Plain text
en: If I<s> is NULL, the B<wctomb>()  function returns nonzero if the encoding has nontrivial shift state, or zero if the encoding is stateless.
fr: Si I<s> est NULL, la fonction B<wctomb>() renvoie une valeur non nulle si l'encodage a un état de décalage non trivial, ou zéro si l'encodage est sans état.

note: type: Plain text
en: The B<wctomb>()  function is not thread-safe.
fr: La fonction B<wctomb>() n'est pas sûre dans un contexte multithread.

note: type: Plain text
en: The behavior of B<wctomb>()  depends on the B<LC_CTYPE> category of the current locale.
fr: Le comportement de B<wctomb>() dépend de la catégorie B<LC_CTYPE> de la locale utilisée.

note: type: Plain text
en: The function B<wcrtomb>(3)  provides a better interface to the same functionality.
fr: La fonction B<wcrtomb>(3) fournit une meilleure interface pour la même fonctionnalité.
