perkamon - en to fr translation catalogue (305 entries)

note: type: TH
en: 2011-09-22
fr: 22 septembre 2011

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: btowc - convert single byte to wide character
fr: btowc - Convertir un octet en caractère large

note: type: Plain text
en: The B<btowc>()  function converts I<c>, interpreted as a multibyte sequence of length 1, starting in the initial shift state, to a wide character and returns it.  If I<c> is B<EOF> or not a valid multibyte sequence of length 1, the B<btowc>()  function returns B<WEOF>.
fr: La fonction B<btowc>() convertit I<c>, considéré comme une séquence multioctet de longueur 1, débutant dans l'état de décalage initial, en caractère large et la renvoie. Si I<c> n'est pas le caractère B<EOF> ou une séquence multioctet valable de longueur 1, la fonction B<btowc> renvoie B<WEOF>.

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

note: type: Plain text
en: The B<btowc>()  function returns the wide character converted from the single byte I<c>.  If I<c> is B<EOF> or not a valid multibyte sequence of length 1, it returns B<WEOF>.
fr: La fonction B<btowc> renvoie le caractère large converti à partir de l'octet I<c>. Si I<c> est B<EOF> ou n'est pas une séquence multioctet de longueur 1, elle renvoie B<WEOF>.

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

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

note: type: Plain text
en: This function should never be used.  It does not work for encodings which have state, and unnecessarily treats single bytes differently from multibyte sequences.  Use either B<mbtowc>(3)  or the thread-safe B<mbrtowc>(3)  instead.
fr: Cette fonction ne devrait jamais être utilisée. Elle ne permet pas d'encoder des séquences à état, et manipule inutilement les octets simples différemment des séquences multioctets. Utilisez soit B<mbtowc>(3), soit B<mbrtowc>(3) qui est sûre du point de vue des threads, à la place.

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: 2011-09-28
fr: 28 septembre 2011

note: type: Plain text
en: fgetws - read a wide-character string from a FILE stream
fr: fgetws - Lire une chaîne de caractères larges depuis un flux FILE

