# Messages français pour GNU concernant gnulib.
# Copyright © 1996-, 2008, 2011 Free Software Foundation, Inc.
# This file is distributed under the same license as the gnulib package.
#
# Michel Robitaille <robitail@IRO.UMontreal.CA>, 1996-.
# Nicolas Provost <nprovost@quadriv.com>, 2008.
# David Prévot <david@tilapin.org>, 2011.
# Stéphane Aulery <lkppo@free.fr>, 2019.
#
msgid ""
msgstr ""
"Project-Id-Version: gnulib-4.0.0.2567\n"
"Report-Msgid-Bugs-To: bug-gnulib@gnu.org\n"
"POT-Creation-Date: 2019-12-11 07:43+0100\n"
"PO-Revision-Date: 2019-05-21 20:15+0200\n"
"Last-Translator: Stéphane Aulery <lkppo@free.fr>\n"
"Language-Team: French <traduc@traduc.org>\n"
"Language: fr\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"X-Bugs: Report translation errors to the Language-Team address.\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Lokalize 1.2\n"

#: lib/argmatch.c:132
#, c-format
msgid "invalid argument %s for %s"
msgstr "argument %s non valable pour %s"

#: lib/argmatch.c:133
#, c-format
msgid "ambiguous argument %s for %s"
msgstr "argument %s ambigu pour %s"

#: lib/argmatch.c:152 lib/argmatch.h:223
msgid "Valid arguments are:"
msgstr "Les arguments valables sont :"

#: lib/bitset/stats.c:177
#, c-format
msgid "%u bitset_allocs, %u freed (%.2f%%).\n"
msgstr "%u bitset_allocs, %u libérés (%.2f%%).\n"

#: lib/bitset/stats.c:180
#, c-format
msgid "%u bitset_sets, %u cached (%.2f%%)\n"
msgstr "%u bitset_sets, %u cachés (%.2f%%).\n"

#: lib/bitset/stats.c:183
#, c-format
msgid "%u bitset_resets, %u cached (%.2f%%)\n"
msgstr "%u bitset_resets, %u cachés (%.2f%%)\n"

#: lib/bitset/stats.c:186
#, c-format
msgid "%u bitset_tests, %u cached (%.2f%%)\n"
msgstr "%u bitset_tests, %u cachés (%.2f%%)\n"

#: lib/bitset/stats.c:190
#, c-format
msgid "%u bitset_lists\n"
msgstr "%u bitset_lists\n"

#: lib/bitset/stats.c:192
msgid "count log histogram\n"
msgstr "histogramme par comptage\n"

#: lib/bitset/stats.c:195
msgid "size log histogram\n"
msgstr "histogramme par taille\n"

#: lib/bitset/stats.c:198
msgid "density histogram\n"
msgstr "histogramme par densité\n"

#: lib/bitset/stats.c:210
#, c-format
msgid ""
"Bitset statistics:\n"
"\n"
msgstr ""
"Statistiques de bitset :\n"
"\n"

#: lib/bitset/stats.c:213
#, c-format
msgid "Accumulated runs = %u\n"
msgstr "Lancement cumulés = %u\n"

#: lib/bitset/stats.c:255 lib/bitset/stats.c:260
msgid "cannot read stats file"
msgstr "impossible de lire les permissions du fichier"

#: lib/bitset/stats.c:257
#, c-format
msgid "bad stats file size\n"
msgstr "taille du fichier de permission erroné\n"

#: lib/bitset/stats.c:281 lib/bitset/stats.c:283
msgid "cannot write stats file"
msgstr "impossible d'écrire les permissions du fichier"

#: lib/bitset/stats.c:286
msgid "cannot open stats file for writing"
msgstr "impossible d'ouvrir les permissions du fichier en écriture"

#: lib/closeout.c:122
msgid "write error"
msgstr "erreur d'écriture"

#: lib/error.c:195
msgid "Unknown system error"
msgstr "Erreur système inconnue"

