perkamon - en to fr translation catalogue (339 entries)

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

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: bcmp - compare byte sequences
fr: bcmp - Comparaison de séquences d'octets

note: type: Plain text
en: The B<bcmp>()  function compares the two byte sequences I<s1> and I<s2> of length I<n> each.  If they are equal, and in particular if I<n> is zero, B<bcmp>()  returns 0.  Otherwise it returns a nonzero result.
fr: La fonction B<bcmp>() compare les séquences d'octets I<s1> et I<s2> de même longueur I<n>. Si elles sont égales, et en particulier si I<n> est nul, B<bcmp>() renvoie zéro. Sinon une valeur non nulle est renvoyée.

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

note: type: Plain text
en: The B<bcmp>()  function returns 0 if the byte sequences are equal, otherwise a nonzero result is returned.
fr: La fonction B<bcmp>() renvoie 0 si les séquences d'octets sont égales, et une valeur non nulle sinon.

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

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

note: type: Plain text
en: 4.3BSD.  This function is deprecated (marked as LEGACY in POSIX.1-2001): use B<memcmp>(3)  in new programs.  POSIX.1-2008 removes the specification of B<bcmp>().
fr: BSD\ 4.3. Cette fonction est déconseillée (marquée «\ LEGACY\ » dans POSIX.1-2001), utilisez plutôt B<memcmp>(3) pour de nouveaux programmes. POSIX.1-2008 supprime la spécification de B<bcmp>().

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

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

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

note: type: Plain text
en: bcopy - copy byte sequence
fr: bcopy - Copier une séquence d'octets

note: type: Plain text
en: The B<bcopy>()  function copies I<n> bytes from I<src> to I<dest>.  The result is correct, even when both areas overlap.
fr: La fonction B<bcopy>() copie I<n> octets depuis I<src> vers I<dest>. Le résultat est correct même si les deux zones se chevauchent.

note: type: Plain text
en: None.
fr: Aucune.

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

note: type: Plain text
en: 4.3BSD.  This function is deprecated (marked as LEGACY in POSIX.1-2001): use B<memcpy>(3)  or B<memmove>(3)  in new programs.  Note that the first two arguments are interchanged for B<memcpy>(3)  and B<memmove>(3).  POSIX.1-2008 removes the specification of B<bcopy>().
fr: BSD\ 4.3. Cette fonction est déconseillée (marquée «\ LEGACY\ » dans POSIX.1-2001), utilisez plutôt B<memcpy>(3) ou B<memmove>(3) dans de nouveaux programmes. Notez que les deux premiers paramètres sont inversés par rapport à B<memcpy>(3) et B<memmove>(3). POSIX.1-2008 supprime la spécification de B<bcopy>().

note: type: TH
en: 2002-01-20
fr: 20 janvier 2002

note: type: Plain text
en: bcmp, bcopy, bzero, memccpy, memchr, memcmp, memcpy, memfrob, memmem, memmove, memset - byte string operations
fr: bcmp, bcopy, bzero, memccpy, memchr, memcmp, memcpy, memfrob, memmem, memmove, memset - Opérations sur des chaînes d'octets

note: type: Plain text
en: The byte string functions perform operations on strings (byte arrays)  that are not necessarily null-terminated.  See the individual man pages for descriptions of each function.
fr: Ces fonctions agissent sur des chaînes d'octets (tableaux d'octets) qui ne se terminent pas nécessairement par le caractère nul. Reportez-vous aux pages de manuel de chaque fonction pour obtenir leur description.

note: The old functions are not even available on some non-GNU/Linux systems. type: Plain text
en: The functions B<bcmp>(), B<bcopy>()  and B<bzero>()  are obsolete.  Use B<memcmp>(), B<memcpy>()  and B<memset>()  instead.
fr: Les fonctions B<bcmp>(), B<bcopy>() et B<bzero>() sont obsolètes. Utilisez B<memcmp>(), B<memcpy>() et B<memset>() à la place.

note: type: Plain text
en: bzero - write zero-valued bytes
fr: bzero - Écrire des zéros dans un bloc d'octets

