perkamon - en to fr translation catalogue (183 entries)

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

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: abort - cause abnormal process termination
fr: abort - Terminer de manière anormale un programme

note: type: Plain text
en: The B<abort>()  first unblocks the B<SIGABRT> signal, and then raises that signal for the calling process.  This results in the abnormal termination of the process unless the B<SIGABRT> signal is caught and the signal handler does not return (see B<longjmp>(3)).
fr: B<abort>() déverrouille le signal B<SIGABRT>, puis émet celui-ci pour le processus appelant. Le processus est alors terminé de façon anormale, sauf si le signal B<SIGABRT> est intercepté et si le gestionnaire de signaux ne rend pas la main (consultez B<longjmp>(3)).

note: type: Plain text
en: If the B<abort>()  function causes process termination, all open streams are closed and flushed.
fr: Si B<abort>() produit effectivement la fin d'exécution du processus, tous les flux ouverts sont vidés et fermés

note: type: Plain text
en: If the B<SIGABRT> signal is ignored, or caught by a handler that returns, the B<abort>()  function will still terminate the process.  It does this by restoring the default disposition for B<SIGABRT> and then raising the signal for a second time.
fr: Si le signal B<SIGABRT> est ignoré ou intercepté par un gestionnaire de signaux qui retourne, B<abort>() terminera de toute façon le processus. Il effectue cela en restaurant la disposition par défaut de B<SIGABRT> et en émettant le signal une seconde fois.

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

note: type: Plain text
en: The B<abort>()  function never returns.
fr: La fonction B<abort>() ne revient jamais.

note: type: SH
en: ATTRIBUTES
fr: ATTRIBUTS

note: type: SS
en: Multithreading (see pthreads(7))
fr: Multithreading (consultez pthreads(7))

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

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

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

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

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

note: type: TH
en: 2013-09-26
fr: 26 septembre 2013

note: type: Plain text
en: assert - abort the program if assertion is false
fr: assert - Terminer le programme en cas d'échec d'un test

note: type: Plain text
en: If the macro B<NDEBUG> was defined at the moment I<E<lt>assert.hE<gt>> was last included, the macro B<assert>()  generates no code, and hence does nothing at all.  Otherwise, the macro B<assert>()  prints an error message to standard error and terminates the program by calling B<abort>(3)  if I<expression> is false (i.e., compares equal to zero).
fr: Si la macro B<NDEBUG> est définie au moment de la dernière inclusion de I<E<lt>assert.hE<gt>>, la macro B<assert>() ne génère aucun code et ne fait rien. Sinon, la macro B<assert>() affiche un message d'erreur sur la sortie d'erreur et termine l'exécution du programme en cours en appelant B<abort>(3) si I<expression> est fausse (égale à zéro).

note: type: Plain text
en: The purpose of this macro is to help programmers find bugs in their programs.  The message "assertion failed in file foo.c, function do_bar(), line 1287" is of no help at all to a user.
fr: Le but de cette macro est d'aider les programmeurs à trouver des bogues dans leurs applications. Le message «\ assertion failed in file foo.c, function do_bar(), line 1287\ » ne sert à rien pour l'utilisateur.

note: type: Plain text
en: No value is returned.
fr: Aucune valeur n'est renvoyée.

note: See Defect Report 107 for more details. type: Plain text
en: POSIX.1-2001, C89, C99.  In C89, I<expression> is required to be of type I<int> and undefined behavior results if it is not, but in C99 it may have any scalar type.
fr: POSIX.1-2001, C89, C99. Dans C89, I<expression> devait être de type I<int> et le comportement était indéfini si ce n'était pas le cas, mais dans C99, elle peut être de n'importe quel type scalaire.

note: type: SH
en: BUGS
fr: BOGUES

note: type: Plain text
en: B<assert>()  is implemented as a macro; if the expression tested has side-effects, program behavior will be different depending on whether B<NDEBUG> is defined.  This may create Heisenbugs which go away when debugging is turned on.
fr: B<assert>() étant implémentée comme une macro, si l'expression testée a des effets de bord, le comportement du programme différera suivant l'existence de B<NDEBUG>. Cela peut induire des «\ Heisenbugs\ » (N.d.T\ : bogue qui disparaît ou se modifie quand on essaye de le localiser) qui disparaissent lors du débogage.

