perkamon - en to fr translation catalogue (81 entries)

note: type: TH
en: 2019-03-06
fr: 6 mars 2019

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: scanf, fscanf, sscanf, vscanf, vsscanf, vfscanf - input format conversion
fr: scanf, fscanf, sscanf, vscanf, vsscanf, vfscanf - Entrées formatées

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<vscanf>(), B<vsscanf>(), B<vfscanf>():
fr: B<vscanf>(), B<vsscanf>(), B<vfscanf>() :

note: type: Plain text
en: The B<scanf>()  family of functions scans input according to I<format> as described below.  This format may contain I<conversion specifications>; the results from such conversions, if any, are stored in the locations pointed to by the I<pointer> arguments that follow I<format>.  Each I<pointer> argument must be of a type that is appropriate for the value returned by the corresponding conversion specification.
fr: Les fonctions de la famille B<scanf>() analysent leurs entrées conformément au I<format> décrit plus bas. Ce format peut contenir des I<indicateurs de conversion>. Les résultats des conversions, s'il y en a, sont stockés dans des endroits pointés par des arguments I<pointeurs> qui suivent le I<format>. Chaque argument I<pointeur> doit être du type approprié pour la valeur retournée par la spécification de conversion correspondante.

note: type: Plain text
en: If the number of conversion specifications in I<format> exceeds the number of I<pointer> arguments, the results are undefined.  If the number of I<pointer> arguments exceeds the number of conversion specifications, then the excess I<pointer> arguments are evaluated, but are otherwise ignored.
fr: Si le nombre de spécifications de conversion dans I<format> excède le nombre d'arguments I<pointeur>, le résultat est indéterminé. Si le nombre d'arguments I<pointeur> excède le nombre de spécifications de conversion, les arguments I<pointeur> en excès sont évalués mais ignorés.

note: type: Plain text
en: The B<scanf>()  function reads input from the standard input stream I<stdin>, B<fscanf>()  reads input from the stream pointer I<stream>, and B<sscanf>()  reads its input from the character string pointed to by I<str>.
fr: La fonction B<scanf>() lit ses données depuis le flux d'entrée standard I<stdin>, B<fscanf>() lit ses entrées depuis le flux pointé par I<stream>, et B<sscanf>() lit ses entrées dans la chaîne de caractères pointée par I<str>.