#: lib/getopt.c:278
#, c-format
msgid "%s: option '%s%s' is ambiguous\n"
msgstr "%s : l'option « %s%s » est ambiguë\n"

#: lib/getopt.c:284
#, c-format
msgid "%s: option '%s%s' is ambiguous; possibilities:"
msgstr "%s : l'option « %s%s » est ambiguë, possibilités :"

#: lib/getopt.c:319
#, c-format
msgid "%s: unrecognized option '%s%s'\n"
msgstr "%s : option « %s%s » non reconnue\n"

#: lib/getopt.c:345
#, c-format
msgid "%s: option '%s%s' doesn't allow an argument\n"
msgstr "%s : l'option « %s%s » ne prend pas d'argument\n"

#: lib/getopt.c:360
#, c-format
msgid "%s: option '%s%s' requires an argument\n"
msgstr "%s : l'option « %s%s » nécessite un argument\n"

#: lib/getopt.c:621
#, c-format
msgid "%s: invalid option -- '%c'\n"
msgstr "%s : option non valable -- « %c »\n"

#: lib/getopt.c:636 lib/getopt.c:682
#, c-format
msgid "%s: option requires an argument -- '%c'\n"
msgstr "%s : l'option nécessite un argument -- « %c »\n"

#: lib/obstack.c:338 lib/obstack.c:340 lib/xalloc-die.c:34
msgid "memory exhausted"
msgstr "mémoire épuisée"

#. TRANSLATORS:
#. Get translations for open and closing quotation marks.
#. The message catalog should translate "`" to a left
#. quotation mark suitable for the locale, and similarly for
#. "'".  For example, a French Unicode local should translate
#. these to U+00AB (LEFT-POINTING DOUBLE ANGLE
#. QUOTATION MARK), and U+00BB (RIGHT-POINTING DOUBLE ANGLE
#. QUOTATION MARK), respectively.
#.
#. If the catalog has no translation, we will try to
#. use Unicode U+2018 (LEFT SINGLE QUOTATION MARK) and
#. Unicode U+2019 (RIGHT SINGLE QUOTATION MARK).  If the
#. current locale is not Unicode, locale_quoting_style
#. will quote 'like this', and clocale_quoting_style will
#. quote "like this".  You should always include translations
#. for "`" and "'" even if U+2018 and U+2019 are appropriate
#. for your locale.
#.
#. If you don't know what to put here, please see
#. <https://en.wikipedia.org/wiki/Quotation_marks_in_other_languages>
#. and use glyphs suitable for your language.
#: lib/quotearg.c:362
msgid "`"
msgstr "« "

#: lib/quotearg.c:363
msgid "'"
msgstr " »"

#: lib/spawn-pipe.c:141 lib/spawn-pipe.c:144 lib/spawn-pipe.c:265
#: lib/spawn-pipe.c:268
#, c-format
msgid "cannot create pipe"
msgstr "impossible de créer un tube (« pipe »)"

#: lib/spawn-pipe.c:235 lib/spawn-pipe.c:349 lib/wait-process.c:290
#: lib/wait-process.c:364
#, c-format
msgid "%s subprocess failed"
msgstr "échec de sous-processus %s"

#: lib/timevar.c:316
msgid "Execution times (seconds)"
msgstr "Temps d'exécution (s)"

#: lib/timevar.c:318
msgid "CPU user"
msgstr "Temps utilisateur"

#: lib/timevar.c:318
msgid "CPU system"
msgstr "Temps système"

#: lib/timevar.c:318
msgid "wall clock"
msgstr "horloge murale"

#: lib/w32spawn.h:49
#, c-format
msgid "_open_osfhandle failed"
msgstr "échec de _open_osfhandle"

#: lib/w32spawn.h:90
#, c-format
msgid "cannot restore fd %d: dup2 failed"
msgstr ""
"impossible de restaurer le descripteur de fichier (fd) %d : échec de dup2"