note: type: Plain text
en: assert_perror - test errnum and abort
fr: assert_perror - Vérifier un code d'erreur et arrêter le programme

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

note: type: Plain text
en: If the macro B<NDEBUG> was defined at the moment I<E<lt>assert.hE<gt>> was last included, the macro B<assert_perror>()  generates no code, and hence does nothing at all.  Otherwise, the macro B<assert_perror>()  prints an error message to standard error and terminates the program by calling B<abort>(3)  if I<errnum> is nonzero.  The message contains the filename, function name and line number of the macro call, and the output of I<strerror(errnum)>.
fr: Si la macro B<NDEBUG> est définie lors de la dernière inclusion de I<E<lt>assert.hE<gt>>, la macro B<assert_perror>() ne génère aucun code et n'a donc aucun effet. Sinon, la macro B<assert_perror>() affiche un message d'erreur sur la sortie d'erreur et termine le programme en appelant B<abort>(3) si I<errnum> est non nul. Le message contient le nom du fichier, le nom de la fonction et le numéro de ligne de l'appel de la macro, ainsi que le résultat de I<strerror(errnum)>.

note: type: Plain text
en: This is a GNU extension.
fr: Il s'agit d'une extension GNU.

note: type: Plain text
en: The purpose of the assert macros is to help programmers find bugs in their programs, things that cannot happen unless there was a coding mistake.  However, with system or library calls the situation is rather different, and error returns can happen, and will happen, and should be tested for.  Not by an assert, where the test goes away when B<NDEBUG> is defined, but by proper error handling code.  Never use this macro.
fr: Le but des macros d'assertion est d'aider les programmeurs à trouver des bogues dans leurs applications, bogues résultant d'erreur de programmation. Cependant, avec les fonctions ou les appels système, la situation est différente et un retour en erreur peut (et va) survenir et doit donc être testé. N'utilisez pas une assertion dont le test disparaîtrait quand B<NDEBUG> est définie, mais écrivez un gestionnaire d'erreur correct. N'utilisez jamais cette macro.

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

note: type: Plain text
en: err, verr, errx, verrx, warn, vwarn, warnx, vwarnx - formatted error messages
fr: err, verr, errx, verrx, warn, vwarn, warnx, vwarnx - Messages d'erreurs formatés

note: type: Plain text
en: The B<err>()  and B<warn>()  family of functions display a formatted error message on the standard error output.  In all cases, the last component of the program name, a colon character, and a space are output.  If the I<fmt> argument is not NULL, the B<printf>(3)-like formatted error message is output.  The output is terminated by a newline character.
fr: Les fonctions de la famille B<err>() et B<warn>() affichent un message d'erreur formaté sur la sortie d'erreur standard. Dans tous les cas, elles affichent le nom du programme, un deux-points, et une espace. Si l'argument I<fmt> n'est pas NULL, le message est affiché avec un format de type B<printf>(3). La sortie se termine par un saut de ligne.

note: type: Plain text
en: The B<err>(), B<verr>(), B<warn>(), and B<vwarn>()  functions append an error message obtained from B<strerror>(3)  based on the global variable I<errno>, preceded by another colon and space unless the I<fmt> argument is NULL.
fr: Les fonctions B<err>(), B<verr>(), B<warn>(), et B<vwarn>() ajoutent un message d'erreur obtenu avec B<strerror>(3) à partir de la variable globale I<errno>, précédé d'un autre deux-points et d'un espace, sauf si l'argument I<fmt> est NULL.

note: type: Plain text
en: The B<errx>()  and B<warnx>()  functions do not append an error message.
fr: Les fonctions B<errx>() et B<warnx>() n'ajoutent pas de message d'erreur.

note: type: Plain text
en: The B<err>(), B<verr>(), B<errx>(), and B<verrx>()  functions do not return, but exit with the value of the argument I<eval>.
fr: Les fonctions B<err>(), B<verr>(), B<errx>(), et B<verrx>() ne reviennent pas, elles terminent le programme avec le code de retour I<eval>.

note: .SH HISTORY The .BR err () and .BR warn () functions first appeared in 4.4BSD. type: Plain text
en: These functions are nonstandard BSD extensions.
fr: Ces fonctions sont des extensions BSD non standard.