note: type: Plain text
en: The B<fgetws>()  function is the wide-character equivalent of the B<fgets>(3)  function.  It reads a string of at most I<n-1> wide characters into the wide-character array pointed to by I<ws>, and adds a terminating null wide character (L\(aq\e0\(aq).  It stops reading wide characters after it has encountered and stored a newline wide character.  It also stops when end of stream is reached.
fr: La fonction B<fgetws>() est l'équivalent pour les caractères larges de la fonction B<fgets>(3). Elle lit une chaîne de caractères d'au plus I<n-1> caractères larges dans le tableau de caractères larges pointés par I<ws>, puis ajoute un caractère large nul (L\(aq\e0\(aq) final. La lecture s'arrête dès qu'un caractère large de saut de ligne a été rencontré, et stocké. Elle s'arrête aussi lorsque la fin du flux est atteinte.

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

note: type: Plain text
en: For a nonlocking counterpart, see B<unlocked_stdio>(3).
fr: Pour une version de cette fonction ignorant les verrouillages, voir B<unlocked_stdio>(3).

note: type: Plain text
en: The B<fgetws>()  function, if successful, returns I<ws>.  If end of stream was already reached or if an error occurred, it returns NULL.
fr: La fonction B<fgetws>() renvoie I<ws> s'il n'y a pas d'erreur. Si la fin du flux est déjà atteinte, ou si une erreur se produit, elle renvoie NULL.

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

note: type: Plain text
en: In the absence of additional information passed to the B<fopen>(3)  call, it is reasonable to expect that B<fgetws>()  will actually read a multibyte string from the stream and then convert it to a wide-character string.
fr: En l'absence d'information supplémentaire transmise à l'appel B<fopen>(3), on peut raisonnablement supposer que B<fgetws>() lira en fait une chaîne multioctet depuis le flux, et la convertira en chaîne de caractères larges.

note: type: Plain text
en: This function is unreliable, because it does not permit to deal properly with null wide characters that may be present in the input.
fr: Cette fonction n'est pas fiable, car elle ne permet pas de traiter correctement les caractères larges nuls, susceptible d'être rencontrés en entrée.

note: type: Plain text
en: fputws - write a wide-character string to a FILE stream
fr: fputws - Écrire une chaîne de caractères larges dans un flux FILE

note: type: Plain text
en: The B<fputws>()  function is the wide-character equivalent of the B<fputs>(3)  function.  It writes the wide-character string starting at I<ws>, up to but not including the terminating null wide character (L\(aq\e0\(aq), to I<stream>.
fr: La fonction B<fputws>() est l'équivalent pour les caractères larges de la fonction B<fputs>(3). Elle écrit la chaîne de caractères larges commençant en I<ws>, jusqu'au caractère large nul L\(aq\e0\(aq final non compris, dans le flux I<stream>.

note: type: Plain text
en: The B<fputws>()  function returns a nonnegative integer if the operation was successful, or -1 to indicate an error.
fr: La fonction B<fputws>() renvoie un entier non négatif si elle réussit, ou -1 en cas d'erreur.

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

note: type: Plain text
en: In the absence of additional information passed to the B<fopen>(3)  call, it is reasonable to expect that B<fputws>()  will actually write the multibyte string corresponding to the wide-character string I<ws>.
fr: En l'absence d'information supplémentaire transmise à l'appel B<fopen>(3), on peut raisonnablement supposer que B<fputws>() écrira en fait une séquence multioctet correspondant à la chaîne de caractères larges I<ws>.

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

note: type: Plain text
en: fwide - set and determine the orientation of a FILE stream
fr: fwide - Définir et déterminer les orientations d'un flux FILE

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

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

note: type: Plain text
en: When I<mode> is zero, the B<fwide>()  function determines the current orientation of I<stream>.  It returns a positive value if I<stream> is wide-character oriented, that is, if wide-character I/O is permitted but char I/O is disallowed.  It returns a negative value if I<stream> is byte oriented\(emthat is, if char I/O is permitted but wide-character I/O is disallowed.  It returns zero if I<stream> has no orientation yet; in this case the next I/O operation might change the orientation (to byte oriented if it is a char I/O operation, or to wide-character oriented if it is a wide-character I/O operation).
fr: Lorsque I<mode> vaut zéro, la fonction B<fwide>() détermine l'orientation du flux I<stream>. Elle renvoie une valeur positive si I<stream> est orienté caractères larges, c'est-à-dire si les entrées-sorties par caractères larges sont autorisées, mais pas celles par octet. Elle renvoie une valeur négative si I<stream> est orienté octets, c'est-à-dire si les entrées-sorties par octet sont autorisées, mais pas celles par caractères larges. Elle renvoie zéro si I<stream> n'a pas encore d'orientation. Dans ce cas, l'opération d'entrée-sortie suivante peut changer son orientation (octet s'il s'agit d'une opération normale, caractères larges si c'est une opération avec des caractères larges).

note: type: Plain text
en: Once a stream has an orientation, it cannot be changed and persists until the stream is closed.
fr: une fois qu'un flux a une orientation, elle ne peut pas être changée, et persistera jusqu'à sa fermeture.

note: type: Plain text
en: When I<mode> is nonzero, the B<fwide>()  function first attempts to set I<stream>'s orientation (to wide-character oriented if I<mode> is greater than 0, or to byte oriented if I<mode> is less than 0).  It then returns a value denoting the current orientation, as above.
fr: Quand le I<mode> est non nul, la fonction B<fwide>() essaye d'abord de définir l'orientation correspondante du flux I<stream> (caractères larges si le I<mode> est supérieur à 0, octets s'il est négatif). Puis elle renvoie une valeur correspondant à l'orientation réelle, comme précédemment.

note: type: Plain text
en: The B<fwide>()  function returns the stream's orientation, after possibly changing it.  A positive return value means wide-character oriented.  A negative return value means byte oriented.  A return value of zero means undecided.
fr: La fonction B<fwide>() renvoie l'orientation du flux, après l'avoir éventuellement modifiée. Une valeur de retour positive représente une orientation caractères larges, une valeur de retour négative représente une orientation octets, et une valeur de retour nulle représente une orientation non définie.

note: type: Plain text
en: Wide-character output to a byte oriented stream can be performed through the B<fprintf>(3)  function with the B<%lc> and B<%ls> directives.
fr: Une sortie en caractères larges dans un flux orienté octets peut être réalisée avec la fonction B<fprintf>(3) en utilisant les directives B<%lc> et B<%ls>.

note: type: Plain text
en: Char oriented output to a wide-character oriented stream can be performed through the B<fwprintf>(3)  function with the B<%c> and B<%s> directives.
fr: Les sorties orientées caractères dans un flux orienté caractères larges sont possibles en utilisant les directives B<%c> et B<%s> de la fonction B<fwprintf>(3).

note: type: TH
en: 1999-07-25
fr: 25 juillet 1999

note: type: Plain text
en: getwchar - read a wide character from standard input
fr: getwchar - Lecture d'un caractère large depuis l'entrée standard

note: type: Plain text
en: The B<getwchar>()  function is the wide-character equivalent of the B<getchar>(3)  function.  It reads a wide character from I<stdin> and returns it.  If the end of stream is reached, or if I<ferror(stdin)> becomes true, it returns B<WEOF>.  If a wide-character conversion error occurs, it sets I<errno> to B<EILSEQ> and returns B<WEOF>.
fr: La fonction B<getwchar>() est l'équivalent pour les caractères larges de la fonction B<getchar>(3). Elle lit un caractère large depuis I<stdin> et le renvoie. Si la fin du flux est atteinte, ou si I<ferror(stdin)> devient vrai, elle renvoie B<WEOF>. Si une erreur de conversion de caractère large se produit, elle place B<EILSEQ> dans I<errno> et renvoie B<WEOF>.

note: type: Plain text
en: The B<getwchar>()  function returns the next wide-character from standard input, or B<WEOF>.
fr: La fonction B<getwchar>() renvoie le caractère large suivant lu dans l'entrée standard, ou B<WEOF>.

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

note: type: Plain text
en: It is reasonable to expect that B<getwchar>()  will actually read a multibyte sequence from standard input and then convert it to a wide character.
fr: On peut supposer raisonnablement que B<getwchar>() lira en fait une séquence multioctet depuis l'entrée standard, et la convertira en caractères larges.

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

note: type: Plain text
en: mbrlen - determine number of bytes in next multibyte character
fr: mbrlen - Calculer la longueur d'un caractère multioctets

note: type: Plain text
en: The B<mbrlen>()  function inspects at most I<n> bytes of the multibyte string starting at I<s> and extracts the next complete multibyte character.  It updates the shift state I<*ps>.  If the multibyte character is not the null wide character, it returns the number of bytes that were consumed from I<s>.  If the multibyte character is the null wide character, it resets the shift state I<*ps> to the initial state and returns 0.
fr: La fonction B<mbrlen>() examine au maximum I<n> octets de la séquence commençant en I<s> et en extrait le caractère multioctet complet suivant. Elle met à jour l'état de décalage I<*ps>. Si le caractère multioctet ne correspond pas au caractère large nul, elle renvoie le nombre d'octets qui ont été lus dans I<s>. Si ce caractère correspond au caractère large nul, elle réinitialise l'état I<*ps> et renvoie 0.

note: type: Plain text
en: If the I<n> bytes starting at I<s> do not contain a complete multibyte character, B<mbrlen>()  returns I<(size_t)\ -2>.  This can happen even if I<n> E<gt>= I<MB_CUR_MAX>, if the multibyte string contains redundant shift sequences.
fr: Si les I<n> octets commençant en I<s> ne contiennent pas un caractère multioctet complet, B<mbrlen>() renvoie I<(size_t)\ -2>. Ceci peut se produire même si I<n> E<gt>= I<MB_CUR_MAX>, dans le cas où la séquence multioctet contient des séquences de décalage redondantes.

note: type: Plain text
en: If the multibyte string starting at I<s> contains an invalid multibyte sequence before the next complete character, B<mbrlen>()  returns I<(size_t)\ -1> and sets I<errno> to B<EILSEQ>.  In this case, the effects on I<*ps> are undefined.
fr: Si la séquence multioctet commençant en I<s> contient une séquence invalide avant le prochain caractère complet, B<mbrlen>() renvoie I<(size_t)\ -1> et place dans I<errno> la valeur B<EILSEQ>. Dans ce cas, les effets sur I<*ps> sont indéfinis.

note: type: Plain text
en: If I<ps> is NULL, a static anonymous state known only to the B<mbrlen>()  function is used instead.
fr: Si I<ps> est un pointeur NULL, une zone de mémoire statique réservée à B<mbrlen>() est utilisée à sa place.

note: type: Plain text
en: The B<mbrlen>()  function returns the number of bytes parsed from the multibyte sequence starting at I<s>, if a non-null wide character was recognized.  It returns 0, if a null wide character was recognized.  It returns I<(size_t)\ -1> and sets I<errno> to B<EILSEQ>, if an invalid multibyte sequence was encountered.  It returns I<(size_t)\ -2> if it couldn't parse a complete multibyte character, meaning that I<n> should be increased.
fr: La fonction B<mbrlen>() renvoie le nombre d'octets balayés depuis la séquence commençant en I<s>, si un caractère large non nul a été reconnu. Elle renvoie zéro si un caractère large nul est rencontré. Elle renvoie I<(size_t)\ -1> et remplit I<errno> avec B<EILSEQ>, si une séquence invalide est trouvée. Elle renvoie I<(size_t)\ -2> si elle n'a pas trouvé de caractère entier, et si I<n> doit être augmenté.

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<mbrlen>()  function is thread-safe with exceptions.  It is not thread-safe if called with a NULL I<ps> parameter.
fr: La fonction B<mbrlen>() est sûre dans un contexte multithread avec exceptions. Elle n’est pas sûre dans un contexte multithread si appelées avec un paramètre I<ps> NULL.

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

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

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

note: type: Plain text
en: The main case for this function is when I<s> is not NULL and I<pwc> is not NULL.  In this case, the B<mbrtowc>()  function inspects at most I<n> bytes of the multibyte string starting at I<s>, extracts the next complete multibyte character, converts it to a wide character and stores it at I<*pwc>.  It updates the shift state I<*ps>.  If the converted wide character is not L\(aq\e0\(aq (the null wide character), it returns the number of bytes that were consumed from I<s>.  If the converted wide character is L\(aq\e0\(aq, it resets the shift state I<*ps> to the initial state and returns 0.
fr: L'utilisation principale de cette fonction est avec I<s> et I<pwc> non NULL. Dans ce cas, la fonction B<mbrtowc>() examine au plus I<n> octets de la chaîne multioctet commençant en I<s>, en extrait le prochain caractère multioctet complet, et le place en I<*pwc>. Elle met à jour l'état de décalage I<*ps>. Si le caractère large obtenu n'est pas L\(aq\e0\(aq (le caractère large nul), elle renvoie le nombre d'octets consommés depuis I<s>. Si le caractère large obtenu est L\(aq\e0\(aq, elle réinitialise l'état de décalage I<*ps> et renvoie zéro.

note: type: Plain text
en: If the I<n> bytes starting at I<s> do not contain a complete multibyte character, B<mbrtowc>()  returns I<(size_t)\ -2>.  This can happen even if I<n> E<gt>= I<MB_CUR_MAX>, if the multibyte string contains redundant shift sequences.
fr: Si les I<n> octets commençant en I<s> ne contiennent pas de caractère large complet, B<mbrtowc>() renvoie I<(size_t)\ -2>. Cela peut se produire même si I<n> E<gt>= I<MB_CUR_MAX>, lorsque la séquence multioctet contient des séquences de décalage redondantes.

note: type: Plain text
en: If the multibyte string starting at I<s> contains an invalid multibyte sequence before the next complete character, B<mbrtowc>()  returns I<(size_t)\ -1> and sets I<errno> to B<EILSEQ>.  In this case, the effects on I<*ps> are undefined.
fr: Si la séquence multioctet commençant en I<s> contient une séquence invalide avant le prochain caractère complet, B<mbrtowc>() renvoie I<(size_t)\ -1> et place dans I<errno> la valeur B<EILSEQ>. Dans ce cas, les effets sur I<*ps> sont indéfinis.

note: type: Plain text
en: A different case is when I<s> is not NULL but I<pwc> is NULL.  In this case, the B<mbrtowc>()  function behaves as above, except that it does not store the converted wide character in memory.
fr: Une autre situation est possible, si I<s> est non NULL, mais I<pwc> est NULL. Dans ce cas, B<mbrtowc>() se comporte comme précédemment, mais n'enregistre pas le caractère large obtenu.

note: type: Plain text
en: A third case is when I<s> is NULL.  In this case, I<pwc> and I<n> are ignored.  If the conversion state represented by I<*ps> denotes an incomplete multibyte character conversion, the B<mbrtowc>()  function returns I<(size_t)\ -1>, sets I<errno> to B<EILSEQ>, and leaves I<*ps> in an undefined state.  Otherwise, the B<mbrtowc>()  function puts I<*ps> in the initial state and returns 0.
fr: Un troisième cas se présente si I<s> est NULL. Alors, I<pwc> et I<n> sont ignorés. Si l'état de conversion représenté par I<*ps> indique une conversion multioctet incomplète, la fonction B<mbrtowc>() renvoie I<(size_t)\ -1>, remplie I<errno> avec B<EILSEQ>, et laisse I<*ps> dans un état indéfini. Sinon, la fonction B<mbrtowc>() replace I<*ps> dans l'état initial et renvoie 0.

note: type: Plain text
en: In all of the above cases, if I<ps> is NULL, a static anonymous state known only to the B<mbrtowc>()  function is used instead.  Otherwise, I<*ps> must be a valid I<mbstate_t> object.  An I<mbstate_t> object I<a> can be initialized to the initial state by zeroing it, for example using
fr: Dans tous ces cas, si I<ps> est un pointeur NULL, une zone de mémoire statique propre à B<mbrtowc>() est utilisée à sa place. Sinon, I<*ps> doit être un objet I<mbstate_t> valide. Un tel objet I<mbstate_t> noté I<a> peut être initialisé en le mettant à zéro, par exemple ainsi\ :

note: type: Plain text
en: The B<mbrtowc>()  function returns the number of bytes parsed from the multibyte sequence starting at I<s>, if a non-L\(aq\e0\(aq wide character was recognized.  It returns 0, if a L\(aq\e0\(aq wide character was recognized.  It returns I<(size_t)\ -1> and sets I<errno> to B<EILSEQ>, if an invalid multibyte sequence was encountered.  It returns I<(size_t)\ -2> if it couldn't parse a complete multibyte character, meaning that I<n> should be increased.
fr: La fonction B<mbrtowc>() renvoie le nombre d'octets balayés depuis la séquence commençant en I<s>, si un caractère large non nul a été reconnu. Elle renvoie zéro si un caractère large nul est rencontré. Elle renvoie I<(size_t)\ -1> et remplit I<errno> avec B<EILSEQ>, si une séquence invalide est trouvée. Elle renvoie I<(size_t)\ -2> si elle n'a pas trouvé de caractère entier, et si I<n> doit être augmenté.

note: type: Plain text
en: The B<mbrtowc>()  function is thread-safe with exceptions.  It is not thread-safe if called with a NULL I<ps> parameter.
fr: La fonction B<mbrtowc>() est sûre dans un contexte multithread avec exceptions. Elle n’est pas sûre dans un contexte multithread si appelées avec un paramètre I<ps> NULL.

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

note: type: Plain text
en: mbsinit - test for initial shift state
fr: mbsinit - Vérifier si la conversion est dans l'état initial

note: type: Plain text
en: Character conversion between the multibyte representation and the wide character representation uses conversion state, of type I<mbstate_t>.  Conversion of a string uses a finite-state machine; when it is interrupted after the complete conversion of a number of characters, it may need to save a state for processing the remaining characters.  Such a conversion state is needed for the sake of encodings such as ISO-2022 and UTF-7.
fr: La conversion de caractères entre la représentation multioctet et les caractères larges emploie un état de type I<mbstate_t>. La conversion d'une chaîne utilise un automate à états finis. Lorsqu'elle est interrompue après la conversion d'un nombre entier de caractères, il peut être nécessaire de mémoriser son état pour pouvoir traiter ultérieurement le reste de la chaîne. Un tel état de conversion est indispensable pour certains encodages tels que ISO-2022 et UTF-7.

note: type: Plain text
en: The initial state is the state at the beginning of conversion of a string.  There are two kinds of state: The one used by multibyte to wide character conversion functions, such as B<mbsrtowcs>(3), and the one used by wide character to multibyte conversion functions, such as B<wcsrtombs>(3), but they both fit in a I<mbstate_t>, and they both have the same representation for an initial state.
fr: L'état initial est celui du début de la conversion d'une chaîne. Il y a deux types d'états, celui utilisé par les conversions multioctets en caractères larges, comme pour B<mbsrtowcs>(3), et celui employé par les conversions inverses, comme pour B<wcsrtombs>(3). Toutefois, les deux types peuvent être stockés dans une variable I<mbstate_t>, et ils se présentent tous deux l'état initial sous la même forme.

note: type: Plain text
en: For 8-bit encodings, all states are equivalent to the initial state.  For multibyte encodings like UTF-8, EUC-*, BIG5 or SJIS, the wide character to multibyte conversion functions never produce non-initial states, but the multibyte to wide-character conversion functions like B<mbrtowc>(3)  do produce non-initial states when interrupted in the middle of a character.
fr: Pour les codages 8\ bits, tous les états sont équivalents à l'état initial. Pour les encodages multioctets comme UTF-8, EUC-* BIG5 ou SJIS, les fonctions de conversion de caractères larges en multioctets ne produisent jamais d'état non initial, mais les fonctions de conversion multioctets en caractères larges comme B<mbrtowc>(3) produisent un état non initial si elles sont interrompues au milieu d'un caractère.

note: type: Plain text
en: One possible way to create an I<mbstate_t> in initial state is to set it to zero:
fr: Une possibilité pour créer un état I<mbstate_t> initial est de le définir à zéro\ :

note: type: Plain text
en: On Linux, the following works as well, but might generate compiler warnings:
fr: Sous Linux, on peut aussi utiliser la ligne suivante, même si elle déclenche des avertissements du compilateur\ :

note: type: Plain text
en: The function B<mbsinit>()  tests whether I<*ps> corresponds to an initial state.
fr: La fonction B<mbsinit>() vérifie si I<*ps> correspond à un état initial.

note: type: Plain text
en: B<mbsinit>()  returns nonzero if I<*ps> is an initial state, or if I<ps> is NULL.  Otherwise it returns 0.
fr: La fonction B<mbsinit>() renvoie une valeur non nulle si I<*ps> est dans l'état initial, ou si I<ps> est un pointeur NULL. Sinon, elle renvoie zéro.

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

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

note: type: Plain text
en: mbsnrtowcs - convert a multibyte string to a wide-character string
fr: mbsnrtowcs - Convertir une séquence multioctet en chaîne de caractères larges

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

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<mbsnrtowcs>()  function is like the B<mbsrtowcs>(3)  function, except that the number of bytes to be converted, starting at I<*src>, is limited to I<nms>.
fr: La fonction B<mbsnrtowcs>() est équivalente à la fonction B<mbsrtowcs>(3), sauf qu'elle ne convertit qu'un nombre limité (à I<nms>) d'octets commençant en I<*src>.

note: type: Plain text
en: If I<dest> is not NULL, the B<mbsnrtowcs>()  function converts at most I<nms> bytes from the multibyte string I<*src> to a wide-character string starting at I<dest>.  At most I<len> wide characters are written to I<dest>.  The shift state I<*ps> is updated.  The conversion is effectively performed by repeatedly calling I<mbrtowc(dest, *src, n, ps)> where I<n> is some positive number, as long as this call succeeds, and then incrementing I<dest> by one and I<*src> by the number of bytes consumed.  The conversion can stop for three reasons:
fr: Si I<dest> n'est pas un pointeur NULL, la fonction B<mbsnrtowcs>() convertit au plus I<nms> octets depuis la séquence multioctet I<*src> en une chaîne de caractères larges située dans I<dest>. Au maximum I<len> caractères larges sont écrits dans I<dest>. L'état de conversion I<*ps> est mis à jour. La conversion est en fait réalisée en invoquant de façon répétée I<mbrtowc(dest, *src, n, ps)>, où I<n> est un nombre positif, aussi longtemps que l'appel réussit, puis en incrémentant I<dest> de un et en augmentant I<*src> du nombre d'octets lus. La conversion peut s'arrêter pour trois raisons\ :

note: type: Plain text
en: An invalid multibyte sequence has been encountered.  In this case, I<*src> is left pointing to the invalid multibyte sequence, I<(size_t)\ -1> is returned, and I<errno> is set to B<EILSEQ>.
fr: Une séquence multioctet incorrecte a été rencontrée. Dans ce cas, I<*src> pointera sur la séquence incorrecte, et la fonction renvoie I<(size_t)\ -1> en positionnant I<errno> à la valeur B<EILSEQ>.

note: type: Plain text
en: The I<nms> limit forces a stop, or I<len> non-L\(aq\e0\(aq wide characters have been stored at I<dest>.  In this case, I<*src> is left pointing to the next multibyte sequence to be converted, and the number of wide characters written to I<dest> is returned.
fr: L'arrêt est forcé à cause de la limite I<nms>, ou si I<len> caractères larges différents de L\(aq\e0\(aq ont été enregistrés en I<dest>. Dans ce cas, I<*src> pointe sur la séquence multioctet suivante, et le nombre de caractères larges écrits dans I<dest> est renvoyé.

note: type: Plain text
en: The multibyte string has been completely converted, including the terminating null wide character (\(aq\e0\(aq)  (which has the side effect of bringing back I<*ps> to the initial state).  In this case, I<*src> is set to NULL, and the number of wide characters written to I<dest>, excluding the terminating null wide character, is returned.
fr: La séquence multioctet a été complètement convertie, y compris le caractère nul (\(aq\e0\(aq) final (ce qui a pour effet de bord de ramener I<*ps> à l'état initial). Dans ce cas, I<*src> est mis à NULL, et le nombre de caractères écrits dans I<dest>, moins le caractère large nul final, est renvoyé.

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

note: type: Plain text
en: In both of the above cases, if I<ps> is NULL, a static anonymous state known only to the B<mbsnrtowcs>()  function is used instead.
fr: Dans tous les cas, si I<ps> est un pointeur NULL, un état anonyme statique, réservé à la fonction B<mbsnrtowcs>() est utilisé à sa place.

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

note: type: Plain text
en: The B<mbsnrtowcs>()  function returns the number of wide characters that make up the converted part of the wide-character string, not including the terminating null wide character.  If an invalid multibyte sequence was encountered, I<(size_t)\ -1> is returned, and I<errno> set to B<EILSEQ>.
fr: La fonction B<mbsnrtowcs>() renvoie le nombre de caractères larges placés dans la zone convertie, sans compter le caractère nul final. Si une séquence multioctet incorrecte est rencontrée, la fonction renvoie I<(size_t)\ -1>, et I<errno> contient B<EILSEQ>.

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

note: type: Plain text
en: Passing NULL as I<ps> is not multithread safe.
fr: L'utilisation d'un pointeur NULL pour I<ps> n'est pas sûre dans un contexte multithread.

note: type: Plain text
en: mbsrtowcs - convert a multibyte string to a wide-character string
fr: mbsrtowcs - Convertir une séquence multioctet en chaîne de caractères larges

note: type: Plain text
en: If I<dest> is not NULL, the B<mbsrtowcs>()  function converts the multibyte string I<*src> to a wide-character string starting at I<dest>.  At most I<len> wide characters are written to I<dest>.  The shift state I<*ps> is updated.  The conversion is effectively performed by repeatedly calling I<mbrtowc(dest, *src, n, ps)> where I<n> is some positive number, as long as this call succeeds, and then incrementing I<dest> by one and I<*src> by the number of bytes consumed.  The conversion can stop for three reasons:
fr: Si I<dest> n'est pas un pointeur NULL, la fonction B<mbsrtowcs>() convertit la séquence multioctet I<*src> en une chaîne de caractères larges débutant en I<dest>. Au maximum, I<len> caractères larges sont écrits dans I<dest>. L'état de conversion I<*ps> est mis à jour. La conversion est en fait réalisée en invoquant de façon répétée I<mbrtowc(dest, *src, n, ps)> où I<n> est un nombre positif, aussi longtemps que cet appel réussit, en incrémentant chaque fois I<dest> de un et en augmentant I<*src> du nombre d'octets lus. La conversion peut s'arrêter pour trois raisons\ :

note: type: Plain text
en: I<len> non-L\(aq\e0\(aq wide characters have been stored at I<dest>.  In this case, I<*src> is left pointing to the next multibyte sequence to be converted, and the number of wide characters written to I<dest> is returned.
fr: I<len> caractères larges différents de L\(aq\e0\(aq ont été enregistrés en I<dest>. Dans ce cas, I<*src> pointe sur la séquence multioctet suivante, et le nombre de caractères larges écrites dans I<dest> est renvoyé.

note: type: Plain text
en: The multibyte string has been completely converted, including the terminating null wide character (\(aq\e0\(aq), which has the side effect of bringing back I<*ps> to the initial state.  In this case, I<*src> is set to NULL, and the number of wide characters written to I<dest>, excluding the terminating null wide character, is returned.
fr: La séquence multioctet a été complètement convertie, y compris le caractère nul (\(aq\e0\(aq) final, ce qui a pour effet de bord de ramener I<*ps> à l'état initial. Dans ce cas, I<*src> est mis à NULL, et le nombre de caractères écrits dans I<dest>, moins le caractère large nul final, est renvoyé.

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

note: type: Plain text
en: In both of the above cases, if I<ps> is NULL, a static anonymous state known only to the B<mbsrtowcs>()  function is used instead.
fr: Dans tous les cas, si I<ps> est un pointeur NULL, un état anonyme statique, réservé à la fonction B<mbsnrtowcs>() est utilisé à sa place.

note: type: Plain text
en: The B<mbsrtowcs>()  function returns the number of wide characters that make up the converted part of the wide-character string, not including the terminating null wide character.  If an invalid multibyte sequence was encountered, I<(size_t)\ -1> is returned, and I<errno> set to B<EILSEQ>.
fr: La fonction B<mbsrtowcs>() renvoie le nombre de caractères larges placés dans la zone convertie, sans compter le caractère nul final. Si une séquence multioctet incorrecte est rencontrée, la fonction renvoie I<(size_t)\ -1>, et I<errno> contient B<EILSEQ>.

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

note: type: Plain text
en: putwchar - write a wide character to standard output
fr: putwchar - Écriture d'un caractère large sur la sortie standard

note: type: Plain text
en: The B<putwchar>()  function is the wide-character equivalent of the B<putchar>(3)  function.  It writes the wide character I<wc> to I<stdout>.  If I<ferror(stdout)> becomes true, it returns B<WEOF>.  If a wide character conversion error occurs, it sets I<errno> to B<EILSEQ> and returns B<WEOF>.  Otherwise it returns I<wc>.
fr: La fonction B<putwchar>() est l'équivalent pour les caractères larges de la fonction B<putchar>(3). Elle écrit le caractère large I<wc> sur I<stdout>. Si B<ferror>(I<stdout>) devient vrai, elle renvoie B<WEOF>. Si une erreur de conversion de caractère large se produit, elle remplit I<errno> avec B<EILSEQ> et renvoie B<WEOF>. Sinon, elle renvoie I<wc>.

note: type: Plain text
en: The B<putwchar>()  function returns I<wc> if no error occurred, or B<WEOF> to indicate an error.
fr: La fonction B<putwchar>() renvoie I<wc> lorsqu'elle réussit, ou B<WEOF> en cas d'erreur.

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

note: type: Plain text
en: It is reasonable to expect that B<putwchar>()  will actually write the multibyte sequence corresponding to the wide character I<wc>.
fr: On peut supposer raisonnablement que B<putwchar>() écrira en fait une séquence multioctet correspondant au caractère large I<wc>.

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

note: type: Plain text
en: ungetwc - push back a wide character onto a FILE stream
fr: ungetwc - Remettre un caractère large dans un flux

note: type: Plain text
en: The B<ungetwc>()  function is the wide-character equivalent of the B<ungetc>(3)  function.  It pushes back a wide character onto I<stream> and returns it.
fr: La fonction B<ungetwc>() est l'équivalent de la fonction B<ungetc>(3) pour les caractères larges. Elle remet un caractère large dans I<stream> et renvoie sa valeur.

note: type: Plain text
en: If I<wc> is B<WEOF>, it returns B<WEOF>.  If I<wc> is an invalid wide character, it sets I<errno> to B<EILSEQ> and returns B<WEOF>.
fr: Si I<wc> est B<WEOF>, B<WEOF> est renvoyé. Si I<wc> est un caractère large non valide, I<errno> est positionné à B<EILSEQ> et B<WEOF> est renvoyé.

note: type: Plain text
en: If I<wc> is a valid wide character, it is pushed back onto the stream and thus becomes available for future wide-character read operations.  The file-position indicator is decremented by one or more.  The end-of-file indicator is cleared.  The backing storage of the file is not affected.
fr: Si I<wc> est un caractère large valide, celui-ci est remis dans le flux et devient alors disponible pour de nouvelles opérations de lecture de caractères larges. Le pointeur de fichier est décrémenté de un ou plus. L'indicateur de fin de fichier est réinitialisé. L'image du fichier sur disque n'est pas affectée.

note: type: Plain text
en: Note: I<wc> need not be the last wide-character read from the stream; it can be any other valid wide character.
fr: NB\ : I<wc> n'a pas besoin d'être le dernier caractère large lu depuis le flux\ ; ce peut être n'importe quel autre caractère large.

note: type: Plain text
en: If the implementation supports multiple push-back operations in a row, the pushed-back wide characters will be read in reverse order; however, only one level of push-back is guaranteed.
fr: Si l'implémentation supporte la remise dans le flux de caractères multiples, les caractères larges seront lus dans l'ordre inverse. Cependant, seulement un niveau de réinjection est garanti.

note: type: Plain text
en: The B<ungetwc>()  function returns I<wc> when successful, or B<WEOF> upon failure.
fr: La fonction B<ungetwc>() renvoie I<wc> en cas de succès ou B<WEOF> en cas d'erreur.

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

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

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

note: type: Plain text
en: wcpcpy - copy a wide-character string, returning a pointer to its end
fr: wcpcpy - Copier une chaîne de caractères larges et indiquer sa fin

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

note: type: Plain text
en: The B<wcpcpy>()  function is the wide-character equivalent of the B<stpcpy>(3)  function.  It copies the wide-character string pointed to by I<src>, including the terminating null wide character (L\(aq\e0\(aq), to the array pointed to by I<dest>.
fr: La fonction B<wcpcpy>() est l'équivalent pour les caractères larges de la fonction B<stpcpy>(3). Elle copie la chaîne pointée par I<src> y compris le caractère large nul (L\(aq\e0\(aq) final, dans la zone pointée par I<dest>.

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<wcslen(src)+1> wide characters at I<dest>.
fr: Le programmeur doit s'assurer qu'il y a assez de place pour au moins I<wcslen(src)+1> caractères larges en I<dest>.

note: type: Plain text
en: B<wcpcpy>()  returns a pointer to the end of the wide-character string I<dest>, that is, a pointer to the terminating null wide character.
fr: B<wcpcpy>() renvoie un pointeur sur la fin de la chaîne de caractères larges I<dest>, c'est-à-dire un pointeur sur le caractère large nul final.

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

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

note: type: Plain text
en: wcpncpy - copy a fixed-size string of wide characters, returning a pointer to its end
fr: wcpncpy - Copier une chaîne de caractères larges et indiquer sa fin

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

note: type: Plain text
en: The B<wcpncpy>()  function is the wide-character equivalent of the B<stpncpy>(3)  function.  It copies at most I<n> wide characters from the wide-character string pointed to by I<src>, including the terminating null wide (L\(aq\e0\(aq), to the array pointed to by I<dest>.  Exactly I<n> wide characters are written at I<dest>.  If the length I<wcslen(src)> is smaller than I<n>, the remaining wide characters in the array pointed to by I<dest> are filled with L\(aq\e0\(aq characters.  If the length I<wcslen(src)> is greater than or equal to I<n>, the string pointed to by I<dest> will not be L\(aq\e0\(aq terminated.
fr: La fonction B<wcpncpy>() est l'équivalent pour les caractères larges de la fonction B<stpncpy>(3). Elle copie au plus I<n> caractères larges depuis la chaîne pointée par I<src>, y compris le caractère large nul (L\(aq\e0\(aq) final, vers la chaîne pointée par I<dest>. I<n> caractères exactement seront écrits dans I<dest>. Si la longueur I<wcslen(src)> est inférieure à I<n>, les caractères restants dans la table pointée par I<dest> sont remplis de caractères L\(aq\e0\(aq. Si la longueur I<wcslen(src)> est supérieure ou égale à I<n>, la chaîne pointée par I<dest> ne sera pas terminée par un L\(aq\e0\(aq.

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

note: type: Plain text
en: B<wcpncpy>()  returns a pointer to the last wide character written, that is, I<dest>+I<n>-1.
fr: B<wcpncpy>() renvoie un pointeur sur le dernier caractère écrit, c'est-à-dire I<dest>+I<n>-1.

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

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

note: type: Plain text
en: The main case for this function is when I<s> is not NULL and I<wc> is not a null wide character (L\(aq\e0\(aq).  In this case, the B<wcrtomb>()  function converts the wide character I<wc> to its multibyte representation and stores it at the beginning of the character array pointed to by I<s>.  It updates the shift state I<*ps>, and returns the length of said multibyte representation, that is, the number of bytes written at I<s>.
fr: L'utilisation principale de cette fonction est le cas où I<s> est non NULL, et I<wc> n'est pas un caractère large nul (L\(aq\e0\(aq). Alors, la fonction B<wcrtomb>() convertit le caractère large I<wc> dans sa représentation multioctet, et l'enregistre au début de la chaîne pointée par I<s>. Elle met à jour l'état de conversion I<*ps>, et renvoie la longueur de la représentation multioctet, c'est-à-dire le nombre d'octets écrits en I<s>.

note: type: Plain text
en: A different case is when I<s> is not NULL, but I<wc> is a null wide character (L\(aq\e0\(aq).  In this case, the B<wcrtomb>()  function stores at the character array pointed to by I<s> the shift sequence needed to bring I<*ps> back to the initial state, followed by a \(aq\e0\(aq byte.  It updates the shift state I<*ps> (i.e., brings it into the initial state), and returns the length of the shift sequence plus one, that is, the number of bytes written at I<s>.
fr: Une autre possibilité peut se présenter quand I<s> est non NULL, mais I<wc> est un caractère large nul (L\(aq\e0\(aq). Dans cette situation, la fonction B<wcrtomb>() enregistre dans la chaîne de caractères pointée par I<s> la séquence de décalages nécessaire pour ramener I<*ps> à son état initial, suivie d'un octet \(aq\e0\(aq. Elle met à jour l'état I<*ps> (le ramène donc à l'état initial), et renvoie la longueur de la séquence en ajoutant un pour compter le caractère nul final, c'est-à-dire le nombre d'octets écrits dans I<s>.

note: type: Plain text
en: A third case is when I<s> is NULL.  In this case, I<wc> is ignored, and the function effectively returns
fr: Un troisième cas se présente quand I<s> est NULL. Alors, I<wc> est ignoré, et la fonction renvoie alors le résultat de

note: type: Plain text
en:     wcrtomb(buf, L\(aq\e0\(aq, ps)
fr:     wcrtomb(I<tampon>,L\(aq\e0\(aq, ps)

note: type: Plain text
en: where I<buf> is an internal anonymous buffer.
fr: où I<tampon> est un tampon interne anonyme.

note: type: Plain text
en: In all of the above cases, if I<ps> is NULL, a static anonymous state known only to the B<wcrtomb>()  function is used instead.
fr: Dans tous les cas ci-dessus, si I<ps> est un pointeur NULL, un état statique interne est utilisé à la place, qui n'est connu que de la fonction B<wcrtomb>().

note: type: Plain text
en: The B<wcrtomb>()  function returns the number of bytes that have been or would have been written to the byte array at I<s>.  If I<wc> can not be represented as a multibyte sequence (according to the current locale), I<(size_t)\ -1> is returned, and I<errno> set to B<EILSEQ>.
fr: La fonction B<wcrtomb>() renvoie le nombre d'octets qui ont été - ou qui auraient été - écrits dans le tableau d'octets I<s>. Si I<wc> ne peut pas être représenté comme une séquence multioctet (dans la locale en cours), elle renvoie I<(size_t)\ -1>, et place B<EILSEQ> dans I<errno>.

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

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

note: type: Plain text
en: wcscasecmp - compare two wide-character strings, ignoring case
fr: wcscasecmp - Comparer deux chaînes de caractères larges en ignorant la casse

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

note: type: Plain text
en: The B<wcscasecmp>()  function is the wide-character equivalent of the B<strcasecmp>(3)  function.  It compares the wide-character string pointed to by I<s1> and the wide-character string pointed to by I<s2>, ignoring case differences (B<towupper>(3), B<towlower>(3)).
fr: La fonction B<wcscasecmp>() est l'équivalent pour caractères larges de la fonction B<strcasecmp>(3). Elle compare la chaîne de caractères larges pointée par I<s1> avec celle pointée par I<s2>, en ignorant les différences de casse (B<towupper>(3), B<towlower>(3)).

note: type: Plain text
en: The B<wcscasecmp>()  function returns zero if the wide-character strings at I<s1> and I<s2> are equal except for case distinctions.  It returns a positive integer if I<s1> is greater than I<s2>, ignoring case.  It returns a negative integer if I<s1> is smaller than I<s2>, ignoring case.
fr: La fonction B<wcscasecmp>() renvoie zéro si les chaînes de caractères larges I<s1> et I<s2> sont égales excepté pour des distinctions de casse. Elle renvoie un entier positif si I<s1> est supérieur à I<s2>, en ignorant la casse. Elle renvoie un entier négatif si I<s1> est inférieur à I<s2>, en ignorant la casse.

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

note: type: Plain text
en: The B<wcscasecmp>()  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<wcscasecmp>() 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 la locale pendant son exécution.

note: type: Plain text
en: POSIX.1-2008.  This function is not specified in POSIX.1-2001, and is not widely available on other systems.
fr: POSIX.1-2008. Cette fonction n'est pas spécifiée dans POSIX.1-2001 et n'est que rarement disponible sur d'autres systèmes.

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

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

note: type: Plain text
en: wcscat - concatenate two wide-character strings
fr: wcscat - Concaténer deux chaînes de caractères larges

note: type: Plain text
en: The B<wcscat>()  function is the wide-character equivalent of the B<strcat>(3)  function.  It copies the wide-character string pointed to by I<src>, including the terminating null wide character (L\(aq\e0\(aq), to the end of the wide-character string pointed to by I<dest>.
fr: La fonction B<wcscat>() est l'équivalent pour les caractères larges de la fonction B<strcat>(3). Elle copie la chaîne de caractères larges pointée par I<src> à la fin de celle pointée par I<dest>, puis ajoute un caractère large nul (L\(aq\e0\(aq) final.

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

note: type: Plain text
en: B<wcscat>()  returns I<dest>.
fr: B<wcscat>() renvoie I<dest>.

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

note: type: Plain text
en: wcschr - search a wide character in a wide-character string
fr: wcschr - Rechercher un caractère large dans une chaîne

note: type: Plain text
en: The B<wcschr>()  function is the wide-character equivalent of the B<strchr>(3)  function.  It searches the first occurrence of I<wc> in the wide-character string pointed to by I<wcs>.
fr: La fonction B<wcschr>() est l'équivalent pour les caractères larges de la fonction B<strchr>(3). Elle recherche la première occurrence de I<wc> dans la chaîne de caractères larges pointée par I<wcs>.

note: type: Plain text
en: The B<wcschr>()  function returns a pointer to the first occurrence of I<wc> in the wide-character string pointed to by I<wcs>, or NULL if I<wc> does not occur in the string.
fr: La fonction B<wcschr>() renvoie un pointeur sur la première occurrence de I<wc> dans la chaîne de caractères larges I<wcs>, ou NULL si I<wc> ne s'y trouve pas.

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

note: type: Plain text
en: wcscmp - compare two wide-character strings
fr: wcscmp - Comparer deux chaînes de caractères larges

note: type: Plain text
en: The B<wcscmp>()  function is the wide-character equivalent of the B<strcmp>(3)  function.  It compares the wide-character string pointed to by I<s1> and the wide-character string pointed to by I<s2>.
fr: La fonction B<wcscmp>() est l'équivalent pour les caractères larges de la fonction B<strcmp>(3). Elle compare la chaîne de caractères larges pointée par I<s1> avec celle pointée par I<s2>.

note: type: Plain text
en: The B<wcscmp>()  function returns zero if the wide-character strings at I<s1> and I<s2> are equal.  It returns an integer greater than zero if at the first differing position I<i>, the corresponding wide-character I<s1[i]> is greater than I<s2[i]>.  It returns an integer less than zero if at the first differing position I<i>, the corresponding wide-character I<s1[i]> is less than I<s2[i]>.
fr: La fonction B<wcscmp>() renvoie zéro si les chaînes de caractères larges I<s1> et I<s2> sont égales. Elle renvoie un entier positif si à l'emplacement I<i> de la première différence, le caractère large correspondant I<s1[i]> est supérieur à I<s2[i]>. Elle renvoie un entier négatif si I<s1[i]> est inférieur à I<s2[i]>.

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

note: type: Plain text
en: wcscpy - copy a wide-character string
fr: wcscpy - Copier une chaîne de caractères larges

note: type: Plain text
en: The B<wcscpy>()  function is the wide-character equivalent of the B<strcpy>(3)  function.  It copies the wide-character string pointed to by I<src>, including the terminating null wide character (L\(aq\e0\(aq), to the array pointed to by I<dest>.
fr: La fonction B<wcscpy>() est l'équivalent pour caractères larges de la fonction B<strcpy>(3). Elle copie la chaîne de caractères larges pointée par I<src>, y compris le caractère large nul (L\(aq\e0\(aq) final, à l'emplacement pointé par I<dest>.

note: type: Plain text
en: B<wcscpy>()  returns I<dest>.
fr: B<wcscpy>() renvoie I<dest>.

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

note: type: Plain text
en: wcscspn - search a wide-character string for any of a set of wide characters
fr: wcscspn - Extraire des portions de chaîne de caractères larges

note: type: Plain text
en: B<size_t wcscspn(const wchar_t *>I<wcs>B<, const wchar_t *>I<reject>B<);>
fr: B<size_t wcscspn(const wchar_t *>I<wcs>B<, const wchar_t *>I<rejet>B<);>

note: type: Plain text
en: The B<wcscspn>()  function is the wide-character equivalent of the B<strcspn>(3)  function.  It determines the length of the longest initial segment of I<wcs> which consists entirely of wide-characters not listed in I<reject>.  In other words, it searches for the first occurrence in the wide-character string I<wcs> of any of the characters in the wide-character string I<reject>.
fr: La fonction B<wcscspn>() est l'équivalent pour caractères larges de la fonction B<strcspn>(3). Elle détermine la longueur du plus long segment initial de I<wcs> constitué entièrement de caractères larges non cités dans I<rejet>. En d'autres termes, elle cherche la première occurrence de l'un des caractères larges contenus dans I<rejet> au sein de la chaîne I<wcs>.

note: type: Plain text
en: The B<wcscspn>()  function returns the number of wide characters in the longest initial segment of I<wcs> which consists entirely of wide-characters not listed in I<reject>.  In other words, it returns the position of the first occurrence in the wide-character string I<wcs> of any of the characters in the wide-character string I<reject>, or I<wcslen(wcs)> if there is none.
fr: La fonction B<wcscspn>() renvoie le nombre de caractères larges du segment initial de la chaîne I<wcs> non contenus dans I<rejet>. Elle retourne donc la position de la première occurrence d'un caractère de la chaîne I<rejet> au sein de I<wcs> ou I<wcslen(wcs)> si aucun n'est trouvé.

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

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

note: type: Plain text
en: wcsdup - duplicate a wide-character string
fr: wcsdup - Dupliquer une chaîne de caractères larges

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

note: type: Plain text
en: The B<wcsdup>()  function is the wide-character equivalent of the B<strdup>(3)  function.  It allocates and returns a new wide-character string whose initial contents is a duplicate of the wide-character string pointed to by I<s>.
fr: La fonction B<wcsdup>() est l'équivalent pour caractères larges de la fonction B<strdup>(3). Elle alloue et renvoie une nouvelle chaîne de caractères larges dont le contenu initial est une copie de la chaîne pointée par I<s>.

note: type: Plain text
en: Memory for the new wide-character string is obtained with B<malloc>(3), and should be freed with B<free>(3).
fr: La mémoire nécessaire est obtenue grâce à B<malloc>(3), et doit être libérée avec B<free>(3).

note: type: Plain text
en: On success, B<wcsdup>()  returns a pointer to the new wide-character string.  On error, it returns -1, with I<errno> set to indicate the cause of the error.
fr: En cas de succès, B<wcsdup>() renvoie un pointeur sur la nouvelle chaîne de caractères larges. En cas d'erreur, -1 est renvoyé 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: type: TH
en: 2013-11-21
fr: 21 novembre 2013

note: type: Plain text
en: wcslen - determine the length of a wide-character string
fr: wcslen - Déterminer la longueur d'une chaîne de caractères larges

note: type: Plain text
en: The B<wcslen>()  function is the wide-character equivalent of the B<strlen>(3)  function.  It determines the length of the wide-character string pointed to by I<s>, excluding the terminating null wide character (L\(aq\e0\(aq).
fr: La fonction B<wcslen>() est l'équivalent de la fonction B<strlen>(3) pour les caractères larges. Elle détermine la longueur de la chaîne pointée par I<s>, sans compter le caractère large nul (L\(aq\e0\(aq) final.

note: type: Plain text
en: The B<wcslen>()  function returns the number of wide characters in I<s>.
fr: La fonction B<wcslen>() renvoie le nombre de caractères larges de I<s> [Ndt\ : B<pas> le nombre d'octets\ !]

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

note: type: Plain text
en: wcsncasecmp - compare two fixed-size wide-character strings, ignoring case
fr: wcsncasecmp - Comparer indépendamment de la casse deux chaînes de caractères larges de longueur fixe

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

note: type: Plain text
en: The B<wcsncasecmp>()  function is the wide-character equivalent of the B<strncasecmp>(3)  function.  It compares the wide-character string pointed to by I<s1> and the wide-character string pointed to by I<s2>, but at most I<n> wide characters from each string, ignoring case differences (B<towupper>(3), B<towlower>(3)).
fr: La fonction B<wcsncasecmp>() est l'équivalent pour caractères larges de la fonction B<strncasecmp>(3). Elle compare la chaîne de caractères larges pointée par I<s1> avec celle pointée par I<s2>, en ne considérant que I<n> caractères larges au maximum, et en ignorant les différences de casse (B<towupper>(3), B<towlower>(3)).

note: type: Plain text
en: The B<wcsncasecmp>()  function returns zero if the wide-character strings at I<s1> and I<s2>, truncated to at most length I<n>, are equal except for case distinctions.  It returns a positive integer if truncated I<s1> is greater than truncated I<s2>, ignoring case.  It returns a negative integer if truncated I<s1> is smaller than truncated I<s2>, ignoring case.
fr: La fonction B<wcsncasecmp>() renvoie zéro si les chaînes de caractères larges I<s1> et I<s2>, tronquées éventuellement à I<n> caractères, sont égales hormis pour les distinctions de casse. Elle renvoie un entier positif si la chaîne tronquée I<s1> est supérieure à la chaîne tronquée I<s2>, en ignorant la casse. Elle renvoie un entier négatif si la chaîne tronquée I<s1> est inférieure à la chaîne tronquée I<s2>, en ignorant la casse.

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

note: type: Plain text
en: The B<wcsncasecmp>()  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<wcsncasecmp>() 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 la locale pendant son exécution.

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

note: type: TH
en: 2013-11-25
fr: 25 novembre 2013

note: type: Plain text
en: wcsncat - concatenate two wide-character strings
fr: wcsncat - Concaténer deux chaînes de caractères larges

note: type: Plain text
en: The B<wcsncat>()  function is the wide-character equivalent of the B<strncat>(3)  function.  It copies at most I<n> wide characters from the wide-character string pointed to by I<src> to the end of the wide-character string pointed to by I<dest>, and adds a terminating null wide character (L\(aq\e0\(aq).
fr: La fonction B<wcsncat>() est l'équivalent pour les caractères larges de la fonction B<strncat>(3). Elle copie au plus I<n> caractères larges depuis la chaîne pointée par I<src> à la fin de celle pointée par I<dest>, puis ajoute un caractère large nul (L\(aq\e0\(aq) final.

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

note: type: Plain text
en: B<wcsncat>()  returns I<dest>.
fr: B<wcsncat>() renvoie I<dest>.

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

note: type: Plain text
en: wcsncmp - compare two fixed-size wide-character strings
fr: wcsncmp - Comparer deux chaînes de caractères larges de longueur fixe

note: type: Plain text
en: The B<wcsncmp>()  function is the wide-character equivalent of the B<strncmp>(3)  function.  It compares the wide-character string pointed to by I<s1> and the wide-character string pointed to by I<s2>, but at most I<n> wide characters from each string.  In each string, the comparison extends only up to the first occurrence of a null wide character (L\(aq\e0\(aq), if any.
fr: La fonction B<wcsncmp>() est l'équivalent pour les caractères larges de la fonction B<strncmp>(3). Elle compare la chaîne de caractères larges pointée par I<s1> et celle pointée par I<s2>, en ne considérant que I<n> caractères larges au maximum pour chaque chaîne. Au sein de chaque chaîne, la comparaison n'a lieu que jusqu'à la première occurrence d'un caractère large nul (L\(aq\e0\(aq), s'il y en a un.

note: type: Plain text
en: The B<wcsncmp>()  function returns zero if the wide-character strings at I<s1> and I<s2>, truncated to at most length I<n>, are equal.  It returns an integer greater than zero if at the first differing position I<i> (I<i> E<lt> I<n>), the corresponding wide-character I<s1[i]> is greater than I<s2[i]>.  It returns an integer less than zero if at the first differing position I<i> (i E<lt> I<n>), the corresponding wide-character I<s1[i]> is less than I<s2[i]>.
fr: La fonction B<wcsncmp>() renvoie zéro si les chaînes de caractères larges I<s1> et I<s2>, tronquées au besoin à I<n> caractères, sont égales. Elle renvoie un entier positif lorsqu'à l'emplacement I<i> de la première différence (I<i> E<lt> I<n>), le caractère large correspondant I<s1[i]> est supérieur à I<s2[i]>. Elle renvoie un entier négatif si I<s1[i]> est inférieur à I<s2[i]>.

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

note: type: Plain text
en: wcsncpy - copy a fixed-size string of wide characters
fr: wcsncpy - Copier une chaîne de caractères larges de longueur fixe

note: type: Plain text
en: The B<wcsncpy>()  function is the wide-character equivalent of the B<strncpy>(3)  function.  It copies at most I<n> wide characters from the wide-character string pointed to by I<src>, including the terminating null wide character (L\(aq\e0\(aq), to the array pointed to by I<dest>.  Exactly I<n> wide characters are written at I<dest>.  If the length I<wcslen(src)> is smaller than I<n>, the remaining wide characters in the array pointed to by I<dest> are filled with null wide characters.  If the length I<wcslen(src)> is greater than or equal to I<n>, the string pointed to by I<dest> will not be terminated by a null wide character.
fr: La fonction B<wcsncpy>() est l'équivalent pour les caractères larges de la fonction B<strncpy>(3). Elle copie au plus I<n> caractères larges depuis la chaîne pointée par I<src>, y compris le caractère large nul (L\(aq\e0\(aq) final, vers la zone pointée par I<dest>. Elle écrit exactement I<n> caractères larges dans I<dest>. Si la longueur I<wcslen(src)> est inférieure à I<n>, les caractères restants dans la zone pointée par I<dest> seront remplis par des caractères larges nuls. Si la longueur I<wcslen(src)> est supérieure ou égale à I<n>, la chaîne pointée par I<dest> ne sera pas terminée par un caractère large nul.

note: type: Plain text
en: B<wcsncpy>()  returns I<dest>.
fr: B<wcsncpy>() renvoie I<dest>.

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

note: type: Plain text
en: wcsnlen - determine the length of a fixed-size wide-character string
fr: wcsnlen - Déterminer la longueur d'une chaîne de caractères larges limitée

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

note: type: Plain text
en: The B<wcsnlen>()  function is the wide-character equivalent of the B<strnlen>(3)  function.  It returns the number of wide-characters in the string pointed to by I<s>, not including the terminating null wide character (L\(aq\e0\(aq), but at most I<maxlen> wide characters (note: this parameter is not a byte count).  In doing this, B<wcsnlen>()  looks at only the first I<maxlen> wide characters at I<s> and never beyond I<s+maxlen>.
fr: La fonction B<wcsnlen>() est l'équivalent pour les caractères larges de la fonction B<strnlen>(3). Elle renvoie le nombre de caractères larges se trouvant dans la chaîne pointée par I<s>, sans compter le caractère large nul (L\(aq\e0\(aq) final, en se limitant au maximum à I<maxlen> caractères larges (remarque : ce paramètre n'est pas un décompte d'octets). Pour ce faire, B<wcsnlen>() n'examine que les I<maxlen> premiers caractères larges de I<s> et jamais au-delà de I<s+maxlen>.

note: type: Plain text
en: The B<wcsnlen>()  function returns I<wcslen(s)>, if that is less than I<maxlen>, or I<maxlen> if there is no null wide character among the first I<maxlen> wide characters pointed to by I<s>.
fr: La fonction B<wcsnlen>() renvoie I<wcslen(s)>, si cette valeur est inférieure à I<maxlen>, ou I<maxlen> si elle n'a pas rencontré de caractère large nul en examinant les I<maxlen> premiers caractères larges pointés par I<s>.

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

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

note: type: Plain text
en: wcsnrtombs - convert a wide-character string to a multibyte string
fr: wcsnrtombs - Convertir une chaîne de caractères larges en séquence multioctet

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

note: type: Plain text
en: The B<wcsnrtombs>()  function is like the B<wcsrtombs>(3)  function, except that the number of wide characters to be converted, starting at I<*src>, is limited to I<nwc>.
fr: La fonction B<wcsnrtombs>() est l'équivalent de B<wcsrtombs>(3), sauf que le nombre de caractères larges à convertir est limité (à I<nwc>), en commençant en I<*src>.

note: type: Plain text
en: If I<dest> is not NULL, the B<wcsnrtombs>()  function converts at most I<nwc> wide characters from the wide-character string I<*src> to a multibyte string starting at I<dest>.  At most I<len> bytes are written to I<dest>.  The shift state I<*ps> is updated.  The conversion is effectively performed by repeatedly calling I<wcrtomb(dest, *src, ps)>, as long as this call succeeds, and then incrementing I<dest> by the number of bytes written and I<*src> by one.  The conversion can stop for three reasons:
fr: Si I<dest> n'est pas un pointeur NULL, la fonction B<wcsnrtombs>() convertit au maximum I<nwc> caractères larges depuis la chaîne I<*src> vers la séquence multioctet située en I<dest>. Au plus I<len> octets seront écrits dans I<dest>. L'état de conversion I<*ps> est mis à jour. La conversion est réalisée en fait en invoquant à répétition I<wcrtomb(dest,*src,ps)>, aussi longtemps que cet appel réussit, en augmentant à chaque fois I<dest> du nombre d'octets écrits, et en incrémentant I<*src> de 1. La conversion peut se terminer pour trois raisons\ :

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

note: type: Plain text
en: I<nwc> wide characters have been converted without encountering a null wide character (L\(aq\e0\(aq), or the length limit forces a stop.  In this case, I<*src> is left pointing to the next wide character to be converted, and the number of bytes written to I<dest> is returned.
fr: On a converti I<nwc> caractères larges sans rencontrer de caractère large nul (L\(aq\e0\(aq), ou la limite I<len> est atteinte. Dans ce cas, I<*src> pointera sur le caractère suivant à convertir, et la fonction renvoie le nombre d'octets écrits dans I<dest>.

note: type: Plain text
en: The wide-character string has been completely converted, including the terminating null wide character (which has the side effect of bringing back I<*ps> to the initial state).  In this case, I<*src> is set to NULL, and the number of bytes written to I<dest>, excluding the terminating null byte (\(aq\e0\(aq), is returned.
fr: La chaîne de caractères larges a été complètement convertie, y compris le caractère large nul final (ramenant I<*ps> à l'état initial). Dans ce cas, I<*src> devient NULL, et la fonction renvoie le nombre d'octets écrits dans I<dest>, sans compter l'octet nul («\ \e0\ ») final.

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

note: type: Plain text
en: In both of the above cases, if I<ps> is NULL, a static anonymous state known only to the B<wcsnrtombs>()  function is used instead.
fr: Dans tous les cas, si I<ps> est un pointeur NULL, un état anonyme statique, réservé à la fonction B<wcsnrtombs>() est utilisé à sa place.

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

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

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

note: type: TH
en: 2013-11-18
fr: 18 novembre 2013

note: type: Plain text
en: wcspbrk - search a wide-character string for any of a set of wide characters
fr: wcspbrk - Rechercher un ensemble de caractères larges dans une chaîne

note: type: Plain text
en: The B<wcspbrk>()  function is the wide-character equivalent of the B<strpbrk>(3)  function.  It searches for the first occurrence in the wide-character string pointed to by I<wcs> of any of the characters in the wide-character string pointed to by I<accept>.
fr: La fonction B<wcspbrk>() est l'équivalent pour les caractères larges de la fonction B<strpbrk>(3). Elle recherche la première occurrence d'un caractère large se trouvant dans I<accept> au sein de la chaîne I<wcs>.

note: type: Plain text
en: The B<wcspbrk>()  function returns a pointer to the first occurrence in I<wcs> of any of the characters listed in I<accept>.  If I<wcs> contains none of these characters, NULL is returned.
fr: La fonction B<wcspbrk>() renvoie un pointeur sur la première occurrence au sein de I<wcs> d'un caractère large contenu dans I<accept>. Si I<wcs> n'en contient aucun, elle renvoie NULL.

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

note: type: TH
en: 2013-11-19
fr: 19 novembre 2013

note: type: Plain text
en: wcsrchr - search a wide character in a wide-character string
fr: wcsrchr - Rechercher un caractère large dans une chaîne

note: type: Plain text
en: The B<wcsrchr>()  function is the wide-character equivalent of the B<strrchr>(3)  function.  It searches the last occurrence of I<wc> in the wide-character string pointed to by I<wcs>.
fr: La fonction B<wcsrchr>() est l'équivalent pour les caractères larges de la fonction B<strrchr>(3). Elle recherche la dernière occurrence de I<wc> dans la chaîne de caractères larges pointée par I<wcs>.

note: type: Plain text
en: The B<wcsrchr>()  function returns a pointer to the last occurrence of I<wc> in the wide-character string pointed to by I<wcs>, or NULL if I<wc> does not occur in the string.
fr: La fonction B<wcsrchr>() renvoie un pointeur sur la dernière occurrence de I<wc> dans la chaîne de caractères larges I<wcs>, ou NULL si I<wc> ne s'y trouve pas.

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

note: type: Plain text
en: wcsrtombs - convert a wide-character string to a multibyte string
fr: wcsrtombs - Convertir une chaîne de caractères larges en séquence multioctet

note: type: Plain text
en: If I<dest> is not NULL, the B<wcsrtombs>()  function converts the wide-character string I<*src> to a multibyte string starting at I<dest>.  At most I<len> bytes are written to I<dest>.  The shift state I<*ps> is updated.  The conversion is effectively performed by repeatedly calling I<wcrtomb(dest, *src, ps)>, as long as this call succeeds, and then incrementing I<dest> by the number of bytes written and I<*src> by one.  The conversion can stop for three reasons:
fr: Si I<dest> n'est pas un pointeur NULL, la fonction B<wcsrtombs>() convertit les caractères larges depuis la chaîne I<*src> vers la séquence multioctet située en I<dest>. Au plus I<len> octets seront écrits dans I<dest>. L'état de conversion I<*ps> est mis à jour. La conversion est réalisée en invoquant I<wcrtomb(dest,*src,ps)> aussi longtemps que cet appel réussit, en augmentant à chaque fois I<dest> du nombre d'octets écrits, et en incrémentant I<*src>. La conversion peut se terminer pour trois raisons\ :

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

note: type: Plain text
en: 2. The length limit forces a stop.  In this case, I<*src> is left pointing to the next wide character to be converted, and the number of bytes written to I<dest> is returned.
fr: 2. La limite I<len> est atteinte. Dans ce cas I<*src> pointera sur le caractère suivant à convertir, et la fonction renvoie le nombre d'octets écrits dans I<dest>.

note: type: Plain text
en: 3. The wide-character string has been completely converted, including the terminating null wide character (L\(aq\e0\(aq), which has the side effect of bringing back I<*ps> to the initial state.  In this case, I<*src> is set to NULL, and the number of bytes written to I<dest>, excluding the terminating null byte (\(aq\e0\(aq), is returned.
fr: 3. La chaîne de caractères larges a été complètement convertie, y compris le caractère large nul final («\ L\(aq\e0\(aq\ »), ramenant I<*ps> à l'état initial. Dans ce cas, I<*src> devient NULL, et la fonction renvoie le nombre d'octets écrits dans I<dest>, sans compter l'octet nul («\ \(aq\e0\(aq\ ») final.

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

note: type: Plain text
en: In both of the above cases, if I<ps> is NULL, a static anonymous state known only to the B<wcsrtombs>()  function is used instead.
fr: Dans tous les cas, si I<ps> est un pointeur NULL, un état anonyme statique, réservé à la fonction B<mbsnrtowcs>() est utilisé à sa place.

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

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

note: type: TH
en: 2013-11-11
fr: 11 novembre 2013

note: type: Plain text
en: wcsspn - advance in a wide-character string, skipping any of a set of wide characters
fr: wcsspn - Balayer une chaîne de caractères larges en sautant un ensemble de caractères

note: type: Plain text
en: The B<wcsspn>()  function is the wide-character equivalent of the B<strspn>(3)  function.  It determines the length of the longest initial segment of I<wcs> which consists entirely of wide-characters listed in I<accept>.  In other words, it searches for the first occurrence in the wide-character string I<wcs> of a wide-character not contained in the wide-character string I<accept>.
fr: La fonction B<wcsspn>() est l'équivalent pour les caractères larges de la fonction B<strspn>(3). Elle calcule la longueur du plus long segment initial de I<wcs> constitué uniquement de caractères larges contenus dans I<accept>. En d'autres termes, elle recherche la première occurrence d'un caractère large non contenu dans I<accept> au sein de I<wcs>.

note: type: Plain text
en: The B<wcsspn>()  function returns the number of wide characters in the longest initial segment of I<wcs> which consists entirely of wide-characters listed in I<accept>.  In other words, it returns the position of the first occurrence in the wide-character string I<wcs> of a wide-character not contained in the wide-character string I<accept>, or I<wcslen(wcs)> if there is none.
fr: La fonction B<wcsspn>() renvoie le nombre de caractères larges dans le plus long segment initial de I<wcs> constitué uniquement de caractères se trouvant dans I<accept>. Autrement dit, elle renvoie la position du premier caractère large ne se trouvant pas dans I<accept>, ou I<wcslen(wcs)> s'il n'y en a aucun.

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

note: type: TH
en: 2013-11-12
fr: 12 novembre 2013

note: type: Plain text
en: wcsstr - locate a substring in a wide-character string
fr: wcsstr - Rechercher une sous-chaîne dans une chaîne de caractères larges

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

note: type: Plain text
en: The B<wcsstr>()  function is the wide-character equivalent of the B<strstr>(3)  function.  It searches for the first occurrence of the wide-character string I<needle> (without its terminating null wide character (L\(aq\e0\(aq))  as a substring in the wide-character string I<haystack>.
fr: La fonction B<wcsstr>() est l'équivalent pour les caractères larges de la fonction B<strstr>(3). Elle recherche la première occurrence de la sous-chaîne I<aiguille> (sans son caractère large nul (L\(aq\e0\(aq) final) au sein de la chaîne de caractères larges I<meule_de_foin>.

note: type: Plain text
en: The B<wcsstr>()  function returns a pointer to the first occurrence of I<needle> in I<haystack>.  It returns NULL if I<needle> does not occur as a substring in I<haystack>.
fr: La fonction B<wcsstr>() renvoie un pointeur sur la première occurrence d'I<aiguille> dans la chaîne I<meule_de_foin>. Si elle n'en trouve pas, elle renvoie NULL.

note: type: Plain text
en: Note the special case: If I<needle> is the empty wide-character string, the return value is always I<haystack> itself.
fr: Cas particulier\ : si I<aiguille> est une chaîne vide, la valeur renvoyée est I<meule_de_foin> elle-même.

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

note: type: Plain text
en: wcstoimax, wcstoumax - convert wide-character string to integer
fr: wcstoimax, wcstoumax - Convertir une chaîne de caractères larges en entier

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

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

note: type: Plain text
en: wcstok - split wide-character string into tokens
fr: wcstok - Extraire des mots d'une chaîne de caractères larges

note: type: Plain text
en: The B<wcstok>()  function is the wide-character equivalent of the B<strtok>(3)  function, with an added argument to make it multithread-safe.  It can be used to split a wide-character string I<wcs> into tokens, where a token is defined as a substring not containing any wide-characters from I<delim>.
fr: La fonction B<wcstok>() est l'équivalent pour les caractères larges de la fonction B<strtok>(3), avec un argument supplémentaire permettant de l'employer dans un contexte multithread. On peut l'utiliser pour découper la chaîne de caractères larges I<wcs> en éléments syntaxiques (tokens), définis comme des sous-chaînes ne contenant aucun caractère large contenu dans la chaîne I<delim>.

note: type: Plain text
en: The search starts at I<wcs>, if I<wcs> is not NULL, or at I<*ptr>, if I<wcs> is NULL.  First, any delimiter wide-characters are skipped, that is, the pointer is advanced beyond any wide-characters which occur in I<delim>.  If the end of the wide-character string is now reached, B<wcstok>()  returns NULL, to indicate that no tokens were found, and stores an appropriate value in I<*ptr>, so that subsequent calls to B<wcstok>()  will continue to return NULL.  Otherwise, the B<wcstok>()  function recognizes the beginning of a token and returns a pointer to it, but before doing that, it zero-terminates the token by replacing the next wide-character which occurs in I<delim> with a null wide character (L\(aq\e0\(aq), and it updates I<*ptr> so that subsequent calls will continue searching after the end of recognized token.
fr: La recherche démarre en I<wcs> si I<wcs> n'est pas NULL, ou en I<*ptr> si I<wcs> est NULL. D'abord tous les caractères larges délimiteurs sont ignorés, c'est-à-dire que le pointeur est placé au-delà de tous les caractères se trouvant dans I<delim>. Si la fin de la chaîne est atteinte, B<wcstok>() renvoie NULL pour indiquer qu'aucun mot n'a été trouvé, et stocke dans I<*ptr> une valeur qui forcera les éventuels appels suivants de B<wcstok>() à renvoyer NULL. Sinon, la fonction considère avoir atteint le début d'un mot, et renvoie un pointeur dessus après l'avoir fait suivre par un caractère large nul (L\(aq\e0\(aq) (en remplaçant le premier caractère se trouvant dans I<delim>). Elle met à jour le pointeur I<*ptr> pour qu'un nouvel appel de B<wcstok>() continue la recherche à la suite du mot trouvé.

note: type: Plain text
en: The B<wcstok>()  function returns a pointer to the next token, or NULL if no further token was found.
fr: La fonction B<wcstok>() renvoie un pointeur sur le mot suivant, ou NULL si aucun mot n'a été trouvé.

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

note: type: Plain text
en: The original I<wcs> wide-character string is destructively modified during the operation.
fr: La chaîne de caractères larges I<wcs> originale est modifiée de manière destructrice durant l'opération.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: The following code loops over the tokens contained in a wide-character string.
fr: Le code suivant parcourt les mots contenus dans la chaîne de caractères larges.

note: type: Plain text
en: wchar_t *wcs = ...;
    wchar_t *token;
    wchar_t *state;
    for (token = wcstok(wcs, " \et\en", &state);
        token != NULL;
        token = wcstok(NULL, " \et\en", &state)) {
        ...
    }
fr: wchar_t * wcs = ...;
    wchar_t * token;
    wchar_t * etat;
    for (token = wcstok(wcs, " \et\en", &etat);
        token != NULL;
        token = wcstok(NULL, " \et\en", &etat)) {
        ...
    }

note: type: Plain text
en: wcswidth - determine columns needed for a fixed-size wide-character string
fr: wcswidth - Déterminer la place nécessaire pour représenter une chaîne de caractères larges

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

note: type: Plain text
en: The B<wcswidth>()  function returns the number of columns needed to represent the wide-character string pointed to by I<s>, but at most I<n> wide characters.  If a nonprintable wide character occurs among these characters, -1 is returned.
fr: La fonction B<wcswidth>() renvoie le nombre de colonnes nécessaires pour afficher le contenu de la chaîne de caractères larges pointée par I<s>, en se limitant à I<n> caractères larges au maximum. Si un caractère non affichable est rencontré, elle renvoie -1.

note: type: Plain text
en: The B<wcswidth>()  function returns the number of column positions for the wide-character string I<s>, truncated to at most length I<n>.
fr: La fonction B<wcswidth>() renvoie le nombre de colonnes nécessaires pour afficher la chaîne de caractères larges I<s>, tronquée à une longueur maximale valant I<n>.

note: type: Plain text
en: The B<wcswidth>()  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<wcswidth>() 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 la locale pendant son exécution.

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

note: type: Plain text
en: wctob - try to represent a wide character as a single byte
fr: wctob - Essayer de représenter un caractère large sur un seul octet

note: type: Plain text
en: The B<wctob>()  function tests whether the multibyte representation of the wide character I<c>, starting in the initial state, consists of a single byte.  If so, it is returned as an I<unsigned char>.
fr: La fonction B<wctob>() vérifie si la représentation multioctet du caractère I<c>, en partant d'un état de conversion initial, consiste en un unique octet. Si c'est le cas il est renvoyé sous forme d'un I<unsigned char>.

note: type: Plain text
en: Never use this function.  It cannot help you in writing internationalized programs.  Internationalized programs must never distinguish single-byte and multibyte characters.
fr: Ne jamais utiliser cette fonction. Elle ne peut pas servir à internationaliser les programmes. Il ne faut pas chercher à distinguer les caractères multioctets et ceux tenant sur un seul octet.

note: type: Plain text
en: The B<wctob>()  function returns the single-byte representation of I<c>, if it exists, of B<EOF> otherwise.
fr: La fonction B<wctob>() renvoie la représentation sur un seul octet de I<c> si elle existe, ou B<EOF> sinon.

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

note: type: Plain text
en: This function should never be used.  Internationalized programs must never distinguish single-byte and multibyte characters.  Use either B<wctomb>(3)  or the thread-safe B<wcrtomb>(3)  instead.
fr: Cette fonction ne devrait jamais être utilisée. Les programmes internationalisés doivent avoir le même comportement avec des caractères multioctets et des caractères simples sur un seul octet. Utilisez soit B<mbtowc>(3), soit B<mbrtowc>(3) qui est sûre du point de vue des threads, à la place.

note: type: Plain text
en: wcwidth - determine columns needed for a wide character
fr: wcwidth - Connaître le nombre de colonnes nécessaires pour un caractère large

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

note: type: Plain text
en: The B<wcwidth>()  function returns the number of columns needed to represent the wide character I<c>.  If I<c> is a printable wide character, the value is at least 0.  If I<c> is null wide character (L\(aq\e0\(aq), the value is 0.  Otherwise -1 is returned.
fr: La fonction B<wcwidth>() renvoie le nombre de colonnes nécessaires pour représenter le caractère large I<c>. Si I<c> est un caractère large imprimable, la valeur est au moins 0. Si I<c> est un caractère large nul (L\(aq\e0\(aq), la valeur renvoyée est 0. Sinon -1 est renvoyé.

note: type: Plain text
en: The B<wcwidth>()  function returns the number of column positions for I<c>.
fr: La fonction B<wcwidth>() renvoie le nombre de colonnes pour I<c>.

note: type: Plain text
en: The B<wcwidth>()  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<wcwidth>() 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 la locale pendant son exécution.

note: type: Plain text
en: Note that glibc before 2.2.5 used the prototype
fr: Notez que la glibc avant 2.2.5 utilisait le prototype

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

note: type: TH
en: 2013-11-05
fr: 5 novembre 2013

note: type: Plain text
en: wmemchr - search a wide character in a wide-character array
fr: wmemchr - Rechercher un caractère large dans une zone de mémoire

note: type: Plain text
en: The B<wmemchr>()  function is the wide-character equivalent of the B<memchr>(3)  function.  It searches the I<n> wide characters starting at I<s> for the first occurrence of the wide character I<c>.
fr: La fonction B<wmemchr>() est l'équivalent pour les caractères larges de la fonction B<memchr>(3). Elle recherche la première occurrence du caractère large I<c> dans la table de I<n> caractères larges débutant en I<s>.

note: type: Plain text
en: The B<wmemchr>()  function returns a pointer to the first occurrence of I<c> among the I<n> wide characters starting at I<s>, or NULL if I<c> does not occur among these.
fr: La fonction B<wmemchr>() renvoie un pointeur sur la première occurrence de I<c> au sein de la table de I<n> caractères larges commençant en I<s>, ou NULL si I<c> n'y figure pas.

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

note: type: Plain text
en: wmemcmp - compare two arrays of wide-characters
fr: wmemcmp - Comparer deux tables de caractères larges

note: type: Plain text
en: The B<wmemcmp>()  function is the wide-character equivalent of the B<memcmp>(3)  function.  It compares the I<n> wide-characters starting at I<s1> and the I<n> wide-characters starting at I<s2>.
fr: La fonction B<wmemcmp>() est l'équivalent pour les caractères larges de la fonction B<memcmp>(3). Elle compare les I<n> caractères larges commençant en I<s1> aux I<n> commençant en I<s2>.

note: type: Plain text
en: The B<wmemcmp>()  function returns zero if the wide-character arrays of size I<n> at I<s1> and I<s2> are equal.  It returns an integer greater than zero if at the first differing position I<i> (I<i> E<lt> I<n>), the corresponding wide-character I<s1[i]> is greater than I<s2[i]>.  It returns an integer less than zero if at the first differing position I<i> (I<i> E<lt> I<n>), the corresponding wide-character I<s1[i]> is less than I<s2[i]>.
fr: La fonction B<wmemcmp>() renvoie zéro si les tableaux de caractères larges, de taille I<n> situés en I<s1> et I<s2> sont égaux. Elle renvoie un entier positif si à l'emplacement I<i> de la première différence (I<i> E<lt> I<n>), le caractère large I<s1[i]> est supérieur à I<s2[i]>. Elle renvoie un entier négatif si I<s1[i]> est inférieur à I<s2[i]>.

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

note: type: Plain text
en: wmemcpy - copy an array of wide-characters
fr: wmemcpy - Copier un tableau de caractères larges

note: type: Plain text
en: The B<wmemcpy>()  function is the wide-character equivalent of the B<memcpy>(3)  function.  It copies I<n> wide characters from the array starting at I<src> to the array starting at I<dest>.
fr: La fonction B<wmemcpy>() est l'équivalent pour les caractères larges de la fonction B<memcpy>(3). Elle copie I<n> caractères larges depuis le tableau pointé par I<src> vers le tableau pointé par I<dest>.

note: type: Plain text
en: The arrays may not overlap; use B<wmemmove>(3)  to copy between overlapping arrays.
fr: Les tableaux ne doivent pas se chevaucher, sinon utilisez B<wmemmove>(3).

note: type: Plain text
en: B<wmemcpy>()  returns I<dest>.
fr: B<wmemcpy>() renvoie I<dest>.

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

note: type: Plain text
en: wmemmove - copy an array of wide-characters
fr: wmemmove - Copier un tableau de caractères larges

note: type: Plain text
en: The B<wmemmove>()  function is the wide-character equivalent of the B<memmove>(3)  function.  It copies I<n> wide characters from the array starting at I<src> to the array starting at I<dest>.  The arrays may overlap.
fr: La fonction B<wmemmove>() est l'équivalent pour les caractères larges de la fonction B<memmove>(3). Elle copie I<n> caractères larges depuis le tableau pointé par I<src> dans le tableau pointé par I<dest>. Les tableaux peuvent se recouvrir.

note: type: Plain text
en: B<wmemmove>()  returns I<dest>.
fr: B<wmemmove>() renvoie I<dest>.

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

note: type: Plain text
en: wmemset - fill an array of wide-characters with a constant wide character
fr: wmemset - Remplir un tableau de caractères larges avec un caractère large constant

note: type: Plain text
en: The B<wmemset>()  function is the wide-character equivalent of the B<memset>(3)  function.  It fills the array of I<n> wide-characters starting at I<wcs> with I<n> copies of the wide character I<wc>.
fr: La fonction B<wmemset>() est l'équivalent pour les caractères larges de la fonction B<memset>(3). Elle remplit un tableau de I<n> caractères larges commençant à l'adresse I<wcs> avec I<n> copies du caractère large I<wc>.

note: type: Plain text
en: B<wmemset>()  returns I<wcs>.
fr: B<wmemset>() renvoie I<wcs>.

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