From df31c933a60ac274e5d17affc894c771d782ef47 Mon Sep 17 00:00:00 2001 From: Sylvestre Ledru Date: Tue, 17 Jun 2025 23:04:09 +0200 Subject: [PATCH] l10n: port printf for translation + add french --- src/uu/printf/locales/en-US.ftl | 5 + src/uu/printf/locales/fr-FR.ftl | 255 ++++++++++++++++++++++++++++++++ src/uu/printf/src/printf.rs | 17 ++- 3 files changed, 272 insertions(+), 5 deletions(-) create mode 100644 src/uu/printf/locales/fr-FR.ftl diff --git a/src/uu/printf/locales/en-US.ftl b/src/uu/printf/locales/en-US.ftl index 6f58a0775..430fd71fa 100644 --- a/src/uu/printf/locales/en-US.ftl +++ b/src/uu/printf/locales/en-US.ftl @@ -247,3 +247,8 @@ printf-after-help = basic anonymous string templating: of the next character will be interpreted as an 8-bit unsigned integer. If there are additional bytes, they will throw an error (unless the environment variable POSIXLY_CORRECT is set) + +printf-error-missing-operand = missing operand +printf-warning-ignoring-excess-arguments = ignoring excess arguments, starting with '{ $arg }' +printf-help-version = Print version information +printf-help-help = Print help information diff --git a/src/uu/printf/locales/fr-FR.ftl b/src/uu/printf/locales/fr-FR.ftl new file mode 100644 index 000000000..9594c7027 --- /dev/null +++ b/src/uu/printf/locales/fr-FR.ftl @@ -0,0 +1,255 @@ +printf-about = Afficher la sortie basée sur la chaîne de format et les arguments suivants. +printf-usage = printf FORMAT [ARGUMENT]... + printf OPTION +printf-after-help = templating de chaîne anonyme de base : + + affiche la chaîne de format au moins une fois, se répétant tant qu'il reste des arguments + la sortie affiche les littéraux échappés dans la chaîne de format comme des littéraux de caractères + la sortie remplace les champs anonymes par le prochain argument inutilisé, formaté selon le champ. + + Affiche le , en remplaçant les séquences de caractères échappés par des littéraux de caractères + et les séquences de champs de substitution par les arguments passés + + littéralement, à l'exception de ce qui suit + séquences de caractères échappés, et les séquences de substitution décrites plus loin. + + ### SÉQUENCES D'ÉCHAPPEMENT + + Les séquences d'échappement suivantes, organisées ici par ordre alphabétique, + afficheront le littéral de caractère correspondant : + + - \" guillemet double + + - \\ barre oblique inverse + + - \\a alerte (BEL) + + - \\b retour arrière + + - \\c Fin d'entrée + + - \\e échappement + + - \\f saut de page + + - \\n nouvelle ligne + + - \\r retour chariot + + - \\t tabulation horizontale + + - \\v tabulation verticale + + - \\NNN octet avec valeur exprimée en valeur octale NNN (1 à 3 chiffres) + les valeurs supérieures à 256 seront traitées + + - \\xHH octet avec valeur exprimée en valeur hexadécimale NN (1 à 2 chiffres) + + - \\uHHHH caractère Unicode (IEC 10646) avec valeur exprimée en valeur hexadécimale HHHH (4 chiffres) + + - \\uHHHH caractère Unicode avec valeur exprimée en valeur hexadécimale HHHH (8 chiffres) + + - %% un seul % + + ### SUBSTITUTIONS + + #### RÉFÉRENCE RAPIDE DES SUBSTITUTIONS + + Champs + + - %s: chaîne + - %b: chaîne analysée pour les littéraux, le deuxième paramètre est la longueur max + + - %c: caractère, pas de deuxième paramètre + + - %i ou %d: entier 64 bits + - %u: entier non signé 64 bits + - %x ou %X: entier non signé 64 bits en hexadécimal + - %o: entier non signé 64 bits en octal + le deuxième paramètre est la largeur min, entier + la sortie en dessous de cette largeur est remplie avec des zéros en tête + + - %q: ARGUMENT est affiché dans un format qui peut être réutilisé comme entrée shell, en échappant les + caractères non imprimables avec la syntaxe POSIX $'' proposée. + + - %f ou %F: valeur en virgule flottante décimale + - %e ou %E: valeur en virgule flottante en notation scientifique + - %g ou %G: plus courte des valeurs en virgule flottante décimale ou SciNote interprétées spécialement. + le deuxième paramètre est + -max places après la virgule pour la sortie en virgule flottante + -max nombre de chiffres significatifs pour la sortie en notation scientifique + + paramétrage des champs + + exemples : + + printf '%4.3i' 7 + + Il a un premier paramètre de 4 et un deuxième paramètre de 3 et donnera ' 007' + + printf '%.1s' abcde + + Il n'a pas de premier paramètre et un deuxième paramètre de 1 et donnera 'a' + + printf '%4c' q + + Il a un premier paramètre de 4 et pas de deuxième paramètre et donnera ' q' + + Le premier paramètre d'un champ est la largeur minimale pour remplir la sortie + si la sortie est inférieure à cette valeur absolue de cette largeur, + elle sera remplie avec des espaces en tête, ou, si l'argument est négatif, + avec des espaces en queue. la valeur par défaut est zéro. + + Le deuxième paramètre d'un champ est particulier au type de champ de sortie. + les valeurs par défaut peuvent être trouvées dans l'aide de substitution complète ci-dessous + + préfixes spéciaux pour les arguments numériques + + - 0: (ex. 010) interpréter l'argument comme octal (champs de sortie entiers uniquement) + - 0x: (ex. 0xABC) interpréter l'argument comme hexadécimal (champs de sortie numériques uniquement) + - \': (ex. \'a) interpréter l'argument comme une constante de caractère + + #### COMMENT UTILISER LES SUBSTITUTIONS + + Les substitutions sont utilisées pour passer des argument(s) supplémentaire(s) dans la chaîne FORMAT, pour être formatés d'une + manière particulière. Par ex. + + printf 'la lettre %X vient avant la lettre %X' 10 11 + + affichera + + la lettre A vient avant la lettre B + + parce que le champ de substitution %X signifie + 'prendre un argument entier et l'écrire comme un nombre hexadécimal' + + Passer plus d'arguments qu'il n'y en a dans la chaîne de format fera que la chaîne de format sera + répétée pour les substitutions restantes + + printf 'il fait %i F à %s \n' 22 Portland 25 Boston 27 New York + + affichera + + il fait 22 F à Portland + il fait 25 F à Boston + il fait 27 F à Boston + + Si une chaîne de format est affichée mais qu'il reste moins d'arguments + qu'il n'y a de champs de substitution, les champs de substitution sans + argument auront par défaut des chaînes vides, ou pour les champs numériques + la valeur 0 + + #### SUBSTITUTIONS DISPONIBLES + + Ce programme, comme GNU coreutils printf, + interprète un sous-ensemble modifié de la spécification printf C POSIX, + une référence rapide aux substitutions est ci-dessous. + + #### SUBSTITUTIONS DE CHAÎNES + + Tous les champs de chaîne ont un paramètre 'largeur max' + %.3s signifie 'afficher pas plus de trois caractères de l'entrée originale' + + - %s: chaîne + + - %b: chaîne échappée - la chaîne sera vérifiée pour tout littéral échappé de + la liste de littéraux échappés ci-dessus, et les traduire en caractères littéraux. + ex. \\n sera transformé en caractère de nouvelle ligne. + Une règle spéciale sur le mode %b est que les littéraux octaux sont interprétés différemment + Dans les arguments passés par %b, les littéraux interprétés en octal doivent être sous la forme \\0NNN + au lieu de \\NNN. (Bien que, pour des raisons d'héritage, les littéraux octaux sous la forme \\NNN seront + toujours interprétés et ne lanceront pas d'avertissement, vous aurez des problèmes si vous utilisez cela pour un + littéral dont le code commence par zéro, car il sera vu comme étant sous forme \\0NNN.) + + - %q: chaîne échappée - la chaîne dans un format qui peut être réutilisé comme entrée par la plupart des shells. + Les caractères non imprimables sont échappés avec la syntaxe POSIX proposée '$''', + et les méta-caractères shell sont cités de manière appropriée. + C'est un format équivalent à la sortie ls --quoting=shell-escape. + + #### SUBSTITUTIONS DE CARACTÈRES + + Le champ caractère n'a pas de paramètre secondaire. + + - %c: un seul caractère + + #### SUBSTITUTIONS D'ENTIERS + + Tous les champs entiers ont un paramètre 'remplir avec zéro' + %.4i signifie un entier qui s'il fait moins de 4 chiffres de longueur, + est rempli avec des zéros en tête jusqu'à ce qu'il fasse 4 chiffres de longueur. + + - %d ou %i: entier 64 bits + + - %u: entier non signé 64 bits + + - %x ou %X: entier non signé 64 bits affiché en hexadécimal (base 16) + %X au lieu de %x signifie utiliser des lettres majuscules pour 'a' à 'f' + + - %o: entier non signé 64 bits affiché en octal (base 8) + + #### SUBSTITUTIONS EN VIRGULE FLOTTANTE + + Tous les champs en virgule flottante ont un paramètre 'max places décimales / max chiffres significatifs' + %.10f signifie une virgule flottante décimale avec 7 places décimales après 0 + %.10e signifie un nombre en notation scientifique avec 10 chiffres significatifs + %.10g signifie le même comportement pour décimal et Sci. Note, respectivement, et fournit la plus courte + de chaque sortie. + + Comme avec GNU coreutils, la valeur après la virgule de ces sorties est analysée comme un + double d'abord avant d'être rendue en texte. Pour les deux implémentations, n'attendez pas de précision significative + au-delà de la 18ème place décimale. Lors de l'utilisation d'un nombre de places décimales qui est 18 ou + plus élevé, vous pouvez vous attendre à une variation de sortie entre GNU coreutils printf et ce printf à la + 18ème place décimale de +/- 1 + + - %f: valeur en virgule flottante présentée en décimal, tronquée et affichée à 6 places décimales par + défaut. Il n'y a pas de parité de comportement post-double avec Coreutils printf, les valeurs ne sont pas + estimées ou ajustées au-delà des valeurs d'entrée. + + - %e ou %E: valeur en virgule flottante présentée en notation scientifique + 7 chiffres significatifs par défaut + %E signifie utiliser E majuscule pour la mantisse. + + - %g ou %G: valeur en virgule flottante présentée dans la plus courte des notations décimale et scientifique + se comporte différemment de %f et %E, veuillez voir la spécification posix printf pour tous les détails, + quelques exemples de comportement différent : + Sci Note a 6 chiffres significatifs par défaut + Les zéros de fin sont supprimés + Au lieu d'être tronqué, le chiffre après le dernier est arrondi + + Comme d'autres comportements dans cet utilitaire, les choix de conception du comportement en virgule flottante + dans cet utilitaire sont sélectionnés pour reproduire exactement + le comportement de printf de GNU coreutils du point de vue des entrées et sorties. + + ### UTILISATION DES PARAMÈTRES + + La plupart des champs de substitution peuvent être paramétrés en utilisant jusqu'à 2 nombres qui peuvent + être passés au champ, entre le signe % et la lettre du champ. + + Le 1er paramètre indique toujours la largeur minimale de sortie, il est utile pour créer + une sortie en colonnes. Toute sortie qui serait inférieure à cette largeur minimale est remplie avec + des espaces en tête + Le 2ème paramètre est précédé d'un point. + Vous n'êtes pas obligé d'utiliser des paramètres + + ### FORMES SPÉCIALES D'ENTRÉE + + Pour l'entrée numérique, les formes d'entrée supplémentaires suivantes sont acceptées en plus du décimal : + + Octal (uniquement avec entier) : si l'argument commence par un 0, les caractères suivants + seront interprétés comme octal (base 8) pour les champs entiers + + Hexadécimal : si l'argument commence par 0x, les caractères suivants seront interprétés + seront interprétés comme hexadécimal (base 16) pour tous les champs numériques + pour les champs flottants, l'entrée hexadécimale résulte en une limite de précision + (dans la conversion de l'entrée après la virgule) de 10^-15 + + Constante de caractère : si l'argument commence par un caractère guillemet simple, le premier octet + du caractère suivant sera interprété comme un entier non signé 8 bits. S'il y a + des octets supplémentaires, ils lanceront une erreur (sauf si la variable d'environnement POSIXLY_CORRECT + est définie) + +# Messages d'erreur +printf-error-missing-operand = opérande manquant +printf-warning-ignoring-excess-arguments = arguments excédentaires ignorés, en commençant par '{ $arg }' +printf-help-version = Afficher les informations de version +printf-help-help = Afficher cette aide diff --git a/src/uu/printf/src/printf.rs b/src/uu/printf/src/printf.rs index a28fc6aae..654162381 100644 --- a/src/uu/printf/src/printf.rs +++ b/src/uu/printf/src/printf.rs @@ -3,11 +3,12 @@ // For the full copyright and license information, please view the LICENSE // file that was distributed with this source code. use clap::{Arg, ArgAction, Command}; +use std::collections::HashMap; use std::io::stdout; use std::ops::ControlFlow; use uucore::error::{UResult, UUsageError}; use uucore::format::{FormatArgument, FormatArguments, FormatItem, parse_spec_and_escape}; -use uucore::locale::get_message; +use uucore::locale::{get_message, get_message_with_args}; use uucore::{format_usage, os_str_as_bytes, show_warning}; const VERSION: &str = "version"; @@ -23,7 +24,7 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> { let format = matches .get_one::(options::FORMAT) - .ok_or_else(|| UUsageError::new(1, "missing operand"))?; + .ok_or_else(|| UUsageError::new(1, get_message("printf-error-missing-operand")))?; let format = os_str_as_bytes(format)?; let values: Vec<_> = match matches.get_many::(options::ARGUMENT) { @@ -57,7 +58,13 @@ pub fn uumain(args: impl uucore::Args) -> UResult<()> { let Some(FormatArgument::Unparsed(arg_str)) = args.peek_arg() else { unreachable!("All args are transformed to Unparsed") }; - show_warning!("ignoring excess arguments, starting with '{arg_str}'"); + show_warning!( + "{}", + get_message_with_args( + "printf-warning-ignoring-excess-arguments", + HashMap::from([("arg".to_string(), arg_str.to_string())]) + ) + ); } return Ok(()); } @@ -87,13 +94,13 @@ pub fn uu_app() -> Command { .arg( Arg::new(HELP) .long(HELP) - .help("Print help information") + .help(get_message("printf-help-help")) .action(ArgAction::Help), ) .arg( Arg::new(VERSION) .long(VERSION) - .help("Print version information") + .help(get_message("printf-help-version")) .action(ArgAction::Version), ) .arg(Arg::new(options::FORMAT).value_parser(clap::value_parser!(std::ffi::OsString)))