#: lib/wait-process.c:231 lib/wait-process.c:263 lib/wait-process.c:325
#, c-format
msgid "%s subprocess"
msgstr "sous-processus %s"

#: lib/wait-process.c:282 lib/wait-process.c:354
#, c-format
msgid "%s subprocess got fatal signal %d"
msgstr "le sous-processus %s a reçu un signal fatal %d"

#~ msgid "Packaged by %s (%s)\n"
#~ msgstr "Empaqueté par %s (%s)\n"

#~ msgid "Packaged by %s\n"
#~ msgstr "Empaqueté par %s\n"

#~ msgid "(C)"
#~ msgstr "©"

#~ msgid ""
#~ "License GPLv3+: GNU GPL version 3 or later <%s>.\n"
#~ "This is free software: you are free to change and redistribute it.\n"
#~ "There is NO WARRANTY, to the extent permitted by law.\n"
#~ msgstr ""
#~ "Licence GPLv3+ : GNU GPL version 3 ou ultérieure <%s>\n"
#~ "Logiciel libre : vous êtes libre de le modifier ou de le redistribuer.\n"
#~ "Il n'y a AUCUNE GARANTIE, dans les limites permises par la loi.\n"

#~ msgid "Written by %s.\n"
#~ msgstr "Écrit par %s.\n"

#~ msgid "Written by %s and %s.\n"
#~ msgstr "Écrit par %s et %s.\n"

#~ msgid "Written by %s, %s, and %s.\n"
#~ msgstr "Écrit par %s, %s et %s.\n"

#~ msgid ""
#~ "Written by %s, %s, %s,\n"
#~ "and %s.\n"
#~ msgstr ""
#~ "Écrit par %s, %s, %s,\n"
#~ "et %s.\n"

#~ msgid ""
#~ "Written by %s, %s, %s,\n"
#~ "%s, and %s.\n"
#~ msgstr ""
#~ "Écrit par %s, %s, %s,\n"
#~ "%s et %s.\n"

#~ msgid ""
#~ "Written by %s, %s, %s,\n"
#~ "%s, %s, and %s.\n"
#~ msgstr ""
#~ "Écrit par %s, %s, %s,\n"
#~ "%s, %s, et %s.\n"

#~ msgid ""
#~ "Written by %s, %s, %s,\n"
#~ "%s, %s, %s, and %s.\n"
#~ msgstr ""
#~ "Écrit par %s, %s, %s,\n"
#~ "%s, %s, %s, et %s.\n"

#~ msgid ""
#~ "Written by %s, %s, %s,\n"
#~ "%s, %s, %s, %s,\n"
#~ "and %s.\n"
#~ msgstr ""
#~ "Écrit par %s, %s, %s,\n"
#~ "%s, %s, %s, %s,\n"
#~ "et %s.\n"

#~ msgid ""
#~ "Written by %s, %s, %s,\n"
#~ "%s, %s, %s, %s,\n"
#~ "%s, and %s.\n"
#~ msgstr ""
#~ "Écrit par %s, %s, %s,\n"
#~ "%s, %s, %s, %s,\n"
#~ "%s et %s.\n"

#~ msgid ""
#~ "Written by %s, %s, %s,\n"
#~ "%s, %s, %s, %s,\n"
#~ "%s, %s, and others.\n"
#~ msgstr ""
#~ "Écrit par %s, %s, %s,\n"
#~ "%s, %s, %s, %s,\n"
#~ "%s, %s et d'autres.\n"

#~ msgid "Report bugs to: %s\n"
#~ msgstr "Signalez toute anomalie à : %s\n"

#~ msgid "Report %s bugs to: %s\n"
#~ msgstr "Signalez les anomalies de %s à : %s\n"

#~ msgid "%s home page: <%s>\n"
#~ msgstr "page d'accueil de %s : <%s>\n"

#~ msgid "General help using GNU software: <%s>\n"
#~ msgstr "Aide globale sur les logiciels GNU : <%s>\n"