note: type: Plain text
en: The B<bzero>()  function sets the first I<n> bytes of the area starting at I<s> to zero (bytes containing \(aq\e0\(aq).
fr: La fonction B<bzero>() met à 0 les I<n> premiers octets du bloc pointé par I<s> (octets contenant «\ \e0\ »).

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

note: type: Plain text
en: 4.3BSD.  This function is deprecated (marked as LEGACY in POSIX.1-2001): use B<memset>(3)  in new programs.  POSIX.1-2008 removes the specification of B<bzero>().
fr: BSD\ 4.3. Cette fonction est déconseillée (marquée «\ LEGACY\ » dans POSIX.1-2001), utilisez B<memset>(3) dans les nouveaux programmes. POSIX.1-2008 supprime la spécification de B<bzero>().

note: type: TH
en: 2014-04-14
fr: 14 avril 2014

note: type: Plain text
en: ffs, ffsl, ffsll - find first bit set in a word
fr: ffs, ffsl, ffsll - Chercher le premier bit à 1 dans un mot

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

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: none
fr: aucune

note: type: Plain text
en: B<ffsl>(), B<ffsll>():
fr: B<ffsl>(), B<ffsll>() :

note: type: Plain text
en: The B<ffs>()  function returns the position of the first (least significant) bit set in the word I<i>.  The least significant bit is position 1 and the most significant position is, for example, 32 or 64.  The functions B<ffsll>()  and B<ffsl>()  do the same but take arguments of possibly different size.
fr: La fonction B<ffs>() renvoie la position du premier bit à 1 (le moins significatif) dans le mot I<i>. Le bit le moins significatif est en position 1, et le plus significatif par exemple en position 32 ou 64. Les fonctions B<ffsll>() et B<ffsl>() effectuent la même chose mais leur argument peut être de taille différente.

note: type: Plain text
en: These functions return the position of the first bit set, or 0 if no bits are set in I<i>.
fr: Ces fonctions renvoient la position du premier bit à 1, ou 0 si aucun bit n'est positionné à 1 dans I<i>.

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

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

note: type: Plain text
en: The B<ffsl>()  and B<ffsll>()  functions are glibc extensions.
fr: Les fonctions B<ffsl>() et B<ffsll>() sont des extensions de la glibc.

note: type: Plain text
en: BSD systems have a prototype in I<E<lt>string.hE<gt>>.
fr: Les systèmes BSD définissent le prototype de cette fonction dans I<E<lt>string.hE<gt>>.

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

note: type: Plain text
en: index, rindex - locate character in string
fr: index, rindex - Recherche de caractères dans une chaîne

note: type: Plain text
en: The B<index>()  function returns a pointer to the first occurrence of the character I<c> in the string I<s>.
fr: La fonction B<index>() renvoie un pointeur sur la première occurrence du caractère I<c> dans la chaîne I<s>.

note: type: Plain text
en: The B<rindex>()  function returns a pointer to the last occurrence of the character I<c> in the string I<s>.
fr: La fonction B<rindex>() renvoie un pointeur sur la dernière occurrence du caractère I<c> dans la chaîne I<s>.

note: type: Plain text
en: The terminating null byte (\(aq\e0\(aq) is considered to be a part of the strings.
fr: Le caractère nul final (« \e0 ») est considéré comme faisant partie de la chaîne.

note: type: Plain text
en: The B<index>()  and B<rindex>()  functions return a pointer to the matched character or NULL if the character is not found.
fr: Les fonctions B<index>() et B<rindex>() renvoient un pointeur sur le caractère correspondant, ou NULL si le caractère n'est pas trouvé.

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

note: type: Plain text
en: 4.3BSD; marked as LEGACY in POSIX.1-2001.  POSIX.1-2008 removes the specifications of B<index>()  and B<rindex>(), recommending B<strchr>(3)  and B<strrchr>(3)  instead.
fr: BSD\ 4.3 ; marquée « LEGACY » dans POSIX.1-2001. POSIX.1-2008 supprime les spécifications de B<index>() et B<rindex>() et recommande à la place  B<strchr>(3) et B<strrchr>(3).

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

note: type: Plain text
en: memccpy - copy memory area
fr: memccpy - Copie de zone mémoire

note: type: Plain text
en: The B<memccpy>()  function copies no more than I<n> bytes from memory area I<src> to memory area I<dest>, stopping when the character I<c> is found.
fr: La fonction B<memccpy>() copie au plus I<n> octets de la zone mémoire I<src> vers la zone mémoire I<dest>, s'arrêtant dès qu'elle rencontre le caractère I<c>.

note: type: Plain text
en: If the memory areas overlap, the results are undefined.
fr: Si les zones mémoires se chevauchent, le résultat est indéfini.

note: type: Plain text
en: The B<memccpy>()  function returns a pointer to the next character in I<dest> after I<c>, or NULL if I<c> was not found in the first I<n> characters of I<src>.
fr: La fonction B<memccpy>() renvoie un pointeur sur le caractère immédiatement après I<c> dans la zone I<dest>, ou NULL si I<c> n'a pas été trouvé dans les I<n> premiers caractères de I<src>.

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

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

note: type: Plain text
en: memchr, memrchr, rawmemchr - scan memory for a character
fr: memchr, memrchr, rawmemchr - Rechercher un caractère dans une zone mémoire

note: type: Plain text
en: B<memrchr>(), B<rawmemchr>(): _GNU_SOURCE
fr: B<memrchr>(), B<rawmemchr>() : _GNU_SOURCE

note: type: Plain text
en: The B<memchr>()  function scans the initial I<n> bytes of the memory area pointed to by I<s> for the first instance of I<c>.  Both I<c> and the bytes of the memory area pointed to by I<s> are interpreted as I<unsigned char>.
fr: La fonction B<memchr>() examine les I<n> premiers octets de la zone mémoire pointée par I<s> à la recherche de la première occurrence de I<c>. À la fois I<s> et les octets de la zone mémoire pointée par I<s> sont interprétés comme des I<unsigned char>.

note: type: Plain text
en: The B<memrchr>()  function is like the B<memchr>()  function, except that it searches backward from the end of the I<n> bytes pointed to by I<s> instead of forward from the beginning.
fr: La fonction B<memrchr>() travaille comme B<memchr>(), sauf qu'elle recherche en arrière depuis la fin de la zone de I<n> octets pointée par I<s> plutôt que depuis le début.

note: type: Plain text
en: The B<rawmemchr>()  function is similar to B<memchr>(): it assumes (i.e., the programmer knows for certain)  that an instance of I<c> lies somewhere in the memory area starting at the location pointed to by I<s>, and so performs an optimized search for I<c> (i.e., no use of a count argument to limit the range of the search).  If an instance of I<c> is not found, the results are unpredictable.  The following call is a fast means of locating a string's terminating null byte:
fr: La fonction B<rawmemchr>() est semblable à B<memchr>() : elle suppose (c'est-à-dire que le développeur en est sûr) qu'une occurrence de I<c> se trouve quelque part dans la zone de mémoire qui commence à l'endroit pointé par I<s> et fait ainsi une recherche optimisée de I<c> (c'est-à-dire sans utiliser d'argument de comptage pour limiter la longueur de la recherche). Si aucune occurrence de I<c> n'est trouvée les résultats sont imprévisibles. L'appel suivant est une manière rapide pour trouver le caractère nul de fin d'une chaîne :

note: type: Plain text
en: The B<memchr>()  and B<memrchr>()  functions return a pointer to the matching byte or NULL if the character does not occur in the given memory area.
fr: Les fonctions B<memchr>() et B<memrchr>() renvoient un pointeur sur l'octet correspondant, ou NULL si le caractère n'est pas présent dans la zone de mémoire concernée.

note: type: Plain text
en: The B<rawmemchr>()  function returns a pointer to the matching byte, if one is found.  If no matching byte is found, the result is unspecified.
fr: La fonction B<rawmemchr>() renvoie un pointeur sur l'octet correspondant, s'il est trouvé. Si aucun caractère correspondant n'est trouvé, le résultat n'est pas spécifié.

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

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

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

note: type: Plain text
en: The B<memchr>()  function conforms to SVr4, 4.3BSD, C89, C99, POSIX.1-2001.
fr: La fonction B<memchr>() se conforme à SVr4, BSD 4.3, C89, C99 et POSIX.1-2001.

note: type: Plain text
en: The B<memrchr>()  function is a GNU extension, available since glibc 2.1.91.
fr: La fonction B<memrchr>() est une extension GNU disponible depuis la glibc\ 2.1.91.

note: type: Plain text
en: The B<rawmemchr>()  function is a GNU extension, available since glibc 2.1.
fr: La fonction B<rawmemchr>() est une extension GNU disponible depuis la glibc\ 2.1.

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

note: type: Plain text
en: memcmp - compare memory areas
fr: memcmp - Comparaison de zones mémoire

note: type: Plain text
en: The B<memcmp>()  function compares the first I<n> bytes (each interpreted as I<unsigned char>)  of the memory areas I<s1> and I<s2>.
fr: La fonction B<memcmp>() compare les I<n> premiers octets (chacun interprété comme I<unsigned char>) des zones mémoire I<s1> et I<s2>.

note: type: Plain text
en: The B<memcmp>()  function returns an integer less than, equal to, or greater than zero if the first I<n> bytes of I<s1> is found, respectively, to be less than, to match, or be greater than the first I<n> bytes of I<s2>.
fr: La fonction B<memcmp>() renvoie un entier négatif, nul ou positif si les I<n> premiers octets de I<s1> sont respectivement inférieurs, égaux ou supérieurs aux I<n> premiers octets de I<s2>.

note: type: Plain text
en: For a nonzero return value, the sign is determined by the sign of the difference between the first pair of bytes (interpreted as I<unsigned char>)  that differ in I<s1> and I<s2>.
fr: Lorsque le code retour est différent de zéro, son signe dépend de celui de la différence entre les deux premiers octets (interprétés comme  I<unsigned char>) qui diffèrent dans I<s1> et I<s2>.

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

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: TH
en: 2014-03-17
fr: 17 mars 2014

note: type: Plain text
en: memcpy - copy memory area
fr: memcpy - Copier une zone mémoire

note: type: Plain text
en: The B<memcpy>()  function copies I<n> bytes from memory area I<src> to memory area I<dest>.  The memory areas must not overlap.  Use B<memmove>(3)  if the memory areas do overlap.
fr: La fonction B<memcpy>() copie I<n> octets depuis la zone mémoire I<src> vers la zone mémoire I<dest>. Les deux zones ne doivent pas se chevaucher. Si c'est le cas, utilisez plutôt B<memmove>(3).

note: type: Plain text
en: The B<memcpy>()  function returns a pointer to I<dest>.
fr: La fonction B<memcpy>() renvoie un pointeur sur I<dest>.

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

note: type: Plain text
en: memfrob - frobnicate (encrypt) a memory area
fr: memfrob - Crypter une zone de mémoire

note: type: Plain text
en: The B<memfrob>()  function encrypts the first I<n> bytes of the memory area I<s> by exclusive-ORing each character with the number 42.  The effect can be reversed by using B<memfrob>()  on the encrypted memory area.
fr: La fonction B<memfrob>() chiffre les I<n> premiers octets de la zone de mémoire I<s> en effectuant un OU-exclusif entre chaque octet et le nombre 42. L'effet inverse est obtenu en rappelant à nouveau B<memfrob>() sur la zone chiffrée.

note: type: Plain text
en: Note that this function is not a proper encryption routine as the XOR constant is fixed, and is suitable only for hiding strings.
fr: Notez que cette fonction n'est pas vraiment un cryptage, car la constante du OU exclusif est fixe. Elle est simplement utile pour cacher des chaînes de texte clair.

note: type: Plain text
en: The B<memfrob>()  function returns a pointer to the encrypted memory area.
fr: La fonction B<memfrob>() renvoie un pointeur sur la zone mémoire chiffrée.

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

note: type: Plain text
en: The B<memfrob>()  function is unique to the GNU C Library.
fr: La fonction B<memfrob>() est spécifique à la bibliothèque GNU\ C.

note: type: Plain text
en: memmem - locate a substring
fr: memmem - Rechercher une sous-chaîne

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

note: type: Plain text
en: The B<memmem>()  function finds the start of the first occurrence of the substring I<needle> of length I<needlelen> in the memory area I<haystack> of length I<haystacklen>.
fr: La fonction B<memmem>() recherche le début de la première occurrence de la sous-chaîne I<needle> (NdT : aiguille) de longueur I<needlelen> au sein de la zone de mémoire I<haystack> (NdT : meule de foin) de longueur I<haystacklen>.

note: type: Plain text
en: The B<memmem>()  function returns a pointer to the beginning of the substring, or NULL if the substring is not found.
fr: La fonction B<memmem>() renvoie un pointeur sur le début de la sous-chaîne, ou NULL si aucune sous-chaîne n'est trouvée.

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

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

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: This function was broken in Linux libraries up to and including libc 5.0.9; there the I<needle> and I<haystack> arguments were interchanged, and a pointer to the end of the first occurrence of I<needle> was returned.
fr: Cette fonction ne fonctionnait pas avec les bibliothèques Linux jusqu'à libc\ 5.0.9 incluse, car les arguments I<needle> et I<haystack> étaient inversés. De plus, la fonction renvoyait un pointeur sur la fin de la première occurrence de I<needle> renvoyée.

note: type: Plain text
en: Both old and new libc's have the bug that if I<needle> is empty, I<haystack-1> (instead of I<haystack>)  is returned.  And glibc 2.0 makes it worse, returning a pointer to the last byte of I<haystack>.  This is fixed in glibc 2.1.
fr: Un bogue supplémentaire existe dans toutes les bibliothèques libc\ : si I<needle> est vide, la fonction renvoie I<haystack-1> (au lieu de I<haystack>). La bibliothèque glibc\ 2.0 était encore pire, puisqu'elle renvoyait un pointeur sur le dernier octet de I<haystack>. Cela a été corrigé dans la glib\ 2.1

note: type: Plain text
en: memmove - copy memory area
fr: memmove - Copier une zone mémoire

note: type: Plain text
en: The B<memmove>()  function copies I<n> bytes from memory area I<src> to memory area I<dest>.  The memory areas may overlap: copying takes place as though the bytes in I<src> are first copied into a temporary array that does not overlap I<src> or I<dest>, and the bytes are then copied from the temporary array to I<dest>.
fr: La fonction B<memmove>() copie I<n> octets depuis la zone mémoire I<src> vers la zone mémoire I<dest>. Les deux zones peuvent se chevaucher\ : la copie s'effectue comme si I<src> était premièrement copiée dans un tableau temporaire ne chevauchant pas I<src> ou I<dest> puis il est copié vers I<dest>.

note: type: Plain text
en: The B<memmove>()  function returns a pointer to I<dest>.
fr: La fonction B<memmove>() renvoie un pointeur sur I<dest>.

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

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

note: type: Plain text
en: mempcpy, wmempcpy - copy memory area
fr: mempcpy, wmempcpy - Copier une zone mémoire

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<mempcpy>()  function is nearly identical to the B<memcpy>(3)  function.  It copies I<n> bytes from the object beginning at I<src> into the object pointed to by I<dest>.  But instead of returning the value of I<dest> it returns a pointer to the byte following the last written byte.
fr: La fonction B<mempcpy>() est quasiment identique à la fonction B<memcpy>(3). Elle copie I<n> octets à partir de l'objet commençant à I<src> dans l'objet pointé par I<dest>. Mais plutôt que de retourner la valeur de I<dest>, elle retourne un pointeur sur l'octet suivant le dernier octet écrit.

note: type: Plain text
en: This function is useful in situations where a number of objects shall be copied to consecutive memory positions.
fr: Cette fonction est pratique dans les situations où plusieurs objets doivent être copiés dans des positions consécutives en mémoire.

note: type: Plain text
en: The B<wmempcpy>()  function is identical but takes I<wchar_t> type arguments and copies I<n> wide characters.
fr: La fonction B<wmempcpy>() est identique mais prend des arguments de type I<wchar_t> et copie I<n> caractères larges.

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

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

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: memset - fill memory with a constant byte
fr: memset - Remplir une zone mémoire avec un octet donné

note: type: Plain text
en: The B<memset>()  function fills the first I<n> bytes of the memory area pointed to by I<s> with the constant byte I<c>.
fr: La fonction B<memset>() remplit les I<n> premiers octets de la zone mémoire pointée par I<s> avec l'octet I<c>.

note: type: Plain text
en: The B<memset>()  function returns a pointer to the memory area I<s>.
fr: La fonction B<memset>() renvoie un pointeur sur la zone mémoire I<s>.

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

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

note: type: Plain text
en: stpcpy - copy a string returning a pointer to its end
fr: stpcpy - Copier une chaîne en renvoyant un pointeur sur sa fin

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

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

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

note: type: Plain text
en: The B<stpcpy>()  function copies the string pointed to by I<src> (including the terminating null byte (\(aq\e0\(aq)) to the array pointed to by I<dest>.  The strings may not overlap, and the destination string I<dest> must be large enough to receive the copy.
fr: La fonction B<stpcpy>() copie la chaîne pointée par I<src> (y compris l'octet nul («\ \e0\ ») final) dans le tableau pointé par I<dest>. Les deux chaînes ne doivent pas se chevaucher. La chaîne I<dest> doit être assez grande pour accueillir la copie.

note: type: Plain text
en: B<stpcpy>()  returns a pointer to the B<end> of the string I<dest> (that is, the address of the terminating null byte)  rather than the beginning.
fr: B<stpcpy>() renvoie un pointeur sur la B<fin> de la chaîne I<dest> (c'est-à dire l'adresse du caractère nul final) au lieu du début.

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

note: type: Plain text
en: This function was added to POSIX.1-2008.  Before that, it was not part of the C or POSIX.1 standards, nor customary on UNIX systems, but was not a GNU invention either.  Perhaps it came from MS-DOS.  It is also present on the BSDs.
fr: Cette fonction a été ajoutée à POSIX.1-2008. Avant cela, elle ne faisait partie ni de la norme C ni de POSIX.1, et n'était pas spécifique UNIX, mais n'était pas non plus une extension GNU. Peut-être venait-elle de l'environnement MS-DOS. Elle est également présente sur les BSDs.

note: type: Plain text
en: This function may overrun the buffer I<dest>.
fr: Cette fonction peut écraser des octets en dehors de I<dest>.

note: type: Plain text
en: For example, this program uses B<stpcpy>()  to concatenate B<foo> and B<bar> to produce B<foobar>, which it then prints.
fr: Par exemple, ce programme utilise B<stpcpy>() pour concaténer B<foo> et B<bar> produisant ainsi B<foobar>, qui est alors affichée.

note: type: Plain text
en: stpncpy - copy a fixed-size string, returning a pointer to its end
fr: stpncpy - Copier une chaîne de taille fixe et pointer sur sa fin

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

note: type: Plain text
en: The B<stpncpy>()  function copies at most I<n> characters from the string pointed to by I<src>, including the terminating null byte (\(aq\e0\(aq), to the array pointed to by I<dest>.  Exactly I<n> characters are written at I<dest>.  If the length I<strlen(src)> is smaller than I<n>, the remaining characters in the array pointed to by I<dest> are filled with null bytes (\(aq\e0\(aq), If the length I<strlen(src)> is greater than or equal to I<n>, the string pointed to by I<dest> will not be null-terminated.
fr: La fonction B<stpncpy>() copie au plus I<n> caractères depuis la chaîne pointée par I<src>, y compris l'octet nul («\ \e0\ ») final dans le tableau pointé par I<dest>. Exactement I<n> caractères sont écrits dans I<dest>. Si la longueur I<strlen(src)> est plus petite que I<n>, les caractères restant dans le tableau pointé par I<dest> sont remplis d'octets nuls («\ \e0\ »). Si la longueur I<strlen(src)> est supérieure ou égale à I<n>, la chaîne pointée par I<dest> ne sera pas terminée par un octet nul final.

note: type: Plain text
en: The strings may not overlap.
fr: Les chaînes ne doivent pas se chevaucher.

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

note: type: Plain text
en: B<stpncpy>()  returns a pointer to the terminating null byte in I<dest>, or, if I<dest> is not null-terminated, I<dest>+I<n>.
fr: B<stpncpy>() renvoie un pointeur sur l'octet nul final dans I<dest>, ou si I<dest> n'a pas de caractère nul final, I<dest>+I<n>.

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

note: type: Plain text
en: This function was added to POSIX.1-2008.  Before that, it was a GNU extension.
fr: Cette fonction a été ajoutée à POSIX.1-2008. Avant cela, c'était une extension GNU.

note: type: TH
en: 2012-05-10
fr: 10 mai 2012

note: type: Plain text
en: strcasecmp, strncasecmp - compare two strings ignoring case
fr: strcasecmp, strncasecmp - Comparer deux chaînes en ignorant les différences majuscules/minuscules

note: type: Plain text
en: The B<strcasecmp>()  function compares the two strings I<s1> and I<s2>, ignoring the case of the characters.  It returns an integer less than, equal to, or greater than zero if I<s1> is found, respectively, to be less than, to match, or be greater than I<s2>.
fr: La fonction B<strcasecmp>() compare les deux chaînes I<s1> et I<s2>, en ignorant les différences entre majuscules et minuscules. Elle renvoie un entier négatif, nul, ou positif, si la chaîne I<s1> est respectivement inférieure, égale ou supérieure à I<s2>.

note: type: Plain text
en: The B<strncasecmp>()  function is similar, except it compares the only first I<n> bytes of I<s1>.
fr: La fonction B<strncasecmp>() est similaire, à la différence qu'elle ne prend en compte que les I<n> premiers octets de I<s1>.

note: type: Plain text
en: The B<strcasecmp>()  and B<strncasecmp>()  functions return an integer less than, equal to, or greater than zero if I<s1> (or the first I<n> bytes thereof) is found, respectively, to be less than, to match, or be greater than I<s2>.
fr: Les fonctions B<strcasecmp>() et B<strncasecmp>() renvoient un entier inférieur, égal ou supérieur à zéro si I<s1> (ou éventuellement ses I<n> premiers octets) est inférieure, égale ou supérieure à I<s2>.

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

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

note: type: Plain text
en: strcat, strncat - concatenate two strings
fr: strcat, strncat - Concaténer deux chaînes

note: type: Plain text
en: The B<strcat>()  function appends the I<src> string to the I<dest> string, overwriting the terminating null byte (\(aq\e0\(aq) at the end of I<dest>, and then adds a terminating null byte.  The strings may not overlap, and the I<dest> string must have enough space for the result.  If I<dest> is not large enough, program behavior is unpredictable; I<buffer overruns are a favorite avenue for attacking secure programs>.
fr: La fonction B<strcat>() ajoute la chaîne I<src> à la fin de la chaîne I<dest> en écrasant l'octet nul («\ \e0\ ») final à la fin de I<dest>, puis en ajoutant un nouvel octet nul final. Les chaînes ne doivent pas se chevaucher, et la chaîne I<dest> doit être assez grande pour accueillir le résultat. Si I<dest> n'est pas assez grande, le comportement du programme est imprévisible. I<Les dépassements de tampon font partie des moyens préférés pour attaquer les programmes sécurisés>.

note: type: Plain text
en: The B<strncat>()  function is similar, except that
fr: La fonction B<strncat>() est similaire, à la différence que :

note: type: Plain text
en: it will use at most I<n> bytes from I<src>; and
fr: elle ne prend en compte que les I<n> premiers octets de I<src>.

note: type: Plain text
en: I<src> does not need to be null-terminated if it contains I<n> or more bytes.
fr: I<src> n'a pas besoin de se terminer par un caractère nul si elle contient au moins I<n> octets.

note: type: Plain text
en: As with B<strcat>(), the resulting string in I<dest> is always null-terminated.
fr: Comme pour B<strcat>(), la chaîne résultante dans I<dest> est toujours terminée par un caractère nul.

note: type: Plain text
en: If I<src> contains I<n> or more bytes, B<strncat>()  writes I<n+1> bytes to I<dest> (I<n> from I<src> plus the terminating null byte).  Therefore, the size of I<dest> must be at least I<strlen(dest)+n+1>.
fr: Si I<src> contient au moins I<n> octets, B<strncat>() écrit I<n+1> octets dans I<dest> (I<n> octets de I<src> plus le caractère nul final). De ce fait, I<dest> doit être au moins de taille I<strlen(dest)+n+1>.

note: type: Plain text
en: A simple implementation of B<strncat>()  might be:
fr: Une implémentation simple de B<strncat>() pourrait être :

note: type: Plain text
en: The B<strcat>()  and B<strncat>()  functions return a pointer to the resulting string I<dest>.
fr: Les fonctions B<strcat>() et B<strncat>() renvoient un pointeur sur la chaîne résultat I<dest>.

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

note: type: Plain text
en: SVr4, 4.3BSD, C89, C99.
fr: SVr4, BSD\ 4.3, C89, C99.

note: type: Plain text
en: Some systems (the BSDs, Solaris, and others) provide the following function:
fr: Certains systèmes (BSD, Solaris et autres) fournissent la fonction suivante :

note: https://lwn.net/Articles/506530/ type: Plain text
en: This function appends the null-terminated string I<src> to the string I<dest>, copying at most I<size-strlen(dest)-1> from I<src>, and adds a null terminator to the result, I<unless> I<size> is less than I<strlen(dest)>.  This function fixes the buffer overrun problem of B<strcat>(), but the caller must still handle the possibility of data loss if I<size> is too small.  The function returns the length of the string B<strlcat>()  tried to create; if the return value is greater than or equal to I<size>, data loss occurred.  If data loss matters, the caller I<must> either check the arguments before the call, or test the function return value.  B<strlcat>()  is not present in glibc and is not standardized by POSIX, but is available on Linux via the I<libbsd> library.
fr: Cette fonction ajoute la chaîne I<src>, terminée par un caractère nul, à la chaîne I<dest> en copiant au plus I<size-strlen(dest)-1> depuis I<src> et ajoute un caractère nul en fin de chaîne au résultat I<sauf> si I<size> est inférieur à I<strlen(dest)>. Cette fonction corrige le problème de dépassement de tampon de B<strcat>(), mais l'appelant doit quand même gérer la possibilité de pertes de données si I<size> est trop petit. La fonction renvoie la longueur de la chaîne que B<strlcat>() a essayé de créer. Si la valeur renvoyée est supérieure à I<size>, c'est qu'il y a eu perte de données. Si les pertes de données sont problématiques, l'appelant I<doit> soit vérifier les arguments avant l'appel, soit tester la valeur de retour de la fonction. B<strlcat>() n'existe pas dans glibc et n'est pas normalisé par POSIX, mais est disponible sous Linux avec la bibliothèque I<libbsd>.

note: type: Plain text
en: strchr, strrchr, strchrnul - locate character in string
fr: strchr, strrchr, strchrnul - Rechercher un caractère dans une chaîne

note: type: Plain text
en: The B<strchr>()  function returns a pointer to the first occurrence of the character I<c> in the string I<s>.
fr: La fonction B<strchr>() renvoie un pointeur sur la première occurrence du caractère I<c> dans la chaîne I<s>.

note: type: Plain text
en: The B<strrchr>()  function returns a pointer to the last occurrence of the character I<c> in the string I<s>.
fr: La fonction B<strrchr>() renvoie un pointeur sur la dernière occurrence du caractère I<c> dans la chaîne I<s>.

note: type: Plain text
en: The B<strchrnul>()  function is like B<strchr>()  except that if I<c> is not found in I<s>, then it returns a pointer to the null byte at the end of I<s>, rather than NULL.
fr: La fonction B<strchrnul>() est comme B<strchr>(), sauf que si I<c> n'est pas trouvé dans I<s>, alors elle retourne un pointeur sur l'octet nul à la fin de I<s>, au lieu de NULL.

note: type: Plain text
en: Here "character" means "byte"; these functions do not work with wide or multibyte characters.
fr: Pour ces fonctions, «\ caractère\ » signifie «\ octet\ »\ ; elles ne marchent pas avec des caractères larges ou multioctets.

note: type: Plain text
en: The B<strchr>()  and B<strrchr>()  functions return a pointer to the matched character or NULL if the character is not found.  The terminating null byte is considered part of the string, so that if I<c> is specified as \(aq\e0\(aq, these functions return a pointer to the terminator.
fr: Les fonctions B<strchr>() et B<strrchr>() renvoient un pointeur sur le caractère correspondant, ou NULL si le caractère n'a pas été trouvé. L'octet nul final est considéré comme faisant partie de la chaîne, de telle sorte que si « \e0 » est indiqué pour I<c>, ces fonctions renvoient un pointeur sur la fin de chaîne.

note: type: Plain text
en: The B<strchrnul>()  function returns a pointer to the matched character, or a pointer to the null byte at the end of I<s> (i.e., I<s+strlen(s)>)  if the character is not found.
fr: La fonction B<strchrnul>() renvoie un pointeur sur le caractère correspondant, ou un pointeur sur le caractère nul terminant I<s> (c'est-à-dire I<s+strlen(s)>) si le caractère n'a pas été trouvé.

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

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

note: type: Plain text
en: B<strchr>()  and B<strrchr>()  are in SVr4, 4.3BSD, C89, C99.  B<strchrnul>()  is a GNU extension.
fr: B<strchr>() et B<strrchr>() sont présents dans SVr4, BSD 4.3, C89 et C99. B<strchrnul>() est une extension GNU.

note: type: Plain text
en: strcmp, strncmp - compare two strings
fr: strcmp, strncmp - Comparaison de deux chaînes

note: type: Plain text
en: The B<strcmp>()  function compares the two strings I<s1> and I<s2>.  It returns an integer less than, equal to, or greater than zero if I<s1> is found, respectively, to be less than, to match, or be greater than I<s2>.
fr: La fonction B<strcmp>() compare les deux chaînes I<s1> et I<s2>. Elle renvoie un entier négatif, nul, ou positif, si I<s1> est respectivement inférieure, égale ou supérieure à I<s2>.

note: type: Plain text
en: The B<strncmp>()  function is similar, except it compares the only first (at most)  I<n> bytes of I<s1> and I<s2>.
fr: La fonction B<strncmp>() est identique sauf qu'elle ne compare que les I<n> (au plus) premiers octets de I<s1> et I<s2>.

note: type: Plain text
en: The B<strcmp>()  and B<strncmp>()  functions return an integer less than, equal to, or greater than zero if I<s1> (or the first I<n> bytes thereof) is found, respectively, to be less than, to match, or be greater than I<s2>.
fr: Les fonctions B<strcmp>() et B<strncmp>() renvoient un entier inférieur, égal ou supérieur à zéro si I<s1> (ou ses I<n> premiers octets) est respectivement inférieure, égale ou supérieure à I<s2>.

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

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

note: type: Plain text
en: strcoll - compare two strings using the current locale
fr: strcoll - Comparaison de deux chaînes suivant la localisation en cours

note: type: Plain text
en: The B<strcoll>()  function compares the two strings I<s1> and I<s2>.  It returns an integer less than, equal to, or greater than zero if I<s1> is found, respectively, to be less than, to match, or be greater than I<s2>.  The comparison is based on strings interpreted as appropriate for the program's current locale for category B<LC_COLLATE>.  (See B<setlocale>(3).)
fr: La fonction B<strcoll>() compare les deux chaînes I<s1> et I<s2>. Elle renvoie un entier négatif, nul, ou positif, si I<s1> est respectivement inférieure, égale, ou supérieure à I<s2>. La comparaison est effectuée en se basant sur la localisation en cours pour la catégorie B<LC_COLLATE> (voir B<setlocale>(3)).

note: type: Plain text
en: The B<strcoll>()  function returns an integer less than, equal to, or greater than zero if I<s1> is found, respectively, to be less than, to match, or be greater than I<s2>, when both are interpreted as appropriate for the current locale.
fr: La fonction B<strcoll>() renvoie un entier inférieur, égal ou supérieur à zéro si I<s1> est respectivement inférieure, égale ou supérieure à I<s2>, ces deux chaînes étant interprétées avec la localisation en cours.

note: type: Plain text
en: In the I<POSIX> or I<C> locales B<strcoll>()  is equivalent to B<strcmp>(3).
fr: Avec les localisations I<POSIX> ou I<C>, B<strcoll>() est équivalente à B<strcmp>(3).

note: type: TH
en: 2014-03-04
fr: 4 mars 2014

note: type: Plain text
en: strcpy, strncpy - copy a string
fr: strcpy, strncpy - Copier une chaîne

note: type: Plain text
en: The B<strcpy>()  function copies the string pointed to by I<src>, including the terminating null byte (\(aq\e0\(aq), to the buffer pointed to by I<dest>.  The strings may not overlap, and the destination string I<dest> must be large enough to receive the copy.  I<Beware of buffer overruns!> (See BUGS.)
fr: La fonction B<strcpy>() copie la chaîne pointée par I<src>, y compris le caractère nul («\ \e0\ ») final dans la chaîne pointée par I<dest>. Les deux chaînes ne doivent pas se chevaucher. La chaîne I<dest> doit être assez grande pour accueillir la copie. I<Attention aux dépassements de tampon !> (consultez B<BUGS>).

note: type: Plain text
en: The B<strncpy>()  function is similar, except that at most I<n> bytes of I<src> are copied.  B<Warning>: If there is no null byte among the first I<n> bytes of I<src>, the string placed in I<dest> will not be null-terminated.
fr: La fonction B<strncpy>() est identique, sauf qu'au plus I<n> octets de I<src> sont copiés. B<Attention> : s'il n'y a pas de caractère nul dans les I<n> premiers octets de I<src>, la chaîne résultante dans I<dest> ne disposera pas de caractère nul final.

note: type: Plain text
en: If the length of I<src> is less than I<n>, B<strncpy>()  writes additional null bytes to I<dest> to ensure that a total of I<n> bytes are written.
fr: Si la longueur de I<src> est inférieure à I<n>, B<strncpy>() écrit des caractères nuls supplémentaires vers I<dest> pour s'assurer qu'un total de I<n> octets ont été écrits.

note: type: Plain text
en: A simple implementation of B<strncpy>()  might be:
fr: Une implémentation simple de B<strncpy>() pourrait être :

note: type: Plain text
en: The B<strcpy>()  and B<strncpy>()  functions return a pointer to the destination string I<dest>.
fr: Les fonctions B<strcpy>() et B<strncpy>() renvoient un pointeur sur la chaîne destination I<dest>.

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

note: type: Plain text
en: Some programmers consider B<strncpy>()  to be inefficient and error prone.  If the programmer knows (i.e., includes code to test!)  that the size of I<dest> is greater than the length of I<src>, then B<strcpy>()  can be used.
fr: Certains programmeurs considèrent B<strncpy>() comme inefficace et propice aux erreurs. Si le programmeur sait (c'est-à-dire en ajoutant du code pour effectuer le test !) que la taille de I<dest> est supérieure à la longueur de I<src>, alors B<strcpy>() peut être utilisée.

note: type: Plain text
en: One valid (and intended) use of B<strncpy>()  is to copy a C string to a fixed-length buffer while ensuring both that the buffer is not overflowed and that unused bytes in the target buffer are zeroed out (perhaps to prevent information leaks if the buffer is to be written to media or transmitted to another process via an interprocess communication technique).
fr: Une façon correcte (et voulue) d'utiliser B<strncpy>() est de copier une chaîne C vers un tampon de longueur fixe en s'assurant à la fois que le tampon n'est pas dépassé et que les octets non utilisés du tampon cible sont mis à zéro (peut-être pour éviter la fuite d'informations si le tampon n'est pas à écrire sur un support ou à transmettre à un autre processus à l'aide d'une technique de communication interprocessus).

note: type: Plain text
en: If there is no terminating null byte in the first I<n> bytes of I<src>, B<strncpy>()  produces an unterminated string in I<dest>.  If I<buf> has length I<buflen>, you can force termination using something like the following:
fr: S'il n'y a pas de caractère nul de fin dans les I<n> premiers octets de I<src>, B<strncpy>() génère une chaîne non terminée et l'affecte dans I<dest>. Si I<buf> est de longueur I<buflen>, il est possible de forcer la chaîne à se terminer en faisant appel à quelque chose comme :

note: type: Plain text
en: (Of course, the above technique ignores the fact that, if I<src> contains more than I<buflen\ -\ 1> bytes, information is lost in the copying to I<dest>.)
fr: (Bien sûr, la méthode précédente ne tient pas compte du fait que si la longueur de I<src> est supérieure à I<buflen\ -\ 1> octets, les informations sont perdues lors de la copie vers I<dest>.)

note: http://static.usenix.org/event/usenix99/full_papers/millert/millert_html/index.html "strlcpy and strlcat - consistent, safe, string copy and concatenation" 1999 USENIX Annual Technical Conference https://lwn.net/Articles/506530/ type: Plain text
en: This function is similar to B<strncpy>(), but it copies at most I<size-1> bytes to I<dest>, always adds a terminating null byte, and does not pad the target with (further) null bytes.  This function fixes some of the problems of B<strcpy>()  and B<strncpy>(), but the caller must still handle the possibility of data loss if I<size> is too small.  The return value of the function is the length of I<src>, which allows truncation to be easily detected: if the return value is greater than or equal to I<size>, truncation occurred.  If loss of data matters, the caller I<must> either check the arguments before the call, or test the function return value.  B<strlcpy>()  is not present in glibc and is not standardized by POSIX, but is available on Linux via the I<libbsd> library.
fr: Cette fonction est similaire à B<strncpy>(), mais elle copie au plus I<size-1> octets vers I<dest>, ajoute toujours un octet nul final et ne remplit la cible avec des (autres) octets nuls. Cette fonction corrige certains des problèmes de B<strcpy>() et B<strncpy>(), mais l'appelant doit quand même gérer la possibilité de pertes de données si I<size> est trop petit. La valeur de retour de la fonction est la longueur de I<src>, ce qui permet de détecter facilement une coupure : si la valeur renvoyée est supérieure à I<size>, c'est qu'il y a eu perte de données. Si les pertes de données sont problématiques, l'appelant I<doit> soit vérifier les arguments avant l'appel, soit tester la valeur de retour de la fonction. B<strlcpy>() n'existe pas dans glibc et n'est pas normalisé par POSIX, mais est disponible sous Linux avec la bibliothèque I<libbsd>.

note: type: Plain text
en: If the destination string of a B<strcpy>()  is not large enough, then anything might happen.  Overflowing fixed-length string buffers is a favorite cracker technique for taking complete control of the machine.  Any time a program reads or copies data into a buffer, the program first needs to check that there's enough space.  This may be unnecessary if you can show that overflow is impossible, but be careful: programs can get changed over time, in ways that may make the impossible possible.
fr: Si la chaîne de destination d'un B<strcpy>() n'est pas suffisamment grande, n'importe quoi peut survenir. Un dépassement de tampon pour une chaîne de taille fixe est la technique favorite de pirates pour prendre le contrôle d'une machine. À chaque fois qu'un programme lit ou copie des données dans un tampon, le programme doit d'abord vérifier qu'il y a suffisamment de place. Ça peut ne pas être nécessaire si vous pouvez montrer qu'un dépassement est impossible, mais faites attention : les programmes changes au cours du temps, et ce qui était impossible peut devenir possible.

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

note: type: Plain text
en: strdup, strndup, strdupa, strndupa - duplicate a string
fr: strdup, strndup, strdupa, strndupa - Dupliquer une chaîne

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

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

note: type: Plain text
en: B<strdupa>(), B<strndupa>(): _GNU_SOURCE
fr: B<strdupa>(), B<strndupa>()\ : _GNU_SOURCE

note: type: Plain text
en: The B<strdup>()  function returns a pointer to a new string which is a duplicate of the string I<s>.  Memory for the new string is obtained with B<malloc>(3), and can be freed with B<free>(3).
fr: La fonction B<strdup>() renvoie un pointeur sur une nouvelle chaîne de caractères qui est dupliquée depuis I<s>. La mémoire occupée par cette nouvelle chaîne est obtenue en appelant B<malloc>(3), et peut (doit) donc être libérée avec B<free>(3).

note: type: Plain text
en: The B<strndup>()  function is similar, but copies at most I<n> bytes.  If I<s> is longer than I<n>, only I<n> bytes are copied, and a terminating null byte (\(aq\e0\(aq) is added.
fr: La fonction B<strndup>() est identique, mais ne copie au plus que I<n> octets. Si I<s> est plus grande que I<n>, seuls I<n> octets sont copiés, et un octet nul de fin (« \e0 ») est ajouté.

note: type: Plain text
en: B<strdupa>()  and B<strndupa>()  are similar, but use B<alloca>(3)  to allocate the buffer.  They are available only when using the GNU GCC suite, and suffer from the same limitations described in B<alloca>(3).
fr: B<strdupa> et B<strndupa> sont similaires, mais utilisent B<alloca>(3) pour allouer le tampon. Elles sont directement utilisables avec GNU GCC, mais souffrent des mêmes restrictions que B<alloca>(3).

note: type: Plain text
en: On success, the B<strdup>()  function returns a pointer to the duplicated string.  It returns NULL if insufficient memory was available, with I<errno> set to indicate the cause of the error.
fr: En cas de succès, la fonction B<strdup>() renvoie un pointeur sur la chaîne dupliquée. NULL est renvoyé s'il n'y avait pas assez de mémoire et I<errno> contient le code d'erreur.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: Insufficient memory available to allocate duplicate string.
fr: Mémoire disponible insuffisante pour dupliquer la chaîne.

note: 4.3BSD-Reno, not (first) 4.3BSD. type: Plain text
en: B<strdup>()  conforms to SVr4, 4.3BSD, POSIX.1-2001.  B<strndup>()  conforms to POSIX.1-2008.  B<strdupa>()  and B<strndupa>()  are GNU extensions.
fr: B<strdup>() est conforme à SVr4, BSD\ 4.3, POSIX.1-2001. B<strndup>() est conforme à POSIX.1-2008. B<strdupa>() et B<strndupa>() sont des extensions GNU.

note: type: Plain text
en: strerror, strerror_r, strerror_l - return string describing error number
fr: strerror, strerror_r, strerror_l - Obtenir le libellé d'un numéro d'erreur

note: type: Plain text
en: B<int strerror_r(int >I<errnum>B<, char *>I<buf>B<, size_t >I<buflen>B<);>
                /* XSI-compliant */
fr: B<int strerror_r(int >I<errnum>B<, char *>I<buf>B<, size_t >I<buflen>B<);>
                /* conforme XSI */

note: type: Plain text
en: B<char *strerror_r(int >I<errnum>B<, char *>I<buf>B<, size_t >I<buflen>B<);>
                /* GNU-specific */
fr: B<char *strerror_r(int >I<errnum>B<, char *>I<buf>B<, size_t >I<buflen>B<);>
                /* spécifique GNU */

note: type: Plain text
en: The XSI-compliant version is provided if:
fr: La version compatible XSI est fournie si :

note: type: Plain text
en: Otherwise, the GNU-specific version is provided.
fr: Autrement, c'est la version GNU qui est fournie.

note: type: Plain text
en: The B<strerror>()  function returns a pointer to a string that describes the error code passed in the argument I<errnum>, possibly using the B<LC_MESSAGES> part of the current locale to select the appropriate language.  (For example, if I<errnum> is B<EINVAL>, the returned description will be "Invalid argument".)  This string must not be modified by the application, but may be modified by a subsequent call to B<strerror>()  or B<strerror_l>().  No other library function, including B<perror>(3), will modify this string.
fr: La fonction B<strerror>() renvoie un pointeur vers une chaîne qui décrit le code d'erreur passé en argument I<errnum>, en utilisant éventuellement la catégorie B<LC_MESSAGES> de la localisation pour sélectionner la langue appropriée (par exemple, si I<errnum> est B<EINVAL>, la description renvoyée sera « Argument invalide »). Cette chaîne ne doit pas être modifiée par l'application, mais peut être écrasée par un appel ultérieur à B<strerror>() ou B<strerror_l>(). Aucune autre fonction de bibliothèque, y compris B<perror>(3), ne modifie cette chaîne.

note: type: Plain text
en: The B<strerror_r>()  function is similar to B<strerror>(), but is thread safe.  This function is available in two versions: an XSI-compliant version specified in POSIX.1-2001 (available since glibc 2.3.4, but not POSIX-compliant until glibc 2.13), and a GNU-specific version (available since glibc 2.0).  The XSI-compliant version is provided with the feature test macros settings shown in the SYNOPSIS; otherwise the GNU-specific version is provided.  If no feature test macros are explicitly defined, then (since glibc 2.4)  B<_POSIX_SOURCE> is defined by default with the value 200112L, so that the XSI-compliant version of B<strerror_r>()  is provided by default.
fr: La fonction B<strerror_r>() est identique à B<strerror>() mais fonctionne correctement dans un environnement multithread. Cette fonction est disponible en deux versions\ : une version conforme XSI spécifiée dans POSIX.1-2001 (disponible depuis la glibc 2.3.4, mais non compatible POSIX avant la glibc 2.13) et une version spécifique GNU (disponible depuis la glibc 2.0). La version compatible XSI est fournie par la macro de test mentionnée dans le B<SYNOPSIS>, sinon la version spécifique GNU est fournie. Si aucune macro de test n'est définie explicitement, alors (depuis la glibc 2.4) B<_POSIX_SOURCE> est définie par défaut avec la valeur 200112L, de telle sorte que la version compatible XSI de B<strerror_r>() est fournie par défaut.

note: type: Plain text
en: The XSI-compliant B<strerror_r>()  is preferred for portable applications.  It returns the error string in the user-supplied buffer I<buf> of length I<buflen>.
fr: La version de B<strerror_r>() conforme XSI est préférée pour les applications portables. Elle renvoie la chaîne dans le tampon I<buf> de longueur I<buflen> fourni par l'appelant.

note: type: Plain text
en: The GNU-specific B<strerror_r>()  returns a pointer to a string containing the error message.  This may be either a pointer to a string that the function stores in I<buf>, or a pointer to some (immutable) static string (in which case I<buf> is unused).  If the function stores a string in I<buf>, then at most I<buflen> bytes are stored (the string may be truncated if I<buflen> is too small and I<errnum> is unknown).  The string always includes a terminating null byte (\(aq\e0\(aq).
fr: La version de B<strerror_r>() spécifique GNU renvoie un pointeur sur une chaîne contenant le message d'erreur. Cela peut être soit un pointeur vers une chaîne que la fonction stocke dans I<buf>, soit un pointeur vers une chaîne statique (immuable) (auquel cas I<buf> n'est pas utilisé). Si la fonction stocke une chaîne dans I<buf>, au plus I<buflen> octets sont stockés (la chaîne peut être tronquée si I<buflen> est trop petit et qu'I<errnum> est inconnu). La chaîne inclut toujours l'octet nul final («\ \e0\ »).

note: type: Plain text
en: B<strerror_l>()  is like B<strerror>(), but maps I<errnum> to a locale-dependent error message in the locale specified by I<locale>.  The behavior of B<strerror_l>()  is undefined if I<locale> is the special locale object B<LC_GLOBAL_LOCALE> or is not a valid locale object handle.
fr: B<strerror_l>() est semblable à B<strerror>(), mais fait correspondre à I<errnum> un message d'erreur adapté à la localisation précisée par I<locale>. Le comportement de B<strerror_l>()  n'est pas défini la la localisation I<locale> est l'objet de localisation spécial B<LC_GLOBAL_LOCALE> ou si elle n'a pas la valeur d'une localisation valide.

note: type: Plain text
en: The B<strerror>(), B<strerror_l>(), and the GNU-specific B<strerror_r>()  functions return the appropriate error description string, or an "Unknown error nnn" message if the error number is unknown.
fr: Les fonction B<strerror>(), B<strerror_l>() et la fonction GNU B<strerror_r>() renvoient la description correspondant au code transmis, ou un message «\ Unknown error nnn\ » si le numéro d'erreur n'existe pas.

note: type: Plain text
en: The XSI-compliant B<strerror_r>()  function returns 0 on success.  On error, a (positive) error number is returned (since glibc 2.13), or -1 is returned and I<errno> is set to indicate the error (glibc versions before 2.13).
fr: La fonction B<strerror_r>() conforme XSI renvoie 0 si elle réussit. En cas d'erreur, un numéro (positif) d'erreur est renvoyé (depuis la glibc 2.13), ou -1 est renvoyé et I<errno> est définit pour indiquer l'erreur (pour les version de la glibc antérieures à 2.13).

note: type: Plain text
en: POSIX.1-2001 and POSIX.1-2008 require that a successful call to B<strerror>()  or B<strerror_l>()  shall leave I<errno> unchanged, and note that, since no function return value is reserved to indicate an error, an application that wishes to check for errors should initialize I<errno> to zero before the call, and then check I<errno> after the call.
fr: POSIX.1-2001 et POSIX.1-2008 exigent qu'un appel réussi de B<strerror>() ou B<strerror_l>() laisse I<errno> non modifié. Remarquez que, puisqu'aucune valeur de retour de fonction n'est réservée pour indiquer d'erreur, une application qui désire vérifier les erreurs devrait initialiser I<errno> à zéro avant l'appel, et vérifier I<errno> après l'appel.

note: type: Plain text
en: The value of I<errnum> is not a valid error number.
fr: La valeur de I<errnum> n'est pas un code d'erreur valide.

note: type: Plain text
en: Insufficient storage was supplied to contain the error description string.
fr: Le tampon fourni n'est pas assez grand.

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

note: FIXME Need a thread-safety statement about strerror_l() type: Plain text
en: The B<strerror_r>()  function is thread-safe.
fr: La fonction B<strerror_r>() est sûre dans un contexte multithread.

note: type: Plain text
en: The B<strerror_l>()  function first appeared in glibc 2.6.
fr: La fonction B<strerror_l>() est apparue dans la glibc 2.6.

note: type: Plain text
en: B<strerror>()  is specified by POSIX.1-2001, POSIX.1-2008, C89, and C99.  B<strerror_r>()  is specified by POSIX.1-2001 and POSIX.1-2008.
fr: B<strerror>() est spécifiée par POSIX.1-2001, POSIX.1-2008, C89 et C99. B<strerror_r>() est spécifiée par POSIX.1-2001 et POSIX.1-2008.

note: type: Plain text
en: B<strerror_l>()  is specified in POSIX.1-2008.
fr: B<strerror_l>() est spécifiée dans POSIX.1-2008.

note: type: Plain text
en: The GNU-specific B<strerror_r>()  function is a nonstandard extension.
fr: La fonction B<strerror_r>() spécifique GNU n'est pas une extension standard.

note: e.g., Solaris 8, HP-UX 11 e.g., FreeBSD 5.4, Tru64 5.1B type: Plain text
en: POSIX.1-2001 permits B<strerror>()  to set I<errno> if the call encounters an error, but does not specify what value should be returned as the function result in the event of an error.  On some systems, B<strerror>()  returns NULL if the error number is unknown.  On other systems, B<strerror>()  returns a string something like "Error nnn occurred" and sets I<errno> to B<EINVAL> if the error number is unknown.  C99 and POSIX.1-2008 require the return value to be non-NULL.
fr: POSIX.1-2001 permet à B<strerror>() d'écrire I<errno> si l'appel rencontre une erreur mais ne spécifie pas quelle valeur devrait être retournée comme résultat de fonction dans l'éventualité d'une erreur. Sur certains systèmes, B<strerror>() renvoie NULL si le numéro d'erreur est inconnu. Sur d'autres, B<strerror>() renvoie une chaîne du style «\ Error nnn occurred\ » et écrit B<EINVAL> dans I<errno> si le numéro d'erreur est inconnu. C99 et POSIX.1-2008 exigent que la valeur renvoyée ne soit pas NULL.

note: type: Plain text
en: strfry - randomize a string
fr: strfry - Créer une anagramme d'une chaîne

note: type: Plain text
en: The B<strfry>()  function randomizes the contents of I<string> by using B<rand>(3)  to randomly swap characters in the string.  The result is an anagram of I<string>.
fr: La fonction B<strfry>() modifie le contenu de la chaîne I<string> en utilisant la fonction B<rand>(3) pour échanger aléatoirement des caractères. Le résultat est une anagramme de I<string>.

note: type: Plain text
en: The B<strfry>()  functions returns a pointer to the randomized string.
fr: La fonction B<strfry>() renvoie un pointeur sur la chaîne modifiée.

note: type: Plain text
en: The B<strfry>()  function is unique to the GNU C Library.
fr: La fonction B<strfry>() est spécifique à la bibliothèque C GNU.

note: type: TH
en: 2014-01-04
fr: 4 janvier 2014

note: type: Plain text
en: stpcpy, strcasecmp, strcat, strchr, strcmp, strcoll, strcpy, strcspn, strdup, strfry, strlen, strncat, strncmp, strncpy, strncasecmp, strpbrk, strrchr, strsep, strspn, strstr, strtok, strxfrm, index, rindex - string operations
fr: stpcpy, strcasecmp, strcat, strchr, strcmp, strcoll, strcpy, strcspn, strdup, strfry, strlen, strncat, strncmp, strncpy, strncasecmp, strpbrk, strrchr, strsep, strspn, strstr, strtok, strxfrm, index, rindex - Opérations sur les chaînes de caractères

note: type: Plain text
en: Compare the strings I<s1> and I<s2> ignoring case.
fr: Compare les chaînes I<s1> et I<s2> sans tenir compte de la casse.

note: type: Plain text
en: Compare the first I<n> characters of the strings I<s1> and I<s2> ignoring case.
fr: Compare les I<n> premiers caractères des chaînes I<s1> et I<s2> sans tenir compte de la casse.

note: type: Plain text
en: Return a pointer to the first occurrence of the character I<c> in the string I<s>.
fr: Renvoie un pointeur sur la première occurrence du caractère I<c> dans la chaîne I<s>.

note: type: Plain text
en: Return a pointer to the last occurrence of the character I<c> in the string I<s>.
fr: Renvoie un pointeur sur la dernière occurrence du caractère I<c> dans la chaîne I<s>.

note: type: Plain text
en: Copy a string from I<src> to I<dest>, returning a pointer to the end of the resulting string at I<dest>.
fr: Copie une chaîne de I<src> vers I<dest> et renvoie un pointeur sur l'extrémité finale de la chaîne résultante I<dest>.

note: type: Plain text
en: Append the string I<src> to the string I<dest>, returning a pointer I<dest>.
fr: Ajoute la chaîne I<src> à la chaîne I<dest> et renvoie un pointeur I<dest>.

note: type: Plain text
en: Compare the strings I<s1> with I<s2>.
fr: Compare les chaînes I<s1> et I<s2>.

note: type: Plain text
en: Compare the strings I<s1> with I<s2> using the current locale.
fr: Compare les deux chaînes I<s1> et I<s2> en utilisant la localisation.

note: type: Plain text
en: Copy the string I<src> to I<dest>, returning a pointer to the start of I<dest>.
fr: Copie la chaîne I<src> dans I<dest> et renvoie un pointeur sur le début de la chaîne I<dest>.

note: type: Plain text
en: Calculate the length of the initial segment of the string I<s> which does not contain any of bytes in the string I<reject>,
fr: Calcule la longueur du segment initial de la chaîne I<s> qui ne contient aucun octet de la chaîne I<reject>,

note: type: Plain text
en: Return a duplicate of the string I<s> in memory allocated using B<malloc>(3).
fr: Renvoie une copie de la chaîne I<s> allouée en mémoire au moyen de B<malloc>(3).

note: type: Plain text
en: Randomly swap the characters in I<string>.
fr: Redistribue aléatoirement les caractères dans I<string>.

note: type: Plain text
en: Return the length of the string I<s>.
fr: Renvoie la longueur de la chaîne I<s>.

note: type: Plain text
en: Append at most I<n> characters from the string I<src> to the string I<dest>, returning a pointer to I<dest>.
fr: Ajoute au plus I<n> caractères de la chaîne I<src> à la chaîne I<dest> et renvoie un pointeur vers I<dest>.

note: type: Plain text
en: Compare at most I<n> bytes of the strings I<s1> and I<s2>.
fr: Compare au plus I<n> octets des chaînes I<s1> et I<s2>.

note: type: Plain text
en: Copy at most I<n> bytes from string I<src> to I<dest>, returning a pointer to the start of I<dest>.
fr: Copie au plus I<n> octets de la chaîne I<src> dans I<dest> et renvoie un pointeur vers le début de I<dest>.

note: type: Plain text
en: Return a pointer to the first occurrence in the string I<s> of one of the bytes in the string I<accept>.
fr: Renvoie un pointeur vers la première occurrence dans la chaîne I<s> de l'un des octets de la chaîne I<accept>.

note: type: Plain text
en: Extract the initial token in I<stringp> that is delimited by one of the bytes in I<delim>.
fr: Extrait le premier élément lexical (token) de I<stringp> qui est délimité par l'un des octets de I<delim>.

note: type: Plain text
en: Calculate the length of the starting segment in the string I<s> that consists entirely of bytes in I<accept>.
fr: Calcule la longueur du segment commençant la chaîne I<s> qui est constitué exclusivement d'octets de I<accept>.

note: type: TP
en: B<char *strstr(const char *>I<haystack>B<, const char *>I<needle>B<);>
fr: B<char *strstr(const char *>I<meule_de_foin>B<, const char *>I<aiguille>B<);>

note: type: Plain text
en: Find the first occurrence of the substring I<needle> in the string I<haystack>, returning a pointer to the found substring.
fr: Recherche la première occurrence de la sous-chaîne I<aiguille> au sein de la chaîne I<meule_de_foin> et renvoie un pointeur sur la sous-chaîne trouvée.

note: type: TP
en: B<char *strtok(char *>I<s>B<, const char *>I<delim>B<);>
fr: B<char *strtok(char *>I<s>B<, const char *>I<délim>B<);>

note: type: Plain text
en: Extract tokens from the string I<s> that are delimited by one of the bytes in I<delim>.
fr: Extrait les éléments lexicaux de la chaîne I<s> qui sont délimités par l'un des mots présents dans I<delim>.

note: type: Plain text
en: Transforms I<src> to the current locale and copies the first I<n> characters to I<dest>.
fr: Modifie I<src> selon la localisation en vigueur et copie les I<n> premiers caractères dans I<dest>.

note: type: Plain text
en: The string functions perform string operations on null-terminated strings.  See the individual man pages for descriptions of each function.
fr: Ces fonctions effectuent diverses opérations sur des chaînes de caractères se terminant par un caractère nul. Consultez les pages de manuel individuelles pour plus de détails.

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

note: type: Plain text
en: strlen - calculate the length of a string
fr: strlen - Calculer la longueur d'une chaîne de caractères

note: type: Plain text
en: The B<strlen>()  function calculates the length of the string I<s>, excluding the terminating null byte (\(aq\e0\(aq).
fr: La fonction B<strlen>() calcule la longueur de la chaîne de caractères I<s>, sans compter l'octet nul («\ \e0\ ») final.

note: type: Plain text
en: The B<strlen>()  function returns the number of bytes in the string I<s>.
fr: La fonction B<strlen>() renvoie le nombre de octets dans la chaîne I<s>

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

note: type: Plain text
en: strnlen - determine the length of a fixed-size string
fr: strnlen - Déterminer la longueur d'une chaîne

note: type: Plain text
en: B<size_t strnlen(const char *>I<s>B<, size_t >I<maxlen>B<);>
fr: B<size_t strnlen(const char *>I<s>B<, size_t >I<lngmax>B<);>

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

note: type: Plain text
en: The B<strnlen>()  function returns the number of bytes in the string pointed to by I<s>, excluding the terminating null byte (\(aq\e0\(aq), but at most I<maxlen>.  In doing this, B<strnlen>()  looks only at the first I<maxlen> bytes at I<s> and never beyond I<s+maxlen>.
fr: La fonction B<strnlen>() renvoie le nombre d'octets de la chaîne pointée par I<s>, octet nul («\ \e0\ ») final non compris, mais en examinant au maximum I<lngmax> octets. Ce faisant, B<strnlen>() n'examine que les I<lngmax> premiers octets de I<s> et n'atteint jamais I<s+lngmax>.

note: type: Plain text
en: The B<strnlen>()  function returns I<strlen(s)>, if that is less than I<maxlen>, or I<maxlen> if there is no null byte (\(aq\e0\(aq) among the first I<maxlen> bytes pointed to by I<s>.
fr: La fonction B<strnlen>() renvoie I<strlen(s)> si la longueur est inférieure à I<lngmax>, ou I<lngmax> s'il n'y a pas d'octet nul (« \e0 ») parmi les I<lngmax> premiers octets de la chaîne pointée par I<s>.

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

note: type: Plain text
en: strpbrk - search a string for any of a set of bytes
fr: strpbrk - Rechercher un ensemble d'octets dans une chaîne

note: type: Plain text
en: The B<strpbrk>()  function locates the first occurrence in the string I<s> of any of the bytes in the string I<accept>.
fr: La fonction B<strpbrk>() recherche la première occurrence dans la chaîne I<s> de n'importe quel octet de la chaîne I<accept>.

note: type: Plain text
en: The B<strpbrk>()  function returns a pointer to the byte in I<s> that matches one of the bytes in I<accept>, or NULL if no such byte is found.
fr: La fonction B<strpbrk>() renvoie un pointeur sur l'octet de I<s> qui correspond à un octet de I<accept>, ou NULL si aucune correspondance n'est trouvée.

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

note: type: Plain text
en: strsep - extract token from string
fr: strsep - Extraction de mots d'une chaîne

note: type: Plain text
en: B<char *strsep(char **>I<stringp>B<, const char *>I<delim>B<);>
fr: B<char *strsep(char **>I<stringp>B<, const char *>I<délim>B<);>

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

note: type: Plain text
en: If I<*stringp> is NULL, the B<strsep>()  function returns NULL and does nothing else.  Otherwise, this function finds the first token in the string I<*stringp>, that is delimited by one of the bytes in the string I<delim>.  This token is terminated by overwriting the delimiter with a null byte (\(aq\e0\(aq), and I<*stringp> is updated to point past the token.  In case no delimiter was found, the token is taken to be the entire string I<*stringp>, and I<*stringp> is made NULL.
fr: Si I<*stringp> est NULL, la fonction B<strsep>() renvoie NULL et ne fait rien d'autre. Dans le cas contraire, cette fonction recherche le premier élément lexical (token) de la chaîne I<*stringp> qui est délimité par l'un des octets de la chaîne I<delim>. Le mot renvoyé est terminé en écrasant le séparateur avec un octet nul (« \e0 ») et I<*stringp> est mis à jour pour pointer après le mot. Dans le cas où aucun séparateur n'est trouvé, l'élément extrait est constitué de toute la chaîne I<*stringp>, et I<*stringp> vaut NULL.

note: type: Plain text
en: The B<strsep>()  function returns a pointer to the token, that is, it returns the original value of I<*stringp>.
fr: La fonction B<strsep>() renvoie un pointeur sur l'élément lexical extrait, c'est-à-dire la valeur originelle de I<*stringp>.

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

note: type: Plain text
en: The B<strsep>()  function was introduced as a replacement for B<strtok>(3), since the latter cannot handle empty fields.  However, B<strtok>(3)  conforms to C89/C99 and hence is more portable.
fr: La fonction B<strsep>() a été introduite en remplacement de B<strtok>(3), qui ne peut pas traiter les champs vides. Néanmoins, B<strtok>(3) est conforme à C89/C99 et est donc plus portable.

note: type: Plain text
en: Be cautious when using this function.  If you do use it, note that:
fr: Faites attention quand vous utilisez cette fonction. Si vous l'utilisez, prenez note des informations suivantes\ :

note: type: Plain text
en: This function modifies its first argument.
fr: Cette fonction modifie son premier argument.

note: type: Plain text
en: This function cannot be used on constant strings.
fr: Cette fonction ne peut pas être utilisée avec des chaînes constantes.

note: type: Plain text
en: The identity of the delimiting character is lost.
fr: Cette fonction ne doit pas être invoquée sur une chaîne constante.

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

note: type: Plain text
en: strsignal - return string describing signal
fr: strsignal - Obtenir un libellé décrivant un signal

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

note: type: Plain text
en: The B<strsignal>()  function returns a string describing the signal number passed in the argument I<sig>.  The string can be used only until the next call to B<strsignal>().
fr: La fonction B<strsignal>() renvoie une chaîne décrivant le signal numéro I<sig>. La chaîne ne peut être utilisée que jusqu'à l'appel suivant de B<strsignal>().

note: type: Plain text
en: The array I<sys_siglist> holds the signal description strings indexed by signal number.  The B<strsignal>()  function should be used if possible instead of this array.
fr: Le tableau I<sys_siglist> contient les libellés des signaux, indexés par leurs numéros. Dans la mesure du possible, il vaut mieux utiliser B<strsignal>().

note: type: Plain text
en: The B<strsignal>()  function returns the appropriate description string, or an unknown signal message if the signal number is invalid.  On some systems (but not on Linux), NULL may instead be returned for an invalid signal number.
fr: La fonction B<strsignal>() renvoie le libellé approprié, ou un message indiquant un signal inconnu si le numéro est invalide. Sur certains systèmes (mais pas Linux) un pointeur NULL peut être renvoyé en cas de signal inexistant.

note: type: Plain text
en: POSIX.1-2008.  Present on Solaris and the BSDs.
fr: POSIX.1-2008. Présente sur Solaris et les BSD.

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

note: type: Plain text
en: strspn, strcspn - get length of a prefix substring
fr: strspn, strcspn - Déterminer la longueur d'une sous-chaîne préfixe

note: type: Plain text
en: The B<strspn>()  function calculates the length (in bytes) of the initial segment of I<s> which consists entirely of bytes in I<accept>.
fr: La fonction B<strspn>() calcule la longueur (en octet) du segment initial de I<s> qui ne contient que des octets présents dans I<accept>.

note: type: Plain text
en: The B<strcspn>()  function calculates the length of the initial segment of I<s> which consists entirely of bytes not in I<reject>.
fr: La fonction B<strcspn>() calcule la longueur du segment initial de I<s> qui ne contient que des octets absents de I<reject>.

note: type: Plain text
en: The B<strspn>()  function returns the number of bytes in the initial segment of I<s> which consist only of bytes from I<accept>.
fr: La fonction B<strspn>() renvoie le nombre d'octets du segment initial de I<s> constitué uniquement d'octets présents dans I<accept>.

note: type: Plain text
en: The B<strcspn>()  function returns the number of bytes in the initial segment of I<s> which are not in the string I<reject>.
fr: La fonction B<strcspn>() renvoie le nombre d'octets du segment initial de I<s> constitué uniquement de caractères absents de I<reject>.

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

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

note: type: Plain text
en: strstr, strcasestr - locate a substring
fr: strstr, strcasestr - Rechercher une sous-chaîne

note: type: Plain text
en: B<char *strstr(const char *>I<haystack>B<, const char *>I<needle>B<);>
fr: B<char *strstr(const char *>I<meule_de_foin>B<, const char *>I<aiguille>B<);>

note: type: Plain text
en: B<char *strcasestr(const char *>I<haystack>B<, const char *>I<needle>B<);>
fr: B<char *strcasestr(const char *>I<meule_de_foin>B<, const char *>I<aiguille>B<);>

note: type: Plain text
en: The B<strstr>()  function finds the first occurrence of the substring I<needle> in the string I<haystack>.  The terminating null bytes (\(aq\e0\(aq) are not compared.
fr: La fonction B<strstr>() cherche la première occurrence de la sous-chaîne I<aiguille> au sein de la chaîne I<meule_de_foin>. Les octets nuls (« \e0 ») finaux ne sont pas comparés.

note: type: Plain text
en: The B<strcasestr>()  function is like B<strstr>(), but ignores the case of both arguments.
fr: La fonction B<strcasestr>() est identique à B<strstr>(), mais elle ignore la casse de ses arguments.

note: type: Plain text
en: These functions return a pointer to the beginning of the located substring, or NULL if the substring is not found.
fr: Ces fonctions renvoient un pointeur sur le début de la sous-chaîne découverte, ou NULL si celle-ci n'est pas trouvée.

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

note: type: Plain text
en: The B<strcasestr>()  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<strcasestr>() 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: The B<strstr>()  function conforms to C89 and C99.  The B<strcasestr>()  function is a nonstandard extension.
fr: La fonction B<strstr>() est conforme à C89 et C99. La fonction B<strcasestr>() est une extension non standard.

note: type: Plain text
en: Early versions of Linux libc (like 4.5.26) would not allow an empty I<needle> argument for B<strstr>().  Later versions (like 4.6.27) work correctly, and return I<haystack> when I<needle> is empty.
fr: Des versions antérieures de la bibliothèque C de Linux (4.5.26 par exemple), n'autorisent pas un argument I<aiguille> vide dans B<strstr>(). Des versions plus récentes (comme la 4.6.27) fonctionnent correctement, et renvoient I<meule_de_foin> si la chaîne I<aiguille> est vide.

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

note: type: Plain text
en: strtok, strtok_r - extract tokens from strings
fr: strtok, strtok_r - Extraire des mots d'une chaîne

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

note: type: Plain text
en: The B<strtok>()  function breaks a string into a sequence of zero or more nonempty tokens.  On the first call to B<strtok>()  the string to be parsed should be specified in I<str>.  In each subsequent call that should parse the same string, I<str> must be NULL.
fr: La fonction B<strtok>() scinde une chaîne en une séquence de zéro, un ou plusieurs éléments lexicaux non vides. Lors du premier appel à B<strtok>(), la chaîne à scinder doit être spécifiée dans I<str>. Dans chaque appel ultérieur fait pour analyser la même chaîne, I<str> devrait normalement valoir NULL.

note: type: Plain text
en: The I<delim> argument specifies a set of bytes that delimit the tokens in the parsed string.  The caller may specify different strings in I<delim> in successive calls that parse the same string.
fr: L'argument I<delimit> indique l'ensemble des octets qui délimitent les éléments dans la chaîne à analyser. La chaîne de séparateurs I<delimit> peut être différente à chaque appel sur la même chaîne.

note: type: Plain text
en: Each call to B<strtok>()  returns a pointer to a null-terminated string containing the next token.  This string does not include the delimiting byte.  If no more tokens are found, B<strtok>()  returns NULL.
fr: Chaque appel à B<strtok>() renvoie un pointeur sur une chaîne, terminée par un octet nul, contenant l'élément suivant. Cette chaîne n'inclut pas le séparateur. S'il n'y a plus d'éléments, B<strtok> renvoie NULL.

note: type: Plain text
en: A sequence of calls to B<strtok>()  that operate on the same string maintains a pointer that determines the point from which to start searching for the next token.  The first call to B<strtok>()  sets this pointer to point to the first byte of the string.  The start of the next token is determined by scanning forward for the next nondelimiter byte in I<str>.  If such a byte is found, it is taken as the start of the next token.  If no such byte is found, then there are no more tokens, and B<strtok>()  returns NULL.  (A string that is empty or that contains only delimiters will thus cause B<strtok>()  to return NULL on the first call.)
fr: Une séquence d'appels à B<strtok>() qui s'exécute sur la même chaîne gère un pointeur qui indique le point de départ de la recherche pour l'élément lexical suivant. Le premier appel à B<strtok>() positionne ce pointeur sur le premier octet de la chaîne. Le début de l'élément lexical suivant est déterminé en parcourant I<str> jusqu'à l'octet suivant qui ne soit pas un séparateur. Lorsqu'un tel octet est rencontré, il est pris comme point de départ de l'élément lexical suivant. Si on ne trouve plus d'octet qui ne soit pas un séparateur, alors il n'y a plus d'élément lexical dans la chaîne, et B<strtok>() renvoie la valeur NULL. (Ainsi, pour une chaîne vide ou qui ne contient que des séparateurs, B<strtok>() renverra la valeur NULL dès le premier appel).

note: type: Plain text
en: The end of each token is found by scanning forward until either the next delimiter byte is found or until the terminating null byte (\(aq\e0\(aq) is encountered.  If a delimiter byte is found, it is overwritten with a null byte to terminate the current token, and B<strtok>()  saves a pointer to the following byte; that pointer will be used as the starting point when searching for the next token.  In this case, B<strtok>()  returns a pointer to the start of the found token.
fr: La fin de chaque élément lexical est déterminée en parcourant la chaîne jusqu'à ce que l'octet suivant soit un délimiteur, ou jusqu'à ce qu'on rencontre l'octet vide (\(aq\e0\(aq). Si un délimiteur est trouvé, il est écrasé par un octet vide pour signifier la fin de l'élément lexical en cours de détermination, et B<strtok>() positionne un pointeur sur l'octet suivant ; ce pointeur marque le point de départ de la recherche de l'élément lexical suivant. Dans ce cas, B<strtok>() renvoie un pointeur vers le début de l'élément lexical qui vient d'être isolé.

note: type: Plain text
en: From the above description, it follows that a sequence of two or more contiguous delimiter bytes in the parsed string is considered to be a single delimiter, and that delimiter bytes at the start or end of the string are ignored.  Put another way: the tokens returned by B<strtok>()  are always nonempty strings.  Thus, for example, given the string "I<aaa;;bbb,>", successive calls to B<strtok>()  that specify the delimiter string "I<;,>" would return the strings "I<aaa>" and "I<bbb>", and then a null pointer.
fr: De ce qui précède, il découle qu'une séquence de deux séparateurs contigus ou plus est considérée comme un seul séparateur et que les séparateurs en début et en fin de chaîne sont ignorés. Les éléments renvoyés par B<strtok>() sont toujours des chaînes non vides. Si l'on considère par exemple la chaîne «I<aaa;;bbb,>», les appels successifs à B<strtok>() pour lequel le séparateur serait «I<;,>» renverraient les chaînes «I<aaa>» and «I<bbb>», puis un pointeur NULL.

note: type: Plain text
en: The B<strtok_r>()  function is a reentrant version B<strtok>().  The I<saveptr> argument is a pointer to a I<char\ *> variable that is used internally by B<strtok_r>()  in order to maintain context between successive calls that parse the same string.
fr: La fonction B<strtok_r>() est la version réentrante de la fonction B<strtok>(). L'argument I<saveptr> est un pointeur sur une variable I<char\ *> utilisée de manière interne à B<strtok_r>() afin de maintenir le contexte entre les appels successifs qui analysent la même chaîne.

note: type: Plain text
en: On the first call to B<strtok_r>(), I<str> should point to the string to be parsed, and the value of I<saveptr> is ignored.  In subsequent calls, I<str> should be NULL, and I<saveptr> should be unchanged since the previous call.
fr: Au premier appel de B<strtok_r>(), I<str> doit pointer sur la chaîne à analyser et la valeur de I<saveptr> est ignorée. Dans les appels suivants, I<str> doit être NULL et I<saveptr> ne doit pas être modifié depuis le précédent appel.

note: type: Plain text
en: Different strings may be parsed concurrently using sequences of calls to B<strtok_r>()  that specify different I<saveptr> arguments.
fr: Différentes chaînes peuvent être analysées de manière concurrente en utilisant des séquences d'appels à B<strtok_r>() qui spécifient différents arguments I<saveptr>.

note: type: Plain text
en: The B<strtok>()  and B<strtok_r>()  functions return a pointer to the next token, or NULL if there are no more tokens.
fr: Les fonctions B<strtok>() et B<strtok_r>() renvoient un pointeur sur l'élément lexical suivant, ou NULL s'il n'y en a plus.

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

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

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: Be cautious when using these functions.  If you do use them, note that:
fr: Faites attention quand vous utilisez ces fonctions. Si vous les utilisez, prenez note des informations suivantes\ :

note: type: Plain text
en: These functions modify their first argument.
fr: Ces fonctions modifient leur premier paramètre.

note: type: Plain text
en: These functions cannot be used on constant strings.
fr: Ces fonctions ne peuvent pas être utilisées avec des chaînes constantes.

note: type: Plain text
en: The identity of the delimiting byte is lost.
fr: L'identité du délimiteur est perdue.

note: type: Plain text
en: The B<strtok>()  function uses a static buffer while parsing, so it's not thread safe.  Use B<strtok_r>()  if this matters to you.
fr: La fonction B<strtok>() utilise un tampon statique et n'est donc pas sûre dans un contexte multithread. Dans ce cas, il vaut mieux utiliser B<strtok_r>().

note: type: Plain text
en: The program below uses nested loops that employ B<strtok_r>()  to break a string into a two-level hierarchy of tokens.  The first command-line argument specifies the string to be parsed.  The second argument specifies the delimiter byte(s)  to be used to separate that string into "major" tokens.  The third argument specifies the delimiter byte(s)  to be used to separate the "major" tokens into subtokens.
fr: Le programme ci-dessous utilise des boucles imbriquées qui utilisent B<strtok_r>() pour scinder une chaîne en une hiérarchie d'éléments à deux niveaux. Le premier argument de la ligne de commande indique la chaîne à analyser. Le second argument indique le ou les séparateurs utilisés pour séparer la chaîne en éléments «\ majeurs\ ». Le troisième argument indique le ou les séparateurs utilisés pour séparer les éléments «\ majeurs\ » en sous-éléments.

note: type: Plain text
en: An example of the output produced by this program is the following:
fr: Voici un exemple de la sortie produite par ce programme\ :

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

note: type: Plain text
en: Another example program using B<strtok>()  can be found in B<getaddrinfo_a>(3).
fr: Un autre exemple de programme qui utilise B<strtok>() se trouve dans B<getaddrinfo_a>(3).

note: type: TH
en: 2001-12-19
fr: 19 décembre 2001

note: type: Plain text
en: strverscmp - compare two version strings
fr: strverscmp - Comparaison de chaînes de version

note: classical solution: "rename jan jan0 jan?" type: Plain text
en: Often one has files I<jan1>, I<jan2>, ..., I<jan9>, I<jan10>, ...  and it feels wrong when B<ls>(1)  orders them I<jan1>, I<jan10>, ..., I<jan2>, ..., I<jan9>.  In order to rectify this, GNU introduced the I<-v> option to B<ls>(1), which is implemented using B<versionsort>(3), which again uses B<strverscmp>().
fr: On a souvent des fichiers I<jan1>, I<jan2>, ..., I<jan9>, I<jan10>, ... et il est malvenu que B<ls>(1) les classe dans l'ordre I<jan1>, I<jan10>, ..., I<jan2>, ..., I<jan9>. Afin de remédier à ceci, GNU a introduit l'option B<-v> à B<ls>(1), option implémentée en utilisant B<versionsort>(3), qui utilise lui-même B<strverscmp>().

note: type: Plain text
en: Thus, the task of B<strverscmp>()  is to compare two strings and find the "right" order, while B<strcmp>(3)  finds only the lexicographic order.  This function does not use the locale category B<LC_COLLATE>, so is meant mostly for situations where the strings are expected to be in ASCII.
fr: Ainsi, la tâche de B<strverscmp>() consiste à comparer deux chaînes et à déterminer le «\ bon\ » ordre, alors que B<strcmp>(3) détermine seulement l'ordre lexicographique. Cette fonction n'utilise pas la catégorie de localisation B<LC_COLLATE>, elle vise donc principalement les situations dans lesquelles les chaînes sont supposées être en ASCII.

note: type: Plain text
en: What this function does is the following.  If both strings are equal, return 0.  Otherwise find the position between two bytes with the property that before it both strings are equal, while directly after it there is a difference.  Find the largest consecutive digit strings containing (or starting at, or ending at) this position.  If one or both of these is empty, then return what B<strcmp>(3)  would have returned (numerical ordering of byte values).  Otherwise, compare both digit strings numerically, where digit strings with one or more leading zeros are interpreted as if they have a decimal point in front (so that in particular digit strings with more leading zeros come before digit strings with fewer leading zeros).  Thus, the ordering is I<000>, I<00>, I<01>, I<010>, I<09>, I<0>, I<1>, I<9>, I<10>.
fr: Cette fonction travaille comme détaillé ci-dessous. Si les deux chaînes sont égales, elle renvoie 0. Sinon, elle recherche une position entre deux octets ayant la propriété suivante\ : avant cette position, les deux chaînes sont égales, alors qu'immédiatement après, elles diffèrent. Elle détermine alors les plus longues chaînes de chiffres consécutifs contenant (ou commençant à, ou se finissant à) cette position. Si l'une des chaînes ou bien les deux chaînes sont vides, alors elles renvoient ce que B<strcmp>(3) aurait renvoyé (classement numérique des valeurs d'octets). Sinon, elle compare numériquement les deux chaînes de chiffres, où les chaînes de chiffres commençant par un ou plusieurs zéro sont interprétées comme si elles avaient une virgule en en-tête (de telle sorte que les chaînes de chiffres particulières commençant par davantage de zéro viennent avant les chaînes de chiffres avec moins de zéro en en-tête). Ainsi, le classement est I<000>, I<00>, I<01>, I<010>, I<09>, I<0>, I<1>, I<9>, I<10>.

note: type: Plain text
en: The B<strverscmp>()  function returns an integer less than, equal to, or greater than zero if I<s1> is found, respectively, to be earlier than, equal to, or later than I<s2>.
fr: La fonction B<strverscmp>() renvoie un entier inférieur, égal ou supérieur à zéro si I<s1> est déterminée comme étant respectivement plus récente que, égale à, ou postérieure à I<s2>.

note: type: Plain text
en: strxfrm - string transformation
fr: strxfrm - Transformations de chaînes

note: type: Plain text
en: The B<strxfrm>()  function transforms the I<src> string into a form such that the result of B<strcmp>(3)  on two strings that have been transformed with B<strxfrm>()  is the same as the result of B<strcoll>(3)  on the two strings before their transformation.  The first I<n> bytes of the transformed string are placed in I<dest>.  The transformation is based on the program's current locale for category B<LC_COLLATE>.  (See B<setlocale>(3)).
fr: La fonction B<strxfrm>() transforme la chaîne I<src> de telle manière que le résultat de B<strcmp>(3) sur deux chaînes ayant été modifiées par B<strxfrm>() soit le même que le résultat de B<strcoll>(3) sur les deux chaînes avant leur transformation. Les I<n> premiers octets de la chaîne transformée sont placés dans I<dest>. La transformation est effectuée en considérant la catégorie B<LC_COLLATE> de la localisation en cours (consultez B<setlocale>(3)).

note: type: Plain text
en: The B<strxfrm>()  function returns the number of bytes required to store the transformed string in I<dest> excluding the terminating null byte (\(aq\e0\(aq).  If the value returned is I<n> or more, the contents of I<dest> are indeterminate.
fr: La fonction B<strxfrm>() renvoie le nombre d'octets nécessaires pour stocker la chaîne transformée I<dest> sans compter l'octet nul («\ \e0\ ») final. Si la valeur renvoyée est supérieure ou égale à I<n>, le contenu de I<dest> est indéfini.

note: type: Plain text
en: In the I<POSIX> or I<C> locales B<strxfrm>()  is equivalent to copying the string with B<strncpy>(3).
fr: Dans les localisations I<POSIX> ou I<C>, B<strxfrm>() est équivalent à une copie avec B<strncpy>(3).