note: type: Plain text
en: The B<vfscanf>()  function is analogous to B<vfprintf>(3)  and reads input from the stream pointer I<stream> using a variable argument list of pointers (see B<stdarg>(3).  The B<vscanf>()  function scans a variable argument list from the standard input and the B<vsscanf>()  function scans it from a string; these are analogous to the B<vprintf>(3)  and B<vsprintf>(3)  functions respectively.
fr: La fonction B<vfscanf>() est analogue à B<vfprintf>(3) et lit ses arguments depuis le flux pointé par I<stream> en utilisant une liste variable d'arguments pointeurs, consultez B<stdarg>(3). La fonction B<vscanf>() examine l'entrée standard en utilisant une liste variable d'arguments pointeurs et la fonction B<vsscanf>() examine une chaîne. Elles sont respectivement analogues aux fonctions B<vprintf>(3) et B<vsprintf>(3).

note: type: Plain text
en: The I<format> string consists of a sequence of I<directives> which describe how to process the sequence of input characters.  If processing of a directive fails, no further input is read, and B<scanf>()  returns.  A "failure" can be either of the following: I<input failure>, meaning that input characters were unavailable, or I<matching failure>, meaning that the input was inappropriate (see below).
fr: La chaîne I<format> consiste en une séquence de I<directives> qui décrit comme traiter la séquence des caractères d'entrée. Si le traitement des directives échoue, aucune autre entrée n'est lue et B<scanf>() revient. Un «\ échec\ » peut être soit un I<échec d'entrée> signifiant que les caractères d'entrée ne sont pas disponibles, soit un I<échec de correspondance> signifiant que l'entrée n'est pas appropriée (voir plus loin)

note: type: Plain text
en: A directive is one of the following:
fr: Une directive peut être\ :

note: type: Plain text
en: A sequence of white-space characters (space, tab, newline, etc.; see B<isspace>(3)).  This directive matches any amount of white space, including none, in the input.
fr: Une séquence de caractères blancs (espace, tabulation, nouvelle ligne, etc.\ ; consultez B<isspace>(3)). Cette directive correspond à un nombre quelconque de caractères blancs, y compris aucun, dans l'entrée.

note: type: Plain text
en: An ordinary character (i.e., one other than white space or \(aq%\(aq).  This character must exactly match the next character of input.
fr: Un caractère ordinaire (c'est-à-dire autre qu'un caractère blanc et que le caractère «\ %\ ». Ce caractère doit exactement correspondre au caractère suivant de l'entrée.

note: type: Plain text
en: A conversion specification, which commences with a \(aq%\(aq (percent) character.  A sequence of characters from the input is converted according to this specification, and the result is placed in the corresponding I<pointer> argument.  If the next item of input does not match the conversion specification, the conversion fails\(emthis is a I<matching failure>.
fr: Une spécification de conversion qui débute avec le caractère «\ %\ ». Une séquence de caractères de l'entrée est convertie conformément à la spécification et le résultat est placé dans l'argument I<pointeur> correspondant. Si l'élément suivant de l'entrée ne correspond pas à la spécification de conversion, la conversion échoue \(em c'est un I<échec de correspondance>.

note: type: Plain text
en: Each I<conversion specification> in I<format> begins with either the character \(aq%\(aq or the character sequence "B<%>I<n>B<$>" (see below for the distinction) followed by:
fr: Chaque I<spécification de conversion> dans I<format> commence avec soit le caractère «\ %\ », soit la séquence de caractères «\ B<%>I<n>B<$>\ » (voir plus loin pour la distinction) suivie par\ :

note: type: Plain text
en: An optional \(aq*\(aq assignment-suppression character: B<scanf>()  reads input as directed by the conversion specification, but discards the input.  No corresponding I<pointer> argument is required, and this specification is not included in the count of successful assignments returned by B<scanf>().
fr: Un caractère d'affectation-suppression optionnel «\ *\ »\ : B<scanf>() lit l'entrée comme indiqué par la spécification de conversion mais ne tient pas compte de l'entrée. Aucun argument I<pointeur> n'est nécessaire et cette spécification n'est pas comptabilisée dans le nombre d'affectations réussies renvoyé par B<scanf>().

note: type: Plain text
en: An optional \(aqm\(aq character.  This is used with string conversions (I<%s>, I<%c>, I<%[>), and relieves the caller of the need to allocate a corresponding buffer to hold the input: instead, B<scanf>()  allocates a buffer of sufficient size, and assigns the address of this buffer to the corresponding I<pointer> argument, which should be a pointer to a I<char\ *> variable (this variable does not need to be initialized before the call).  The caller should subsequently B<free>(3)  this buffer when it is no longer required.
fr: Un caractère « m » optionnel. Il est utilisé dans les conversions de chaînes (I<%s>, I<%c>, I<%[>) et soulage l'appelant du besoin d'allouer un tampon correspondant pour conserver l'entrée : à la place, B<scanf>() alloue un tampon de taille suffisante et affecte l'adresse de ce tampon à l'argument I<pointeur> correspondant qui doit être un pointeur vers une variable I<char\ *> (il n'est pas nécessaire que cette variable soit initialisée avant l'appel). L'appelant doit par la suite libérer (B<free>(3)) ce tampon lorsqu'il devient inutile.

note: type: Plain text
en: An optional decimal integer which specifies the I<maximum field width>.  Reading of characters stops either when this maximum is reached or when a nonmatching character is found, whichever happens first.  Most conversions discard initial white space characters (the exceptions are noted below), and these discarded characters don't count toward the maximum field width.  String input conversions store a terminating null byte (\(aq\e0\(aq)  to mark the end of the input; the maximum field width does not include this terminator.
fr: Un entier décimal optionnel qui indique la I<taille maximum du champ>. La lecture des caractères s'arrête soit lorsque ce maximum est atteint, soit lorsque on trouve un caractère qui ne correspond pas, celui qui arrive le premier. La plupart des conversions abandonnent les caractères blancs de tête (les exceptions sont notées plus loin), et ces caractère abandonnés n'entrent pas en compte dans la taille maximale du champ. Les conversions d'entrée de chaînes stocke un octet nul («\ \e0\ ») final pour marquer la fin de l'entrée\ ; la largeur maximale du champ n'inclut pas ce caractère de terminaison.

note: type: Plain text
en: An optional I<type modifier character>.  For example, the B<l> type modifier is used with integer conversions such as B<%d> to specify that the corresponding I<pointer> argument refers to a I<long int> rather than a pointer to an I<int>.
fr: Un I<caractère modificateur de type> optionnel. Par exemple, le modificateur de type B<l> est utilisé avec les conversions d'entrée telles que B<%d> pour spécifier que l'argument I<pointeur> correspondant fait référence à un I<long int> plutôt qu'à un pointeur sur un I<int>.

note: type: Plain text
en: A I<conversion specifier> that specifies the type of input conversion to be performed.
fr: Un I<spécificateur de conversion> qui spécifie le type de conversion d'entrée à effectuer.

note: type: Plain text
en: The conversion specifications in I<format> are of two forms, either beginning with \(aq%\(aq or beginning with "B<%>I<n>B<$>".  The two forms should not be mixed in the same I<format> string, except that a string containing "B<%>I<n>B<$>" specifications can include B<%%> and B<%*>.  If I<format> contains \(aq%\(aq specifications, then these correspond in order with successive I<pointer> arguments.  In the "B<%>I<n>B<$>" form (which is specified in POSIX.1-2001, but not C99), I<n> is a decimal integer that specifies that the converted input should be placed in the location referred to by the I<n>-th I<pointer> argument following I<format>.
fr: Les spécifications de conversion dans I<format> sont de deux formes\ : soit elles commencent par «\ %\ », soit elles commencent par «\ B<%>I<n>B<$>\ ». Les deux formes ne doivent pas être mélangées dans la même chaîne I<format>, excepté qu'une chaîne contenant les spécifications «\ B<%>I<n>B<$>\ » peut inclure B<%%> et B<%*>. Si I<format> contient des spécifications «\ %\ », celles-ci correspondent, dans l'ordre, aux arguments I<pointeur> successifs. Dans la forme «\ B<%>I<n>B<$>\ » (qui est spécifiée par POSIX.1-2001 mais pas par C99), I<n> est un entier décimal qui spécifie que l'entrée convertie devrait être placée à l'endroit référencé par le I<n>-ième argument I<pointeur> suivant I<format>.

note: type: Plain text
en: The following I<type modifier characters> can appear in a conversion specification:
fr: Les I<caractères modificateurs de type> suivant peuvent se apparaître dans une spécification de conversion\ :

note: type: Plain text
en: Indicates that the conversion will be one of B<d>, B<i>, B<o>, B<u>, B<x>, B<X>, or B<n> and the next pointer is a pointer to a I<short int> or I<unsigned short int> (rather than I<int>).
fr: Indique que la conversion sera de type B<d>, B<i>, B<o>, B<u>, B<x>, B<X> ou B<n> et que le pointeur suivant est un pointeur sur un I<short int> ou un I<unsigned short int> (plutôt que sur un I<int>).

note: type: Plain text
en: As for B<h>, but the next pointer is a pointer to a I<signed char> or I<unsigned char>.
fr: Comme pour B<h>, sauf que le pointeur suivant est un pointeur sur un I<signed char> ou un I<unsigned char>.

note: type: Plain text
en: As for B<h>, but the next pointer is a pointer to an I<intmax_t> or a I<uintmax_t>.  This modifier was introduced in C99.
fr: Comme pour B<h>, sauf que le pointeur suivant est un pointeur sur un I<intmax_t> ou un I<uintmax_t>. Ce modificateur a été introduit dans C99.

note: This use of l was introduced in Amendment 1 to ISO C90. type: Plain text
en: Indicates either that the conversion will be one of B<d>, B<i>, B<o>, B<u>, B<x>, B<X>, or B<n> and the next pointer is a pointer to a I<long int> or I<unsigned long int> (rather than I<int>), or that the conversion will be one of B<e>, B<f>, or B<g> and the next pointer is a pointer to I<double> (rather than I<float>).  Specifying two B<l> characters is equivalent to B<L>.  If used with B<%c> or B<%s>, the corresponding parameter is considered as a pointer to a wide character or wide-character string respectively.
fr: Indique que la conversion sera de type B<d>, B<i>, B<o>, B<u>, B<x>, B<X> ou B<n> et que le pointeur suivant est un pointeur sur un I<long int> ou un I<unsigned long int> (plutôt que sur un I<int>), ou que la conversion sera de type B<e>, B<f> ou B<g> et que le pointeur suivant est un pointeur sur un I<double> (plutôt que sur un I<float>). Indiquer deux caractères B<l> successifs est équivalent à indiquer B<L>. Si c'est utilisé avec B<%c> ou B<%s>, le paramètre correspondant est considéré, respectivement, comme un pointeur vers un caractère large ou une chaîne de caractères larges.

note: MTK, Jul 05: The following is no longer true for modern ANSI C (i.e., C99): (Note that long long is not an ANSI C type. Any program using this will not be portable to all architectures). type: Plain text
en: Indicates that the conversion will be either B<e>, B<f>, or B<g> and the next pointer is a pointer to I<long double> or the conversion will be B<d>, B<i>, B<o>, B<u>, or B<x> and the next pointer is a pointer to I<long long>.
fr: Indique que la conversion sera de type B<e>, B<f> ou B<g> et que le pointeur suivant est un pointeur sur un I<long double> ou que la conversion sera de type B<d>, B<i>, B<o>, B<u>, ou B<x> et que le pointeur suivant est un pointeur sur un I<long long>.

note: type: Plain text
en: equivalent to B<L>.  This specifier does not exist in ANSI C.
fr: est équivalent à B<L>. Ce spécificateur n'existe pas en C ANSI.

note: type: Plain text
en: As for B<h>, but the next pointer is a pointer to a I<ptrdiff_t>.  This modifier was introduced in C99.
fr: Comme pour B<h>, mais le pointeur suivant est un pointeur vers un I<ptrdiff_t>. Ce modificateur a été introduit dans C99.

note: type: Plain text
en: As for B<h>, but the next pointer is a pointer to a I<size_t>.  This modifier was introduced in C99.
fr: Comme pour B<h>, mais le pointeur suivant est un pointeur vers un I<size_t>. Ce modificateur a été introduit dans C99.

note: type: Plain text
en: The following I<conversion specifiers> are available:
fr: Les I<spécificateurs de conversion> suivant sont disponibles\ :

note: type: Plain text
en: Matches a literal \(aq%\(aq.  That is, B<%\&%> in the format string matches a single input \(aq%\(aq character.  No conversion is done (but initial white space characters are discarded), and assignment does not occur.
fr: Correspond à un caractère «\ %\ ». Ceci signifie qu'un spécificateur B<%\&%> dans la chaîne de format correspond à un seul caractère «\ %\ » dans la chaîne d'entrée. Aucune conversion (mais les caractères blancs de début sont ignorés), et aucune assignation n'a lieu.

note: type: Plain text
en: Matches an optionally signed decimal integer; the next pointer must be a pointer to I<int>.
fr: Correspond à un entier décimal éventuellement signé, le pointeur correspondant doit être un pointeur vers un I<int>.

note: type: Plain text
en: Equivalent to I<ld>; this exists only for backward compatibility.  (Note: thus only in libc4.  In libc5 and glibc the B<%D> is silently ignored, causing old programs to fail mysteriously.)
fr: Équivalent à I<ld>, utilisé uniquement pour compatibilité avec des versions précédentes (et seulement dans libc4. Dans libc5 et glibc, le B<%D> est ignoré silencieusement, ce qui conduit d'anciens programmes à échouer mystérieusement).

note: type: Plain text
en: Matches an optionally signed integer; the next pointer must be a pointer to I<int>.  The integer is read in base 16 if it begins with I<0x> or I<0X>, in base 8 if it begins with I<0>, and in base 10 otherwise.  Only characters that correspond to the base are used.
fr: Correspond à un entier éventuellement signé. Le pointeur suivant doit être du type I<int>. L'entier est en base 16 (hexadécimal) s'il commence par I<0x> ou I<0X>, en base 8 (octal) s'il commence par un I<0>, et en base 10 sinon. Seuls les caractères correspondants à la base concernée sont utilisés.

note: type: Plain text
en: Matches an unsigned octal integer; the next pointer must be a pointer to I<unsigned int>.
fr: Correspond à un entier octal non signé. Le pointeur correspondant doit être un pointeur vers un I<unsigned int>.

note: type: Plain text
en: Matches an unsigned decimal integer; the next pointer must be a pointer to I<unsigned int>.
fr: Correspond à un entier décimal non signé. Le pointeur suivant doit être un pointeur vers un I<unsigned int>.

note: type: Plain text
en: Matches an unsigned hexadecimal integer; the next pointer must be a pointer to I<unsigned int>.
fr: Correspond à un entier hexadécimal non signé. Le pointeur suivant doit être un pointeur vers un I<unsigned int>.

note: type: Plain text
en: Equivalent to B<x>.
fr: Équivalent à B<x>

note: type: Plain text
en: Matches an optionally signed floating-point number; the next pointer must be a pointer to I<float>.
fr: Correspond à un nombre réel éventuellement signé. Le pointeur correspondant doit être un pointeur vers un I<float>.

note: type: Plain text
en: Equivalent to B<f>.
fr: Équivalent à B<f>.

note: type: Plain text
en: (C99) Equivalent to B<f>.
fr: (C99) Équivalent à B<f>.

note: type: Plain text
en: Matches a sequence of characters whose length is specified by the I<maximum field width> (default 1); the next pointer must be a pointer to I<char>, and there must be enough room for all the characters (no terminating null byte is added).  The usual skip of leading white space is suppressed.  To skip white space first, use an explicit space in the format.
fr: Correspond à une séquence de caractères dont la longueur est spécifiée par la I<largeur maximum de champ> (par défaut 1). Le pointeur suivant doit être un pointeur vers un I<char>, et il doit y avoir suffisamment de place dans la chaîne pour tous les caractères. Aucun octet nul final n'est ajouté. Les caractères blancs de début ne sont pas supprimés. Si on veut les éliminer, il faut utiliser une espace dans le format.

note: type: Plain text
en: Matches a nonempty sequence of characters from the specified set of accepted characters; the next pointer must be a pointer to I<char>, and there must be enough room for all the characters in the string, plus a terminating null byte.  The usual skip of leading white space is suppressed.  The string is to be made up of characters in (or not in) a particular set; the set is defined by the characters between the open bracket B<[> character and a close bracket B<]> character.  The set I<excludes> those characters if the first character after the open bracket is a circumflex (B<^>).  To include a close bracket in the set, make it the first character after the open bracket or the circumflex; any other position will end the set.  The hyphen character B<-> is also special; when placed between two other characters, it adds all intervening characters to the set.  To include a hyphen, make it the last character before the final close bracket.  For instance, B<[^]0-9-]> means the set "everything except close bracket, zero through nine, and hyphen".  The string ends with the appearance of a character not in the (or, with a circumflex, in) set or when the field width runs out.
fr: Correspond à une séquence non vide de caractères appartenant à un ensemble donné. Le pointeur correspondant doit être un pointeur vers un I<char> et il doit y avoir suffisamment de place dans le tableau de caractères pour accueillir la chaîne ainsi qu'un octet nul final. Les caractères blancs du début ne sont pas supprimés. La chaîne est constituées de caractères inclus ou exclus d'un ensemble donné. L'ensemble est composé des caractères compris entre les deux crochets B<[> et B<]>. L'ensemble I<exclut> ces caractères si le premier après le crochet ouvrant est un accent circonflexe (B<^>). Pour inclure un crochet fermant dans l'ensemble, il suffit de le placer en première position après le crochet ouvrant, ou l'accent circonflexe\ ; à tout autre emplacement il servira à terminer l'ensemble. Le caractère tiret B<-> a également une signification particulière. Quand il est placé entre deux autres caractères, il ajoute à l'ensemble les caractères intermédiaires. Pour inclure un tiret dans l'ensemble, il faut le placer en dernière position avant le crochet fermant. Par exemple, B<[^]0-9-]> correspond à l'ensemble «\ Tout sauf le crochet fermant, les chiffres de 0 à 9, et le tiret\ ». La chaîne se termine dès l'occurrence d'un caractère exclu (ou inclus s'il y à un accent circonflexe ) de l'ensemble, ou dès qu'on atteint la longueur maximale du champ.

note: type: Plain text
en: Matches a pointer value (as printed by B<%p> in B<printf>(3); the next pointer must be a pointer to a pointer to I<void>.
fr: Correspond à une valeur de pointeur (comme affichée par B<%p> dans B<printf>(3). Le pointeur suivant doit être un pointeur sur un pointeur sur I<void>.

note: type: SH
en: RETURN VALUE
fr: VALEUR DE RETOUR

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: The file descriptor underlying I<stream> is marked nonblocking, and the read operation would block.
fr: Le descripteur de fichier I<stream> sous-jacent est non bloquant et l'opération de lecture bloquerait.

note: type: Plain text
en: The file descriptor underlying I<stream> is invalid, or not open for reading.
fr: Le descripteur de fichier I<stream> sous-jacent n'est pas valide ou bien n'est pas ouvert en lecture.

note: type: Plain text
en: Input byte sequence does not form a valid character.
fr: La séquence d'octet en entrée ne constitue pas un caractère valable.

note: type: Plain text
en: The read operation was interrupted by a signal; see B<signal>(7).
fr: La lecture a été interrompue par un signal ; consultez B<signal>(7).

note: type: Plain text
en: Not enough arguments; or I<format> is NULL.
fr: Pas suffisamment de paramètres ; ou bien I<format> est NULL.

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

note: type: Plain text
en: The result of an integer conversion would exceed the size that can be stored in the corresponding integer type.
fr: Le résultat de la conversion entière est plus grand que la taille pouvant être stockée dans le type entier correspondant.

note: type: SH
en: ATTRIBUTES
fr: ATTRIBUTS

note: type: tbl table
en: Value
fr: Valeur

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

note: type: Plain text
en: The functions B<fscanf>(), B<scanf>(), and B<sscanf>()  conform to C89 and C99 and POSIX.1-2001.  These standards do not specify the B<ERANGE> error.
fr: Les fonctions B<fscanf>(), B<scanf>(), et B<sscanf>() sont conformes à C89, C99 et POSIX.1-2001. Ces normes ne spécifient pas l'erreur B<ERANGE>.

note: type: Plain text
en: The B<q> specifier is the 4.4BSD notation for I<long long>, while B<ll> or the usage of B<L> in integer conversions is the GNU notation.
fr: Le spécificateur B<q> est une notation BSD\ 4.4 pour I<long long>, alors que B<ll> ou l'utilisation de B<L> dans les conversions entières sont des notations GNU.

note: type: Plain text
en: The Linux version of these functions is based on the I<GNU> I<libio> library.  Take a look at the I<info> documentation of I<GNU> I<libc (glibc-1.08)> for a more concise description.
fr: Les versions Linux de ces fonctions sont basées sur la bibliothèque I<libio GNU>. Jetez un œil sur la documentation I<info> de la I<libc GNU (glibc-1.08)> pour une description complète.

note: type: SS
en: The 'a' assignment-allocation modifier
fr: Le modificateur d'affectation-allocation « a »

note: type: Plain text
en: Originally, the GNU C library supported dynamic allocation for string inputs (as a nonstandard extension) via the B<a> character.  (This feature is present at least as far back as glibc 2.0.)  Thus, one could write the following to have B<scanf>()  allocate a buffer for an input string, with a pointer to that buffer being returned in I<*buf>:
fr: Initialement, la bibliothèque C de GNU prenait en charge l'allocation dynamique des chaînes de caractères en entrée (comme une extension non standard) au moyen du caractère B<a> (cette fonctionnalité remonte au moins à la version 2.0 de glibc). Ainsi, il était possible, grâce au code suivant, de faire que B<scanf>() alloue un tampon pour une chaîne en entrée, et renvoie un pointeur vers ce tampon dans I<*buf>:

note: type: Plain text
en: The use of the letter B<a> for this purpose was problematic, since B<a> is also specified by the ISO C standard as a synonym for B<f> (floating-point input).  POSIX.1-2008 instead specifies the B<m> modifier for assignment allocation (as documented in DESCRIPTION, above).
fr: L'utilisation de la lettre B<a> dans ce but posait problème étant donné que B<a> est également synonyme de B<f> dans le standard ISO C (entrée de nombre à virgule flottante). POSIX.1-2008 spécifie en revanche que le modificateur B<m> doit être utilisée pour l'affectation allocation (comme indiqué dans la DESCRIPTION plus haut).

note: type: Plain text
en: Note that the B<a> modifier is not available if the program is compiled with I<gcc -std=c99> or I<gcc -D_ISOC99_SOURCE> (unless B<_GNU_SOURCE> is also specified), in which case the B<a> is interpreted as a specifier for floating-point numbers (see above).
fr: Notez que le modificateur B<a> n'est pas disponible si le programme a été compilé avec I<gcc -std=c99> ou I<gcc -D_ISOC99_SOURCE> (à moins que B<_GNU_SOURCE> n'ait également été indiqué), auquel cas B<a> est interprété comme un spécificateur de nombres en virgule flottante (voir plus haut).

note: type: Plain text
en: Support for the B<m> modifier was added to glibc starting with version 2.7, and new programs should use that modifier instead of B<a>.
fr: Le modificateur B<m> est pris en charge depuis la version 2.7 de glibc et les nouveaux programmes doivent utiliser ce modificateur plutôt que B<a>.

note: type: Plain text
en: As well as being standardized by POSIX, the B<m> modifier has the following further advantages over the use of B<a:>
fr: En plus d'être un standard de POSIX, le modificateur B<m> présente les avantages suivants par rapport au modificateur B<a:>

note: type: Plain text
en: It may also be applied to B<%c> conversion specifiers (e.g., B<%3mc>).
fr: Il peut être appliqué aux spécificateurs de conversion B<%c> (par exemple B<%3mc>).

note: type: Plain text
en: It avoids ambiguity with respect to the B<%a> floating-point conversion specifier (and is unaffected by I<gcc -std=c99> etc.).
fr: Il lève toute ambiguité avec le spécificateur de conversion en virgule flottante B<%a> (et n'est pas affecté par I<gcc -std=c99> etc.).

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: All functions are fully C89 conformant, but provide the additional specifiers B<q> and B<a> as well as an additional behavior of the B<L> and B<l> specifiers.  The latter may be considered to be a bug, as it changes the behavior of specifiers defined in C89.
fr: Toutes ces fonctions sont totalement conformes à C89, mais lui ajoutent les spécificateurs B<q> et B<a> ainsi que des comportements supplémentaires des spécificateurs B<L> et B<l>. Ce derniers doivent être considérés comme des bogues, car ils modifient le comportement de spécificateurs définis dans C89.

note: type: Plain text
en: Some combinations of the type modifiers and conversion specifiers defined by ANSI C do not make sense (e.g., B<%Ld>).  While they may have a well-defined behavior on Linux, this need not to be so on other architectures.  Therefore it usually is better to use modifiers that are not defined by ANSI C at all, that is, use B<q> instead of B<L> in combination with B<d>, B<i>, B<o>, B<u>, B<x>, and B<X> conversions or B<ll>.
fr: Certaines combinaisons de modificateurs de type et de spécificateurs de conversion définis par le C ANSI n'ont pas de sens (par exemple B<%Ld>). Bien qu'elles aient un comportement bien défini sous Linux, ce n'est peut être pas le cas sur d'autres architectures. Il vaut donc mieux n'utiliser que des modificateurs définis en C ANSI, c'est-à-dire, utilisez B<q> à la place de B<L> avec les conversions B<d>, B<i>, B<o>, B<u>, B<x> et B<X> ou B<ll>.

note: type: Plain text
en: The usage of B<q> is not the same as on 4.4BSD, as it may be used in float conversions equivalently to B<L>.
fr: L'utilisation B<q> n'est pas la même sous BSD\ 4.4, car il peut être utilisé avec des conversions de réels de manière équivalente à B<L>. [NDT] La conversion B<%s> devrait toujours être accompagnée d'une longueur maximale de chaîne de caractères. En effet, il existe un risque de débordement de tampon, qui peut conduire à un trou de sécurité important dans un programme setuid ou setgid.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: To use the dynamic allocation conversion specifier, specify B<m> as a length modifier (thus B<%ms> or B<%m[>I<range>B<]>).  The caller must B<free>(3)  the returned string, as in the following example:
fr: Pour utiliser l'indicateur de conversion d'allocation dynamique, indiquez B<m> comme modificateur de longueur (par conséquent B<%ms> ou B<%m[>I<range>B<]>). L'appelant doit libérer (B<free>(3)) l'espace occupé par la chaîne renvoyée, comme dans l'exemple suivant :

note: type: Plain text
en: errno = 0;
    n = scanf("%m[a-z]", &p);
    if (n == 1) {
        printf("read: %s\en", p);
        free(p);
    } else if (errno != 0) {
        perror("scanf");
    } else {
        fprintf(stderr, "No matching characters\en");
    }
fr: errno = 0;
    n = scanf("%m[a-z]", &p);
    if (n == 1) {
        printf("read: %s\en", p);
        free(p);
    } else if (errno != 0) {
        perror("scanf");
    } else {
        fprintf(stderr, "Pas de caractères correspondants\en");
    }

note: type: Plain text
en: As shown in the above example, it is necessary to call B<free>(3)  only if the B<scanf>()  call successfully read a string.
fr: Comme montré dans cet exemple, il n'est nécessaire d'appeler B<free>(3) que si l'appel à B<scanf>() a réussi à lire une chaîne.

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

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

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

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