#~ msgid "ARGP_HELP_FMT: %s value is less than or equal to %s"
#~ msgstr "ARGP_HELP_FMT : la valeur %s est inférieure ou égale à %s"

#~ msgid "%.*s: ARGP_HELP_FMT parameter requires a value"
#~ msgstr "%.*s : le paramètre ARGP_HELP_FMT nécessite une valeur"

#~ msgid "%.*s: Unknown ARGP_HELP_FMT parameter"
#~ msgstr "%.*s : paramètre ARGP_HELP_FMT inconnu"

#~ msgid "Garbage in ARGP_HELP_FMT: %s"
#~ msgstr "Problème dans ARGP_HELP_FMT : %s"

#~ msgid ""
#~ "Mandatory or optional arguments to long options are also mandatory or "
#~ "optional for any corresponding short options."
#~ msgstr ""
#~ "Les arguments obligatoires pour la forme longue des options le sont aussi "
#~ "pour les formes courtes associées."

#~ msgid "Usage:"
#~ msgstr "Utilisation :"

#~ msgid "  or: "
#~ msgstr "  ou : "

#~ msgid " [OPTION...]"
#~ msgstr " [OPTION...]"

#~ msgid "Try '%s --help' or '%s --usage' for more information.\n"
#~ msgstr ""
#~ "Essayez « %s --help » ou « %s --usage » pour obtenir plus de "
#~ "renseignements.\n"

#~ msgid "Report bugs to %s.\n"
#~ msgstr "Signalez toute anomalie à %s.\n"

#~ msgid "give this help list"
#~ msgstr "affiche cette aide"

#~ msgid "give a short usage message"
#~ msgstr "donne un court message d'utilisation"

#~ msgid "NAME"
#~ msgstr "NOM"

#~ msgid "set the program name"
#~ msgstr "définit le nom du programme"

#~ msgid "SECS"
#~ msgstr "SECS"

#~ msgid "hang for SECS seconds (default 3600)"
#~ msgstr "suspension pendant SECS secondes (par défaut 3600)"

#~ msgid "print program version"
#~ msgstr "affiche la version du programme"

#~ msgid "(PROGRAM ERROR) No version known!?"
#~ msgstr "(Erreur du programme) pas de version connue !"

#~ msgid "%s: Too many arguments\n"
#~ msgstr "%s : trop d'arguments\n"

#~ msgid "(PROGRAM ERROR) Option should have been recognized!?"
#~ msgstr "(Erreur du programme) l'option aurait dû être reconnue !"

#~ msgid "program error"
#~ msgstr "erreur du programme"

#~ msgid "stack overflow"
#~ msgstr "dépassement de pile"

#~ msgid "cannot find a temporary directory, try setting $TMPDIR"
#~ msgstr ""
#~ "impossible de trouver un répertoire temporaire, essayez de définir $TMPDIR"

#~ msgid "cannot create a temporary directory using template \"%s\""
#~ msgstr ""
#~ "impossible de créer un répertoire temporaire en utilisant le modèle "
#~ "« %s »."

#~ msgid "cannot remove temporary file %s"
#~ msgstr "impossible de supprimer le ficher temporaire %s"

#~ msgid "cannot remove temporary directory %s"
#~ msgstr "impossible de supprimer le répertoire temporaire %s"

#~ msgid "error closing file"
#~ msgstr "erreur de fermeture de fichier"

#~ msgid "preserving permissions for %s"
#~ msgstr "conservation des permissions de %s"

#~ msgid "error while opening %s for reading"
#~ msgstr "erreur à l'ouverture de %s en lecture"

#~ msgid "cannot open backup file %s for writing"
#~ msgstr "impossible d'ouvrir le fichier de sauvegarde %s en écriture"

#~ msgid "error reading %s"
#~ msgstr "erreur de lecture de %s"