note: type: SH
en: EXAMPLE
fr: EXEMPLE

note: type: Plain text
en: Display the current I<errno> information string and exit:
fr: Afficher la chaîne d'informations I<errno> courante et sortir\ :

note: type: Plain text
en: Display an error message and exit:
fr: Afficher un message d'erreur et sortir\ :

note: type: Plain text
en: Warn of an error:
fr: Avertissement sur une erreur\ :

note: type: TH
en: 2008-07-09
fr: 9 juillet 2008

note: type: Plain text
en: errno - number of last error
fr: errno - Code de la dernière erreur

note: type: Plain text
en: The I<E<lt>errno.hE<gt>> header file defines the integer variable I<errno>, which is set by system calls and some library functions in the event of an error to indicate what went wrong.  Its value is significant only when the return value of the call indicated an error (i.e., -1 from most system calls; -1 or NULL from most library functions); a function that succeeds I<is> allowed to change I<errno>.
fr: Le fichier d'en-tête I<E<lt>errno.hE<gt>> définit la variable entière I<errno>, qui est renseignée par les appels système et quelques fonctions de bibliothèque pour décrire les conditions d'erreurs. Sa valeur n'est significative que lorsque la valeur de retour l'appel système indique une erreur (c'est-à-dire -1 pour la plupart des appels système ; -1 ou NULL pour la plupart des fonctions de bibliothèque) ; en cas de réussite une fonction de bibliothèque peut modifier I<errno>.

note: type: Plain text
en: Valid error numbers are all nonzero; I<errno> is never set to zero by any system call or library function.
fr: Les numéros d'erreur corrects sont tous non nuls ; I<errno> n'est mis à zéro par aucun appel système ou fonction de bibliothèque.

note: type: Plain text
en: For some system calls and library functions (e.g., B<getpriority>(2)), -1 is a valid return on success.  In such cases, a successful return can be distinguished from an error return by setting I<errno> to zero before the call, and then, if the call returns a status that indicates that an error may have occurred, checking to see if I<errno> has a nonzero value.
fr: Pour certains appels système et fonctions de bibliothèque (par exemple B<getpriority>(2)), -1 est une valeur de retour correcte en cas de réussite. Dans de tels cas, une valeur de retour en cas de réussite peut être distinguée d'un cas d'erreur en positionnant I<errno> à zéro avant l'appel, puis, quand l'appel fourni une valeur qui indique qu'une erreur a pu se produire, en vérifiant si I<errno> a une valeur non nulle.

note: type: Plain text
en: I<errno> is defined by the ISO C standard to be a modifiable lvalue of type I<int>, and must not be explicitly declared; I<errno> may be a macro.  I<errno> is thread-local; setting it in one thread does not affect its value in any other thread.
fr: I<errno> est définie par le standard ISO C comme une «\ lvalue\ » modifiable de type I<int>, et n'a pas besoin d'être définie explicitement\ ; I<errno> peut être une macro. I<errno> est locale à un thread\ ; lui affecter une valeur dans un thread ne modifie pas sa valeur dans les autres threads.

note: type: Plain text
en: All the error names specified by POSIX.1 must have distinct values, with the exception of B<EAGAIN> and B<EWOULDBLOCK>, which may be the same.
fr: Toutes les erreurs détaillées dans POSIX.1 doivent avoir des valeurs différentes à l'exception de B<EAGAIN> et B<EWOULDBLOCK> qui peuvent avoir la même valeur.

note: The following is now POSIX.1 (2001 edition) lists the following symbolic error names.  Of these, \fBEDOM\fP and \fBERANGE\fP are in the ISO C standard.  ISO C Amendment 1 defines the additional error number \fBEILSEQ\fP for coding errors in multibyte or wide characters. type: Plain text
en: Below is a list of the symbolic error names that are defined on Linux.  Some of these are marked I<POSIX.1>, indicating that the name is defined by POSIX.1-2001, or I<C99>, indicating that the name is defined by C99.
fr: Ci-dessous, une liste des noms d'erreurs symboliques qui sont définis sous Linux. Certains sont marqués avec I<POSIX.1>, cela signifie que POSIX.1-2001 les définit, ceux marqués avec I<C99>, sont définis par C99.

note: type: Plain text
en: Argument list too long (POSIX.1)
fr: Liste d'arguments trop longue (POSIX.1)

note: type: Plain text
en: Permission denied (POSIX.1)
fr: Permission refusée (POSIX.1)

note: type: Plain text
en: Address already in use (POSIX.1)
fr: Adresse déjà en cours d'utilisation (POSIX.1)

note: EADV is only an error on HURD(?) type: Plain text
en: Address not available (POSIX.1)
fr: Adresse non disponible (POSIX.1)

note: type: Plain text
en: Address family not supported (POSIX.1)
fr: Famille d'adresses non supportée (POSIX.1)

note: type: Plain text
en: Resource temporarily unavailable (may be the same value as B<EWOULDBLOCK>)  (POSIX.1)
fr: Ressource temporairement indisponible (peut être la même valeur que B<EWOULDBLOCK>) (POSIX.1)

note: type: Plain text
en: Connection already in progress (POSIX.1)
fr: Connexion déjà en cours (POSIX.1)

note: type: Plain text
en: Invalid exchange
fr: Échange invalide

note: type: Plain text
en: Bad file descriptor (POSIX.1)
fr: Mauvais descripteur de fichier (POSIX.1)

note: type: Plain text
en: File descriptor in bad state
fr: Descripteur de fichier dans un mauvais état

note: type: Plain text
en: Bad message (POSIX.1)
fr: Mauvais message (POSIX.1)

note: type: Plain text
en: Invalid request descriptor
fr: Descripteur de requête non valable

note: type: Plain text
en: Invalid request code
fr: Code de requête non valable

note: EBFONT is defined but appears not to be used by kernel or glibc. type: Plain text
en: Invalid slot
fr: Emplacement (« Slot ») non valable

note: type: Plain text
en: Device or resource busy (POSIX.1)
fr: Périphérique ou ressource indisponible (POSIX.1)

note: type: Plain text
en: Operation canceled (POSIX.1)
fr: Opération annulée (POSIX.1)

note: type: Plain text
en: No child processes (POSIX.1)
fr: Pas de processus fils (POSIX.1)

note: type: Plain text
en: Channel number out of range
fr: Numéro de voie hors du domaine de définition

note: type: Plain text
en: Communication error on send
fr: Échec de la communication lors de l'envoi

note: type: Plain text
en: Connection aborted (POSIX.1)
fr: Connexion abandonnée (POSIX.1)

note: type: Plain text
en: Connection refused (POSIX.1)
fr: Connexion refusée (POSIX.1)

note: type: Plain text
en: Connection reset (POSIX.1)
fr: Connexion réinitialisée (POSIX.1)

note: type: Plain text
en: Resource deadlock avoided (POSIX.1)
fr: Blocage d'une ressource évité (POSIX.1)

note: type: Plain text
en: Synonym for B<EDEADLK>
fr: Synonyme de B<EDEADLK>

note: type: Plain text
en: Destination address required (POSIX.1)
fr: Adresse de destination nécessaire (POSIX.1)

note: EDOTDOT is defined but appears to be unused type: Plain text
en: Mathematics argument out of domain of function (POSIX.1, C99)
fr: Argument mathématique hors du domaine de définition de la fonction (POSIX.1, C99)

note: POSIX just says "Reserved" type: Plain text
en: Disk quota exceeded (POSIX.1)
fr: Quota du disque dépassé (POSIX.1)

note: type: Plain text
en: File exists (POSIX.1)
fr: Fichier existant (POSIX.1)

note: type: Plain text
en: Bad address (POSIX.1)
fr: Mauvaise adresse (POSIX.1)

note: type: Plain text
en: File too large (POSIX.1)
fr: Fichier trop grand (POSIX.1)

note: type: Plain text
en: Host is down
fr: Hôte éteint

note: type: Plain text
en: Host is unreachable (POSIX.1)
fr: Hôte non accessible (POSIX.1)

note: type: Plain text
en: Identifier removed (POSIX.1)
fr: Identificateur supprimé (POSIX.1)

note: type: Plain text
en: Illegal byte sequence (POSIX.1, C99)
fr: Séquence d'octets illégale (POSIX.1, C99)

note: type: Plain text
en: Operation in progress (POSIX.1)
fr: Opération en cours (POSIX.1)

note: type: Plain text
en: Interrupted function call (POSIX.1); see B<signal>(7).
fr: Appel système interrompu (POSIX.1) ; consultez B<signal>(7).

note: type: Plain text
en: Invalid argument (POSIX.1)
fr: Argument invalide (POSIX.1)

note: type: Plain text
en: Input/output error (POSIX.1)
fr: Erreur d'entrée/sortie (POSIX.1)

note: type: Plain text
en: Socket is connected (POSIX.1)
fr: La socket est connectée (POSIX.1)

note: type: Plain text
en: Is a directory (POSIX.1)
fr: Est un répertoire (POSIX.1)

note: type: Plain text
en: Is a named type file
fr: Est un fichier nommé

note: type: Plain text
en: Key has expired
fr: Clé expirée

note: type: Plain text
en: Key was rejected by service
fr: La clé a été rejeté par le service

note: type: Plain text
en: Key has been revoked
fr: La clé a été révoquée

note: type: Plain text
en: Level 2 halted
fr: Niveau 2 arrêté

note: type: Plain text
en: Level 2 not synchronized
fr: Niveau 2 non synchronisé

note: type: Plain text
en: Level 3 halted
fr: Niveau 3 arrêté

note: type: Plain text
en: Cannot access a needed shared library
fr: Impossible d'accéder à la bibliothèque partagée nécessaire

note: type: Plain text
en: Accessing a corrupted shared library
fr: Accès à une bibliothèque partagée corrompue

note: type: Plain text
en: Attempting to link in too many shared libraries
fr: Tentative de liaison avec trop de bibliothèques partagées

note: type: Plain text
en: lib section in a.out corrupted
fr: Section lib dans a.out corrompue

note: type: Plain text
en: Cannot exec a shared library directly
fr: Impossible d'exécuter directement une bibliothèque partagée

note: ELNRNG is defined but appears to be unused type: Plain text
en: Too many levels of symbolic links (POSIX.1)
fr: Trop de niveau de liens symboliques rencontrés (POSIX.1)

note: type: Plain text
en: Wrong medium type
fr: Mauvais type de médium

note: type: Plain text
en: Too many open files (POSIX.1)
fr: Trop de fichiers ouverts (POSIX.1)

note: type: Plain text
en: Too many links (POSIX.1)
fr: Trop de liens symboliques (POSIX.1)

note: type: Plain text
en: Message too long (POSIX.1)
fr: Message trop long (POSIX.1)

note: POSIX says "Reserved" type: Plain text
en: Multihop attempted (POSIX.1)
fr: Tentative de saut multiple « Multihop » (POSIX.1)

note: ENAVAIL is defined, but appears not to be used type: Plain text
en: Filename too long (POSIX.1)
fr: Nom de fichier trop long (POSIX.1)

note: type: Plain text
en: Network is down (POSIX.1)
fr: Le réseau est désactivé (POSIX.1)

note: type: Plain text
en: Connection aborted by network (POSIX.1)
fr: Connexion annulée par le réseau (POSIX.1)

note: type: Plain text
en: Network unreachable (POSIX.1)
fr: Réseau inaccessible (POSIX.1)

note: ENOANO is defined but appears to be unused. type: Plain text
en: Too many open files in system (POSIX.1)
fr: Trop de fichiers ouverts sur le système (POSIX.1)

note: ENOCSI is defined but appears to be unused. type: Plain text
en: No buffer space available (POSIX.1 (XSI STREAMS option))
fr: Plus de tampons disponibles (POSIX.1 (option des FLUX XSI))

note: type: Plain text
en: No message is available on the STREAM head read queue (POSIX.1)
fr: Pas de message disponible en tête de la queue de lecture du FLUX (POSIX.1)

note: type: Plain text
en: No such device (POSIX.1)
fr: Périphérique inexistant (POSIX.1)

note: type: Plain text
en: No such file or directory (POSIX.1)
fr: Fichier ou répertoire inexistant (POSIX.1)

note: type: Plain text
en: Exec format error (POSIX.1)
fr: Erreur de format d'exécution (POSIX.1)

note: type: Plain text
en: Required key not available
fr: Clé nécessaire non disponible

note: type: Plain text
en: No locks available (POSIX.1)
fr: Pas de verrou disponible (POSIX.1)

note: POSIX says "Reserved" type: Plain text
en: Link has been severed (POSIX.1)
fr: Un lien a été disjoint (POSIX.1)

note: type: Plain text
en: No medium found
fr: Aucun média trouvé

note: type: Plain text
en: Not enough space (POSIX.1)
fr: Pas assez de mémoire (POSIX.1)

note: type: Plain text
en: No message of the desired type (POSIX.1)
fr: Pas de message du type attendu (POSIX.1)

note: type: Plain text
en: Machine is not on the network
fr: La machine n'est pas sur le réseau

note: type: Plain text
en: Package not installed
fr: Paquet non installé

note: type: Plain text
en: Protocol not available (POSIX.1)
fr: Protocole indisponible (POSIX.1)

note: type: Plain text
en: No space left on device (POSIX.1)
fr: Plus de place sur le périphérique (POSIX.1)

note: type: Plain text
en: No STREAM resources (POSIX.1 (XSI STREAMS option))
fr: Pas de ressources FLUX (POSIX.1 (option des FLUX XSI))

note: type: Plain text
en: Not a STREAM (POSIX.1 (XSI STREAMS option))
fr: Pas un FLUX (POSIX.1 (option des FLUX XSI))

note: type: Plain text
en: Function not implemented (POSIX.1)
fr: Fonction non implémentée (POSIX.1)

note: type: Plain text
en: Block device required
fr: Périphérique de bloc nécessaire

note: type: Plain text
en: The socket is not connected (POSIX.1)
fr: La socket n'est pas connectée (POSIX.1)

note: type: Plain text
en: Not a directory (POSIX.1)
fr: Pas un répertoire (POSIX.1)

note: ENOTNAM is defined but appears to be unused. type: Plain text
en: Directory not empty (POSIX.1)
fr: Répertoire non vide (POSIX.1)

note: type: Plain text
en: Not a socket (POSIX.1)
fr: Pas une socket (POSIX.1)

note: type: Plain text
en: Operation not supported (POSIX.1)
fr: Opération non supportée (POSIX.1)

note: type: Plain text
en: Inappropriate I/O control operation (POSIX.1)
fr: Opération de contrôle d'entrée/sortie invalide (POSIX.1)

note: type: Plain text
en: Name not unique on network
fr: Le nom sur le réseau n'est pas unique

note: type: Plain text
en: No such device or address (POSIX.1)
fr: Périphérique ou adresse inexistant (POSIX.1)

note: type: Plain text
en: Operation not supported on socket (POSIX.1)
fr: Opération non supportée par la socket (POSIX.1)

note: type: Plain text
en: (B<ENOTSUP> and B<EOPNOTSUPP> have the same value on Linux, but according to POSIX.1 these error values should be distinct.)
fr: (B<ENOTSUP> et B<EOPNOTSUPP> ont la même valeur sous Linux, mais selon POSIX.1, ces codes d'erreurs doivent être différents).

note: type: Plain text
en: Value too large to be stored in data type (POSIX.1)
fr: Valeur trop grande pour être sauvé dans ce type de donnée (POSIX.1)

note: type: Plain text
en: Operation not permitted (POSIX.1)
fr: Opération interdite (POSIX.1)

note: type: Plain text
en: Protocol family not supported
fr: Famille de protocole non supportée

note: type: Plain text
en: Broken pipe (POSIX.1)
fr: Tube cassé (POSIX.1)

note: type: Plain text
en: Protocol error (POSIX.1)
fr: Erreur de protocole (POSIX.1)

note: type: Plain text
en: Protocol not supported (POSIX.1)
fr: Protocole non supporté (POSIX.1)

note: type: Plain text
en: Protocol wrong type for socket (POSIX.1)
fr: Mauvais type de protocole pour la socket (POSIX.1)

note: type: Plain text
en: Result too large (POSIX.1, C99)
fr: Résultat trop grand (POSIX.1, C99)

note: type: Plain text
en: Remote address changed
fr: Adresse distante changée

note: type: Plain text
en: Object is remote
fr: L'objet est distant

note: type: Plain text
en: Remote I/O error
fr: Erreur d'entrées-sorties distante

note: type: Plain text
en: Interrupted system call should be restarted
fr: L'appel système interrompu devrait être relancé

note: type: Plain text
en: Read-only filesystem (POSIX.1)
fr: Système de fichiers en lecture seule (POSIX.1)

note: type: Plain text
en: Cannot send after transport endpoint shutdown
fr: Impossible d'effectuer l'envoi après l'arrêt du point final du transport

note: type: Plain text
en: Invalid seek (POSIX.1)
fr: Recherche invalide (POSIX.1)

note: type: Plain text
en: Socket type not supported
fr: Type de socket non supporté

note: ESRMNT is defined but appears not to be used type: Plain text
en: No such process (POSIX.1)
fr: Processus inexistant (POSIX.1)

note: type: Plain text
en: Stale file handle (POSIX.1)
fr: Vieux descripteur de fichier (POSIX.1)

note: type: Plain text
en: This error can occur for NFS and for other filesystems
fr: Cette erreur peut se produire avec le système de fichiers NFS et d'autres

note: type: Plain text
en: Streams pipe error
fr: Tube de flux cassé

note: type: Plain text
en: Timer expired (POSIX.1 (XSI STREAMS option))
fr: Compteur de temps écoulé (POSIX.1 (option des FLUX XSI))

note: type: Plain text
en: (POSIX.1 says "STREAM B<ioctl>(2)  timeout")
fr: (POSIX.1 dit «\ délai du FLUX B<ioctl>(2) dépassé)

note: ETOOMANYREFS is defined, but appears not to be used. type: Plain text
en: Connection timed out (POSIX.1)
fr: Délai maximal de connexion écoulé (POSIX.1)

note: type: Plain text
en: Text file busy (POSIX.1)
fr: Fichier texte occupé (POSIX.1)

note: type: Plain text
en: Structure needs cleaning
fr: La structure nécessite un nettoyage

note: type: Plain text
en: Protocol driver not attached
fr: Protocole indisponible

note: type: Plain text
en: Too many users
fr: Trop d'utilisateurs

note: type: Plain text
en: Operation would block (may be same value as B<EAGAIN>)  (POSIX.1)
fr: L'opération serait bloquante (peut être la même valeur que B<EAGAIN>) (POSIX.1)

note: type: Plain text
en: Improper link (POSIX.1)
fr: Lien inapproprié (POSIX.1)

note: type: Plain text
en: Exchange full
fr: Échange plein

note: type: Plain text
en: A common mistake is to do
fr: Une erreur fréquente est de faire

note: type: Plain text
en: where I<errno> no longer needs to have the value it had upon return from I<somecall>()  (i.e., it may have been changed by the B<printf>(3)).  If the value of I<errno> should be preserved across a library call, it must be saved:
fr: où I<errno> n'a plus besoin de la valeur qu'elle avait juste après le retour de I<somecall>() (par exemple, elle peut être changée par B<printf>(3)). Si la valeur de I<errno> doit être préservée à travers un appel bibliothèque, elle doit être sauvegardée\ :

note: type: Plain text
en: It was common in traditional C to declare I<errno> manually (i.e., I<extern int errno>)  instead of including I<E<lt>errno.hE<gt>>.  B<Do not do this>.  It will not work with modern versions of the C library.  However, on (very) old UNIX systems, there may be no I<E<lt>errno.hE<gt>> and the declaration is needed.
fr: C'est commun en C traditionnel de déclarer I<errno> manuellement (par exemple, I<extern int errno>) au lieu d'inclure I<E<lt>errno.hE<gt>>. B<Ne faites pas cela>. Cela ne fonctionnera pas avec les versions modernes des bibliothèque C. Toutefois, sur de (très) vieux systèmes UNIX, il peut ne pas y avoir de I<E<lt>errno.hE<gt>> et dans ce cas la déclaration est nécessaire.

note: type: TH
en: 2010-08-29
fr: 29 août 2010

note: type: Plain text
en: error, error_at_line, error_message_count, error_one_per_line, error_print_progname - glibc error reporting functions
fr: error, error_at_line, error_message_count, error_one_per_line, error_print_progname - Fonctions de compte-rendu d'erreurs de la glibc

note: type: Plain text
en: B<error>()  is a general error-reporting function.  It flushes I<stdout>, and then outputs to I<stderr> the program name, a colon and a space, the message specified by the B<printf>(3)-style format string I<format>, and, if I<errnum> is nonzero, a second colon and a space followed by the string given by I<strerror(errnum)>.  Any arguments required for I<format> should follow I<format> in the argument list.  The output is terminated by a newline character.
fr: B<error>() est une fonction générique de rapport d'erreurs. Elle vide I<stdout>, et affiche sur I<stderr>, le nom du programme, un caractère deux-points, une espace, le message spécifié par la chaîne I<format> dans le format B<printf>(3) et si I<errnum> est différent de zéro, un second caractère deux-points, une espace suivie du contenu de I<strerror(errnum)>. Tout argument de I<format> doit suivre I<format> dans la liste des arguments. L'affichage se termine par un retour à la ligne.

note: type: Plain text
en: The program name printed by B<error>()  is the value of the global variable B<program_invocation_name>(3).  I<program_invocation_name> initially has the same value as I<main>()'s I<argv[0]>.  The value of this variable can be modified to change the output of B<error>().
fr: Le nom du programme affiché par B<error>() est la valeur de la variable globale B<program_invocation_name>(3). I<program_invocation_name> est initialisée à la même valeur que l'argument I<argv[0]> de la fonction I<main>(). La valeur de cette variable peut être modifiée pour changer l'affichage de B<error>().

note: type: Plain text
en: If I<status> has a nonzero value, then B<error>()  calls B<exit>(3)  to terminate the program using the given value as the exit status.
fr: Si I<status> possède une valeur non nulle, alors B<error>() appelle B<exit>(3) afin de terminer le programme avec la valeur de retour donnée.

note: type: Plain text
en: The B<error_at_line>()  function is exactly the same as B<error>(), except for the addition of the arguments I<filename> and I<linenum>.  The output produced is as for B<error>(), except that after the program name are written: a colon, the value of I<filename>, a colon, and the value of I<linenum>.  The preprocessor values B<__LINE__> and B<__FILE__> may be useful when calling B<error_at_line>(), but other values can also be used.  For example, these arguments could refer to a location in an input file.
fr: La fonction B<error_at_line>() est identique à B<error>(), excepté les arguments supplémentaires I<filename> et I<linenum>. L'affichage produit est similaire à celui de B<error>(), excepté qu'après le nom du programme sont écrits «\ :\ », la valeur de I<filename>, «\ :\ » et la valeur de I<linenum>. Les paramètres B<__LINE__> et B<__FILE__> du préprocesseur peuvent être utiles lors de l'utilisation de B<error_at_line>(), mais d'autres valeurs peuvent aussi être utilisées. Par exemple, ces arguments peuvent faire référence à l'emplacement dans un fichier.

note: type: Plain text
en: If the global variable I<error_one_per_line> is set nonzero, a sequence of B<error_at_line>()  calls with the same value of I<filename> and I<linenum> will result in only one message (the first) being output.
fr: Si la variable globale I<error_one_per_line> est définie à une valeur non nulle, une séquence d'appels à B<error_at_line>() avec les mêmes valeurs de I<filename> et I<linenum> ne produira qu'un seul message de sortie (le premier).

note: type: Plain text
en: The global variable I<error_message_count> counts the number of messages that have been output by B<error>()  and B<error_at_line>().
fr: La variable globale I<error_message_count> compte le nombre de messages qui ont été affichés avec B<error>() et B<error_at_line>().

note: type: Plain text
en: If the global variable I<error_print_progname> is assigned the address of a function (i.e., is not NULL), then that function is called instead of prefixing the message with the program name and colon.  The function should print a suitable string to I<stderr>.
fr: Si la variable globale I<error_print_progname> est assignée à l'adresse d'une fonction (c'est-à-dire, différent de NULL), alors cette fonction est appelée au lieu de préfixer le message avec le nom du programme et «\ :\ ». La fonction doit affiché une chaîne de caractère sur I<stderr>.

note: type: Plain text
en: These functions and variables are GNU extensions, and should not be used in programs intended to be portable.
fr: Ces fonctions et ces variables sont des extensions GNU et ne doivent pas être utilisées pour des applications portables.