#~ msgid "error writing %s"
#~ msgstr "erreur d'écriture de %s"

#~ msgid "error after reading %s"
#~ msgstr "erreur après la lecture de %s"

#~ msgid "fdopen() failed"
#~ msgstr "échec de fdopen()"

#~ msgid "C# compiler not found, try installing mono"
#~ msgstr "compilateur C# non trouvé, essayez d'installer mono"

#~ msgid "C# virtual machine not found, try installing mono"
#~ msgstr "machine virtuelle C# non trouvée, essayez d'installer mono"

#~ msgid "unbalanced ["
#~ msgstr "[ non appairée"

#~ msgid "invalid character class"
#~ msgstr "nom de classe de caractères non valable"

#~ msgid "character class syntax is [[:space:]], not [:space:]"
#~ msgstr ""
#~ "la syntaxe de la classe de caractères est [[:space:]], et non [:space:]"

#~ msgid "unfinished \\ escape"
#~ msgstr "espace \\ non terminé"

#~ msgid "invalid content of \\{\\}"
#~ msgstr "le contenu de \\{\\} n'est pas valable"

#~ msgid "regular expression too big"
#~ msgstr "expression rationnelle trop grande"

#~ msgid "unbalanced ("
#~ msgstr "( non appairée"

#~ msgid "no syntax specified"
#~ msgstr "pas de syntaxe spécifiée"

#~ msgid "unbalanced )"
#~ msgstr ") non appairée"

#~ msgid "regular empty file"
#~ msgstr "fichier régulier vide"

#~ msgid "regular file"
#~ msgstr "fichier régulier"

#~ msgid "directory"
#~ msgstr "répertoire"

#~ msgid "symbolic link"
#~ msgstr "lien symbolique"

#~ msgid "message queue"
#~ msgstr "file de messages"

#~ msgid "semaphore"
#~ msgstr "sémaphore"

#~ msgid "shared memory object"
#~ msgstr "objet de mémoire partagée"

#~ msgid "typed memory object"
#~ msgstr "objet mémoire typé"

#~ msgid "block special file"
#~ msgstr "fichier spécial de blocs"

#~ msgid "character special file"
#~ msgstr "fichier spécial de caractères"

#~ msgid "contiguous data"
#~ msgstr "données contiguës"

#~ msgid "fifo"
#~ msgstr "PEPS (FIFO)"

#~ msgid "door"
#~ msgstr "porte"

#~ msgid "multiplexed block special file"
#~ msgstr "fichier spécial de blocs multipléxé"

#~ msgid "multiplexed character special file"
#~ msgstr "fichier spécial de caractères mulipléxé"

#~ msgid "multiplexed file"
#~ msgstr "fichier multipléxé"

#~ msgid "named file"
#~ msgstr "fichier nommé"

#~ msgid "network special file"
#~ msgstr "fichier spécial de réseau"

#~ msgid "migrated file with data"
#~ msgstr "fichier migré avec ses données"

#~ msgid "migrated file without data"
#~ msgstr "fichier migré sans ses données"

#~ msgid "port"
#~ msgstr "port"

#~ msgid "socket"
#~ msgstr "socket"

#~ msgid "whiteout"
#~ msgstr "sans"

#~ msgid "weird file"
#~ msgstr "fichier bizarre"

#~ msgid "Address family for hostname not supported"
#~ msgstr "Famille d'adresses du nom d'hôte non pris en charge"

#~ msgid "Temporary failure in name resolution"
#~ msgstr "Échec temporaire lors de la résolution de noms"

#~ msgid "Bad value for ai_flags"
#~ msgstr "Mauvaise valeur pour ai_flags"

#~ msgid "Non-recoverable failure in name resolution"
#~ msgstr "Échec définitif lors de la résolution de noms"

#~ msgid "ai_family not supported"
#~ msgstr "ai_family non pris en charge"

#~ msgid "Memory allocation failure"
#~ msgstr "Échec d'allocation mémoire"

#~ msgid "No address associated with hostname"
#~ msgstr "Aucune adresse associée au nom d'hôte"

#~ msgid "Name or service not known"
#~ msgstr "Nom ou service inconnu"

#~ msgid "Servname not supported for ai_socktype"
#~ msgstr "Nom de serveur non pris en charge pour ai_socktype"

#~ msgid "ai_socktype not supported"
#~ msgstr "ai_socktype non pris en charge"

#~ msgid "System error"
#~ msgstr "Erreur système"

#~ msgid "Argument buffer too small"
#~ msgstr "Mémoire tampon d'argument trop petite"

#~ msgid "Processing request in progress"
#~ msgstr "Traitement de la requête en cours"

#~ msgid "Request canceled"
#~ msgstr "Requête annulée"

#~ msgid "Request not canceled"
#~ msgstr "Requête non annulée"

#~ msgid "All requests done"
#~ msgstr "Requêtes toutes traitées"

#~ msgid "Interrupted by a signal"
#~ msgstr "Interruption par un signal"

#~ msgid "Parameter string not correctly encoded"
#~ msgstr "Chaîne de paramètre mal encodé"

#~ msgid "Unknown error"
#~ msgstr "Erreur inconnue"

#~ msgid "invalid source_version argument to compile_java_class"
#~ msgstr "argument source_version non valable pour compile_java_class"

#~ msgid "invalid target_version argument to compile_java_class"
#~ msgstr "argument target_version non valable pour compile_java_class"

#~ msgid "failed to create \"%s\""
#~ msgstr "échec de création de « %s »"

#~ msgid "error while writing \"%s\" file"
#~ msgstr "erreur lors de l'écriture du fichier « %s »"

#~ msgid "Java compiler not found, try installing gcj or set $JAVAC"
#~ msgstr ""
#~ "compilateur Java non trouvé, essayez d'installer gcj ou de définir $JAVAC"

#~ msgid "Java virtual machine not found, try installing gij or set $JAVA"
#~ msgstr ""
#~ "machine virtuelle Java non trouvée, essayez d'installer gij ou de définir "
#~ "$JAVAC"

#~ msgid "%s subprocess I/O error"
#~ msgstr "erreur d'entrée sortie du sous-processus %s"

#~ msgid "cannot stat %s"
#~ msgstr "impossible de lire les permissions de %s"

#~ msgid "cannot change permissions of %s"
#~ msgstr "impossible de modifier les permissions de %s"

#~ msgid "cannot create directory %s"
#~ msgstr "impossible de créer le répertoire %s"

#~ msgid "unable to record current working directory"
#~ msgstr "impossible de mémoriser le répertoire de travail courant"

#~ msgid "failed to return to initial working directory"
#~ msgstr "échec de retour au répertoire initial de travail"

#~ msgid "Failed to open /dev/zero for read"
#~ msgstr "Échec d'ouverture de /dev/zero en lecture"

#~ msgid "creation of reading thread failed"
#~ msgstr "échec de création du processus de lecture"

#~ msgid "cannot set up nonblocking I/O to %s subprocess"
#~ msgstr ""
#~ "impossible de configurer l'entrée sortie non bloquante au sous-processus "
#~ "%s"

#~ msgid "communication with %s subprocess failed"
#~ msgstr "échec de communication avec le sous-processus %s"

#~ msgid "write to %s subprocess failed"
#~ msgstr "échec d'écriture vers le sous-processus %s"

#~ msgid "read from %s subprocess failed"
#~ msgstr "échec de lecture depuis le sous-processus %s"

#~ msgid "subprocess %s terminated with exit code %d"
#~ msgstr "le sous-processus %s s'est terminé avec le code de retour %d"

#~ msgid "creation of threads failed"
#~ msgstr "échec de création de processus"

#~ msgid "%s subprocess terminated with exit code %d"
#~ msgstr "le sous-processus de %s s'est terminé avec le code de retour %d"

#~ msgid "Success"
#~ msgstr "Succès"

#~ msgid "No match"
#~ msgstr "Pas de correspondance"

#~ msgid "Invalid regular expression"
#~ msgstr "Expression rationnelle non valable"

#~ msgid "Invalid collation character"
#~ msgstr "Caractère d'assemblage non valable"

#~ msgid "Invalid character class name"
#~ msgstr "Nom de classe de caractères non valable"

#~ msgid "Trailing backslash"
#~ msgstr "Barre oblique inverse en fin de ligne"

#~ msgid "Invalid back reference"
#~ msgstr "Référence antérieure non valable"

#~ msgid "Unmatched [, [^, [:, [., or [="
#~ msgstr "[, [^, [:, [. ou [= non appairé"

#~ msgid "Unmatched ( or \\("
#~ msgstr "( ou \\( non appairée"

#~ msgid "Unmatched \\{"
#~ msgstr "\\{ non appairée"

#~ msgid "Invalid content of \\{\\}"
#~ msgstr "Le contenu de \\{\\} n'est pas valable"

#~ msgid "Invalid range end"
#~ msgstr "Borne finale de l'intervalle non valable"

#~ msgid "Memory exhausted"
#~ msgstr "Mémoire épuisée"

#~ msgid "Invalid preceding regular expression"
#~ msgstr "Expression rationnelle précédente non valable"

#~ msgid "Premature end of regular expression"
#~ msgstr "Fin prématurée d'expression rationnelle"

#~ msgid "Regular expression too big"
#~ msgstr "Expression rationnelle trop grande"

#~ msgid "Unmatched ) or \\)"
#~ msgstr ") ou \\) non appairée"

#~ msgid "No previous regular expression"
#~ msgstr "Pas d'expression rationnelle précédente"

#~ msgid "^[yY]"
#~ msgstr "^[oOyY].*"

#~ msgid "^[nN]"
#~ msgstr "^[nN].*"

#~ msgid "setting permissions for %s"
#~ msgstr "impossible de définir les permissions de %s"

#~ msgid "Hangup"
#~ msgstr "Raccrocher"

#~ msgid "Interrupt"
#~ msgstr "Interrompre"

#~ msgid "Quit"
#~ msgstr "Quitter"

#~ msgid "Illegal instruction"
#~ msgstr "Instruction illégale"

#~ msgid "Trace/breakpoint trap"
#~ msgstr "Piège de trace ou point de d'arrêt "

#~ msgid "Aborted"
#~ msgstr "Abandonné"

#~ msgid "Floating point exception"
#~ msgstr "Exception de virgule flottante"

#~ msgid "Killed"
#~ msgstr "Tué"

#~ msgid "Bus error"
#~ msgstr "Erreur de bus"

#~ msgid "Segmentation fault"
#~ msgstr "Erreur de segmentation"

#~ msgid "Broken pipe"
#~ msgstr "Tube rompu"

#~ msgid "Alarm clock"
#~ msgstr "Réveil"

#~ msgid "Terminated"
#~ msgstr "Terminé"

#~ msgid "Urgent I/O condition"
#~ msgstr "Condition d'entrée sortie urgente"

#~ msgid "Stopped (signal)"
#~ msgstr "Arrêté (signal)"

#~ msgid "Stopped"
#~ msgstr "Arrêté"

#~ msgid "Continued"
#~ msgstr "Continué"

#~ msgid "Child exited"
#~ msgstr "Fin du processus fils"

#~ msgid "Stopped (tty input)"
#~ msgstr "Arrêté (entrée de tty)"

#~ msgid "Stopped (tty output)"
#~ msgstr "Arrêté (sortie de tty)"

#~ msgid "I/O possible"
#~ msgstr "Entrée sortie possible"

#~ msgid "CPU time limit exceeded"
#~ msgstr "Temps limite de processeur dépassé"

#~ msgid "File size limit exceeded"
#~ msgstr "Taille limite de fichier dépassée"

#~ msgid "Virtual timer expired"
#~ msgstr "Temporisation virtuelle dépassée"

#~ msgid "Profiling timer expired"
#~ msgstr "Temporisation de profilage dépassée"

#~ msgid "Window changed"
#~ msgstr "Fenêtre modifiée"

#~ msgid "User defined signal 1"
#~ msgstr "Signal 1 défini par utilisateur"

#~ msgid "User defined signal 2"
#~ msgstr "Signal 2 défini par utilisateur"

#~ msgid "EMT trap"
#~ msgstr "Piège EMT"

#~ msgid "Bad system call"
#~ msgstr "Mauvais appel système"

#~ msgid "Stack fault"
#~ msgstr "Défaut de pile"

#~ msgid "Information request"
#~ msgstr "Demande de renseignements"

#~ msgid "Power failure"
#~ msgstr "Échec d'alimentation"

#~ msgid "Resource lost"
#~ msgstr "Ressource perdue"

#~ msgid "error writing to a closed pipe or socket"
#~ msgstr "Erreur d'écriture vers un tube ou un socket fermé"

#~ msgid "Real-time signal %d"
#~ msgstr "Signal %d en temps réel"

#~ msgid "Unknown signal %d"
#~ msgstr "Signal %d inconnu"

#~ msgid "iconv function not usable"
#~ msgstr "fonction iconv non utilisable"

#~ msgid "iconv function not available"
#~ msgstr "fonction iconv non disponible"

#~ msgid "character out of range"
#~ msgstr "caractère hors limites"

#~ msgid "cannot convert U+%04X to local character set"
#~ msgstr "impossible de convertir U+%04X dans le jeu de caractères local"

#~ msgid "cannot convert U+%04X to local character set: %s"
#~ msgstr "impossible de convertir U+%04X dans le jeu de caractères local : %s"

#~ msgid "invalid user"
#~ msgstr "utilisateur non valable"

#~ msgid "invalid group"
#~ msgstr "groupe non valable"

#~ msgid "invalid spec"
#~ msgstr "spécification non valable"

#~ msgid "unable to display error message"
#~ msgstr "impossible d'afficher le message d'erreur"

#~ msgid "failed to set file descriptor text/binary mode"
#~ msgstr ""
#~ "impossible de définir le mode texte/binaire du descripteur de fichier"

#~ msgid "stdin"
#~ msgstr "entrée standard (stdin)"

#~ msgid "stdout"
#~ msgstr "sortie standard (stdout)"

#~ msgid "stderr"
#~ msgstr "sortie d'erreur (stderr)"

#~ msgid "unknown stream"
#~ msgstr "flux inconnu"

#~ msgid "failed to reopen %s with mode %s"
#~ msgstr "impossible de rouvrir %s en mode %s"

#~ msgid "string comparison failed"
#~ msgstr "échec de comparaison de chaîne"

#~ msgid "Set LC_ALL='C' to work around the problem."
#~ msgstr "Définir LC_ALL='C' pour contourner le problème."

#~ msgid "The strings compared were %s and %s."
#~ msgstr "Les chaînes comparées étaient %s et %s."

#~ msgid "cannot perform formatted output"
#~ msgstr "impossible mettre en forme la sortie formatée"

#~ msgid "standard file descriptors"
#~ msgstr "descripteurs de fichier standards"

#~ msgid "invalid %s%s argument '%s'"
#~ msgstr "argument %s%s non valable « %s »"

#~ msgid "invalid suffix in %s%s argument '%s'"
#~ msgstr "suffixe non valable dans l'argument %s%s « %s »"

#~ msgid "%s%s argument '%s' too large"
#~ msgstr "argument %s%s « %s » trop grand"

#~ msgid "%s home page: <https://www.gnu.org/software/%s/>\n"
#~ msgstr "page d'accueil de %s : <https://www.gnu.org/software/%s/>\n"
