perkamon - en to fr translation catalogue (80 entries)

note: type: TH
en: 2022-10-09
fr: 9 octobre 2022

note: type: SH
en: NAME
fr: NOM

note: type: Plain text
en: asctime, ctime, gmtime, localtime, mktime, asctime_r, ctime_r, gmtime_r, localtime_r - transform date and time to broken-down time or ASCII
fr: asctime, ctime, gmtime, localtime, mktime, asctime_r, ctime_r, gmtime_r, localtime_r - Convertir des dates et des temps au format année/mois/jour ou au format ASCII

note: type: SH
en: LIBRARY
fr: BIBLIOTHÈQUE

note: type: Plain text
en: Standard C library (I<libc>, I<-lc>)
fr: Bibliothèque C standard (I<libc>, I<-lc>)

note: type: Plain text
en: B<char *asctime(const struct tm *>I<tm>B<);>
    B<char *asctime_r(const struct tm *restrict >I<tm>B<,>
    B<                    char >I<buf>B<[restrict 26]);>
fr: B<char *asctime(const struct tm *>I<tm>B<);>
    B<char *asctime_r(const struct tm *restrict >I<tm>B<,>
    B<                    char >I<tampon>B<[restrict 26]);>

note: type: Plain text
en: B<char *ctime(const time_t *>I<timep>B<);>
    B<char *ctime_r(const time_t *restrict >I<timep>B<,>
    B<                    char >I<buf>B<[restrict 26]);>
fr: B<char *ctime(const time_t *>I<timep>B<);>
    B<char *ctime_r(const time_t *restrict >I<timep>B<,>
    B<                    char >I<tampon>B<[restrict 26]);>

note: type: Plain text
en: B<struct tm *gmtime(const time_t *>I<timep>B<);>
    B<struct tm *gmtime_r(const time_t *restrict >I<timep>B<,>
    B<                    struct tm *restrict >I<result>B<);>
fr: B<struct tm *gmtime(const time_t *>I<timep>B<);>
    B<struct tm *gmtime_r(const time_t *restrict >I<timep>B<,>
    B<                    struct tm *restrict >I<résultat>B<);>

note: type: Plain text
en: B<struct tm *localtime(const time_t *>I<timep>B<);>
    B<struct tm *localtime_r(const time_t *restrict >I<timep>B<,>
    B<                    struct tm *restrict >I<result>B<);>
fr: B<struct tm *localtime(const time_t *>I<timep>B<);>
    B<struct tm *localtime_r(const time_t *restrict >I<timep>B<,>
    B<                    struct tm *restrict >I<résultat>B<);>

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 (consulter B<feature_test_macros>(7)) :

note: type: Plain text
en: B<asctime_r>(), B<ctime_r>(), B<gmtime_r>(), B<localtime_r>():
fr: B<asctime_r>(), B<ctime_r>(), B<gmtime_r>(), B<localtime_r>()\ :

note: type: Plain text
en:     _POSIX_C_SOURCE
            || /* Glibc E<lt>= 2.19: */ _BSD_SOURCE || _SVID_SOURCE
fr:     _POSIX_C_SOURCE
            || /* Versions de la Glibc E<lt>= 2.19: */ _BSD_SOURCE || _SVID_SOURCE

note: type: Plain text
en: The B<ctime>(), B<gmtime>(), and B<localtime>()  functions all take an argument of data type I<time_t>, which represents calendar time.  When interpreted as an absolute time value, it represents the number of seconds elapsed since the Epoch, 1970-01-01 00:00:00 +0000 (UTC).
fr: Les fonctions B<ctime>(), B<gmtime>() et B<localtime>() prennent toutes un paramètre de type I<time_t> qui représente un temps en secondes. Si l'on interprète ce paramètre comme une valeur absolue, il s'agit du nombre de secondes écoulées depuis l'époque POSIX, 1er janvier 1970 à 00:00:00 (UTC).

note: type: Plain text
en: The B<asctime>()  and B<mktime>()  functions both take an argument representing broken-down time, which is a representation separated into year, month, day, and so on.
fr: Les fonctions B<asctime>() et B<mktime>() utilisent toutes deux un paramètre représentant le temps dans un format humain, c'est-à-dire année, mois, jour, etc.

note: type: Plain text
en: Broken-down time is stored in the structure I<tm>, described in B<tm>(3type).
fr: La représentation humaine («\ broken-down time\ ») est stockée dans la structure I<tm> décrite dans B<tm>(3type).

note: type: Plain text
en: The call B<ctime(>I<t>B<)> is equivalent to B<asctime(localtime(>I<t>B<))>.  It converts the calendar time I<t> into a null-terminated string of the form
fr: L'appel B<ctime(>I<t>B<)> est équivalent à B<asctime(localtime(>I<t>B<))>. Il convertit le temps calendaire I<t> en une chaîne de caractères, terminée par un octet NULL de la forme

note: type: Plain text
en: The abbreviations for the days of the week are "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", and "Sat".  The abbreviations for the months are "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", and "Dec".  The return value points to a statically allocated string which might be overwritten by subsequent calls to any of the date and time functions.  The function also sets the external variables I<tzname>, I<timezone>, and I<daylight> (see B<tzset>(3))  with information about the current timezone.  The reentrant version B<ctime_r>()  does the same, but stores the string in a user-supplied buffer which should have room for at least 26 bytes.  It need not set I<tzname>, I<timezone>, and I<daylight>.
fr: Les abréviations des jours de la semaine sont «\ Sun\ », «\ Mon\ », «\ Tue\ », «\ Wed\ », «\ Thu\ », «\ Fri\ » et «\ Sat\ ». Les abréviations des mois sont «\ Jan\ », «\ Feb\ », «\ Mar\ », «\ Apr\ », «\ May\ », «\ Jun\ », «\ Jul\ », «\ Aug\ », «\ Sep\ », «\ Oct\ », «\ Nov\ » et «\ Dec\ ». La valeur renvoyée pointe sur une chaîne statiquement allouée qui sera écrasée à chaque appel ultérieur d'une fonction de date ou de temps. La fonction définit aussi les variables externes I<tzname>, I<timezone> et I<daylight> (consultez B<tzset>(3)) avec les informations du fuseau horaire. La version réentrante B<ctime_r>() effectue le même travail, mais stocke la chaîne dans un tampon d'une longueur minimale de 26 caractères fourni par l'utilisateur. Elle n'a pas besoin de définir I<tzname>, I<timezone> et I<daylight>.

note: type: Plain text
en: The B<gmtime>()  function converts the calendar time I<timep> to broken-down time representation, expressed in Coordinated Universal Time (UTC).  It may return NULL when the year does not fit into an integer.  The return value points to a statically allocated struct which might be overwritten by subsequent calls to any of the date and time functions.  The B<gmtime_r>()  function does the same, but stores the data in a user-supplied struct.
fr: La fonction B<gmtime>() convertit le temps calendaire I<timep> en une représentation humaine exprimée en temps universel (UTC). Elle peut renvoyer NULL quand l'année ne tient pas dans un entier. La valeur renvoyée pointe vers une structure allouée statiquement qui sera écrasée à chaque appel ultérieur d'une fonction de date ou de temps. La fonction réentrante B<gmtime_r>() effectue le même travail, mais stocke le résultat dans une structure fournie par l'utilisateur.

note: type: Plain text
en: The B<localtime>()  function converts the calendar time I<timep> to broken-down time representation, expressed relative to the user's specified timezone.  The function acts as if it called B<tzset>(3)  and sets the external variables I<tzname> with information about the current timezone, I<timezone> with the difference between Coordinated Universal Time (UTC) and local standard time in seconds, and I<daylight> to a nonzero value if daylight savings time rules apply during some part of the year.  The return value points to a statically allocated struct which might be overwritten by subsequent calls to any of the date and time functions.  The B<localtime_r>()  function does the same, but stores the data in a user-supplied struct.  It need not set I<tzname>, I<timezone>, and I<daylight>.
fr: La fonction B<localtime>() convertit le temps calendaire I<timep> en une représentation humaine exprimée en fonction du fuseau horaire de l'utilisateur. Cette fonction se comporte comme si elle appelait B<tzset>(3) et définit les variables externes I<tzname> avec les informations concernant le fuseau horaire, I<timezone> avec la différence (en secondes) entre le temps universel (UTC) et le temps local et I<daylight> avec une valeur non nulle si le décalage horaire saisonnier s'applique pendant une partie de l'année. La valeur renvoyée pointe vers une structure allouée statiquement qui sera écrasée à chaque appel ultérieur d'une fonction de date ou de temps. La fonction réentrante B<localtime_r>() effectue le même travail, mais stocke le résultat dans une structure fournie par l'utilisateur. Elle n'a pas besoin de définir I<tzname>, I<timezone>, et I<daylight>.

note: type: Plain text
en: The B<asctime>()  function converts the broken-down time value I<tm> into a null-terminated string with the same format as B<ctime>().  The return value points to a statically allocated string which might be overwritten by subsequent calls to any of the date and time functions.  The B<asctime_r>()  function does the same, but stores the string in a user-supplied buffer which should have room for at least 26 bytes.
fr: La fonction B<asctime>() convertit une date au format humain I<tm> en une chaîne de caractères terminée par un octet NULL dans le même format que B<ctime>(). La valeur renvoyée pointe sur une chaîne allouée statiquement qui sera écrasée à chaque appel d'une fonction de date et de temps. La version réentrante B<asctime_r>() effectue le même travail, mais stocke la chaîne dans un tampon d'une longueur minimale de 26 caractères fourni par l'utilisateur.

note: type: Plain text
en: The B<mktime>()  function converts a broken-down time structure, expressed as local time, to calendar time representation.  The function ignores the values supplied by the caller in the I<tm_wday> and I<tm_yday> fields.  The value specified in the I<tm_isdst> field informs B<mktime>()  whether or not daylight saving time (DST)  is in effect for the time supplied in the I<tm> structure: a positive value means DST is in effect; zero means that DST is not in effect; and a negative value means that B<mktime>()  should (use timezone information and system databases to)  attempt to determine whether DST is in effect at the specified time.
fr: La fonction B<mktime>() convertit une structure de temps au format humain exprimée sous forme d'un temps local en une représentation de temps calendaire. La fonction ignore les valeurs I<tm_wday> et I<tm_yday> fournies par l'appelant. La valeur fournie dans le champ I<tm_isdst> indique à B<mktime>() si le décalage horaire d'été (DST) est pris en compte dans le temps fourni dans la structure I<tm>\ : une valeur positive signifie que le décalage horaire d'été est effectif\ ; la valeur zéro signifie que le décalage horaire d'été n'est pas effectif\ ; une valeur négative signifie que B<mktime>() doit déterminer si le décalage horaire d'été est effectif dans le temps spécifié (en utilisant les informations de fuseaux horaires et les bases de données du système).

note: type: Plain text
en: The B<mktime>()  function modifies the fields of the I<tm> structure as follows: I<tm_wday> and I<tm_yday> are set to values determined from the contents of the other fields; if structure members are outside their valid interval, they will be normalized (so that, for example, 40 October is changed into 9 November); I<tm_isdst> is set (regardless of its initial value)  to a positive value or to 0, respectively, to indicate whether DST is or is not in effect at the specified time.  Calling B<mktime>()  also sets the external variable I<tzname> with information about the current timezone.
fr: La fonction B<mktime>() modifie des champs de la structure I<tm> comme suit\ : les valeurs de I<tm_wday> et I<tm_yday> sont déterminées à partir des valeurs des autres champs\ ; si la valeur d'un membre de la structure n'est pas dans un intervalle autorisé, elle sera normalisée (par exemple, le 40 octobre sera converti en 9 novembre)\ ; I<tm_isdst> est défini (indépendamment de sa valeur initiale) à une valeur positive si le décalage horaire d'été est effectif dans le temps spécifié, B<0> sinon. Un appel à B<mktime>() définit aussi la variable externe I<tzname> avec le fuseau horaire actuel.

note: type: Plain text
en: If the specified broken-down time cannot be represented as calendar time (seconds since the Epoch), B<mktime>()  returns I<(time_t)\ -1> and does not alter the members of the broken-down time structure.
fr: Si la représentation du temps au format humain spécifié ne peut pas être convertie au format calendaire (nombre de secondes depuis l'époque POSIX, 1er janvier 1970 à 00:00:00 (UTC)), B<mktime>() renvoie la valeur I<(time_t)\ -1> et ne modifie pas les membres de la structure du temps au format humain.

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

note: type: Plain text
en: On success, B<gmtime>()  and B<localtime>()  return a pointer to a I<struct\ tm>.
fr: S'ils réussissent, les appels B<gmtime>() et B<localtime>() renvoient un pointeur sur une I<struct\ tm>.

note: type: Plain text
en: On success, B<gmtime_r>()  and B<localtime_r>()  return the address of the structure pointed to by I<result>.
fr: S'ils réussissent, les appels B<gmtime_r>() et B<localtime_r>() renvoient l'adresse de la structure pointée par I<résultat>.

note: type: Plain text
en: On success, B<asctime>()  and B<ctime>()  return a pointer to a string.
fr: S'ils réussissent, les appels B<asctime>() et B<ctime>() renvoient un pointeur sur une chaîne.

note: type: Plain text
en: On success, B<asctime_r>()  and B<ctime_r>()  return a pointer to the string pointed to by I<buf>.
fr: S'ils réussissent, les appels B<asctime_r>() et B<ctime_r>() renvoient un pointeur sur la chaîne pointée par I<tampon>.

note: type: Plain text
en: On success, B<mktime>()  returns the calendar time (seconds since the Epoch), expressed as a value of type I<time_t>.
fr: S'il réussit, l'appel B<mktime>() renvoie le temps calendaire (nombre de secondes depuis l'époque POSIX, 1er janvier 1970 à 00:00:00 (UTC)) exprimé sous la forme d'une valeur de type I<time_t>.

note: type: Plain text
en: On error, B<mktime>()  returns the value I<(time_t)\ -1>.  The remaining functions return NULL on error.  On error, I<errno> is set to indicate the error.
fr: En cas d'erreur, I<errno> est définie pour indiquer l'erreur et toutes les fonctions renvoient NULL, sauf B<mktime>() qui renvoie la valeur I<(time_t)\ -1>.

note: type: SH
en: ERRORS
fr: ERREURS

note: type: Plain text
en: The result cannot be represented.
fr: Le résultat ne peut pas être représenté.

note: type: SH
en: ATTRIBUTES
fr: ATTRIBUTS

note: type: Plain text
en: For an explanation of the terms used in this section, see B<attributes>(7).
fr: Pour une explication des termes utilisés dans cette section, consulter B<attributes>(7).

note: type: tbl table
en: Attribute
fr: Attribut

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

note: type: tbl table
en: Thread safety
fr: Sécurité des threads

note: type: Plain text
en: POSIX.1-2001.  C89 and C99 specify B<asctime>(), B<ctime>(), B<gmtime>(), B<localtime>(), and B<mktime>().  POSIX.1-2008 marks B<asctime>(), B<asctime_r>(), B<ctime>(), and B<ctime_r>()  as obsolete, recommending the use of B<strftime>(3)  instead.
fr: POSIX.1-2001. C89 et C99 définissent B<asctime>(), B<ctime>(), B<gmtime>(), B<localtime>() et B<mktime>(). POSIX.1-2008 marque B<asctime>(), B<asctime_r>(), B<ctime>() et B<ctime_r>() comme étant obsolètes et recommande à la place l'utilisation de B<strftime>(3).

note: type: Plain text
en: POSIX doesn't specify the parameters of B<ctime_r>()  to be I<restrict>; that is specific to glibc.
fr: POSIX ne préconise pas I<restrict> pour les paramètres de B<ctime_r>() ; cela est spécifique à la glibc.

note: type: Plain text
en: The four functions B<asctime>(), B<ctime>(), B<gmtime>(), and B<localtime>()  return a pointer to static data and hence are not thread-safe.  The thread-safe versions, B<asctime_r>(), B<ctime_r>(), B<gmtime_r>(), and B<localtime_r>(), are specified by SUSv2.
fr: Les quatre fonctions B<asctime>(), B<ctime>(), B<gmtime>() et B<localtime>() renvoient un pointeur vers des données statiques et ne sont donc pas sûres dans un contexte multithread. Les versions sûres dans un contexte multithread, B<asctime_r>(), B<ctime_r>(), B<gmtime_r>() et B<localtime_r>() sont spécifiées dans SUSv2.

note: type: Plain text
en: POSIX.1-2001 says: "The B<asctime>(), B<ctime>(), B<gmtime>(), and B<localtime>()  functions shall return values in one of two static objects: a broken-down time structure and an array of type I<char>.  Execution of any of the functions may overwrite the information returned in either of these objects by any of the other functions." This can occur in the glibc implementation.
fr: POSIX.1-2001 indique : « Les fonctions B<asctime>(), B<ctime>(), B<gmtime>() et B<localtime>() retourneront les valeurs dans l'un de ces deux objets statiques : une structure de temps au format humain et un tableau de type I<char>. L'exécution de n'importe laquelle de ces fonctions peut écraser l'information renvoyée dans l'un ou l'autre de ces objets par n'importe quelle autre fonction ». Cela peut arriver dans l'implémentation de la glibc.

note: type: Plain text
en: In many implementations, including glibc, a 0 in I<tm_mday> is interpreted as meaning the last day of the preceding month.
fr: Dans beaucoup d'implémentations, dont la glibc, un B<0> dans I<tm_mday> est interprété comme le dernier jour du mois précédent.

note: See http://thread.gmane.org/gmane.comp.time.tz/2034/ type: Plain text
en: According to POSIX.1-2001, B<localtime>()  is required to behave as though B<tzset>(3)  was called, while B<localtime_r>()  does not have this requirement.  For portable code, B<tzset>(3)  should be called before B<localtime_r>().
fr: Selon POSIX.1-2001, B<localtime>() doit se comporter comme si B<tzset>(3) avait été appelée, alors que B<localtime_r>() n'est pas soumise à cette exigence. Pour un code portable, B<tzset>(3) doit être appelée avant B<localtime_r>().

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

note: type: TH
en: 2020-12-21
fr: 21 décembre 2020

note: type: TH
en: Linux Programmer's Manual
fr: Manuel du programmeur Linux

note: type: Plain text
en: B<char *asctime(const struct tm *>I<tm>B<);>
    B<char *asctime_r(const struct tm *>I<tm>B<, char *>I<buf>B<);>
fr: B<char *asctime(const struct tm *>I<tm>B<);>
    B<char *asctime_r(const struct tm *>I<tm>B<, char *>I<tampon>B<);>

note: type: Plain text
en: B<char *ctime(const time_t *>I<timep>B<);>
    B<char *ctime_r(const time_t *>I<timep>B<, char *>I<buf>B<);>
fr: B<char *ctime(const time_t *>I<timep>B<);>
    B<char *ctime_r(const time_t *>I<timep>B<, char *>I<tampon>B<);>

note: type: Plain text
en: B<struct tm *gmtime(const time_t *>I<timep>B<);>
    B<struct tm *gmtime_r(const time_t *>I<timep>B<, struct tm *>I<result>B<);>
fr: B<struct tm *gmtime(const time_t *>I<timep>B<);>
    B<struct tm *gmtime_r(const time_t *>I<timep>B<, struct tm *>I<résultat>B<);>

note: type: Plain text
en: B<struct tm *localtime(const time_t *>I<timep>B<);>
    B<struct tm *localtime_r(const time_t *>I<timep>B<, struct tm *>I<result>B<);>
fr: B<struct tm *localtime(const time_t *>I<timep>B<);>
    B<struct tm *localtime_r(const time_t *>I<timep>B<, struct tm *>I<résultat>B<);>

note: type: Plain text
en: _POSIX_C_SOURCE
        || /* Glibc versions E<lt>= 2.19: */ _BSD_SOURCE || _SVID_SOURCE
fr: _POSIX_C_SOURCE
        || /* Versions de la Glibc E<lt>= 2.19: */ _BSD_SOURCE || _SVID_SOURCE

note: type: Plain text
en: Broken-down time is stored in the structure I<tm>, which is defined in I<E<lt>time.hE<gt>> as follows:
fr: La représentation humaine («\ broken-down time\ ») est stockée dans une structure I<tm>, définie dans I<E<lt>time.hE<gt>> comme suit\ :

note: type: Plain text
en: struct tm {
        int tm_sec;    /* Seconds (0-60) */
        int tm_min;    /* Minutes (0-59) */
        int tm_hour;   /* Hours (0-23) */
        int tm_mday;   /* Day of the month (1-31) */
        int tm_mon;    /* Month (0-11) */
        int tm_year;   /* Year - 1900 */
        int tm_wday;   /* Day of the week (0-6, Sunday = 0) */
        int tm_yday;   /* Day in the year (0-365, 1 Jan = 0) */
        int tm_isdst;  /* Daylight saving time */
    };
fr: struct tm
    {
        int tm_sec;    /* secondes [0,60]                          */
        int tm_min;    /* minutes [0,59]                           */
        int tm_hour;   /* heures [0,23]                            */
        int tm_mday;   /* jour du mois [1,31]                      */
        int tm_mon;    /* mois [0,11]                              */
        int tm_year;   /* année - 1900                             */
        int tm_wday;   /* jour de la semaine [0,6] où Dimanche = 0 */
        int tm_yday;   /* jour de l'année [0,365] où 1er Jan = 0   */
        int tm_isdst;  /* décalage été/hiver                       */
    };

note: type: Plain text
en: The members of the I<tm> structure are:
fr: Les membres de la structure I<tm> sont\ :

note: type: Plain text
en: The number of seconds after the minute, normally in the range 0 to 59, but can be up to 60 to allow for leap seconds.
fr: Le nombre de secondes écoulées depuis le dernier changement de minute. Normalement dans l'intervalle 0 à 59, ce membre peut aller jusqu'à 60 pour les secondes de rattrapage.

note: type: Plain text
en: The number of minutes after the hour, in the range 0 to 59.
fr: Le nombre de minutes écoulées depuis le dernier changement d'heure, dans l'intervalle 0 à 59.

note: type: Plain text
en: The number of hours past midnight, in the range 0 to 23.
fr: Le nombre d'heures écoulées depuis minuit, dans l'intervalle 0 à 23.

note: type: Plain text
en: The day of the month, in the range 1 to 31.
fr: Le quantième du mois, dans l'intervalle 1 à 31.

note: type: Plain text
en: The number of months since January, in the range 0 to 11.
fr: Le nombre de mois écoulés depuis le début de l'année, dans l'intervalle 0 à 11.

note: type: Plain text
en: The number of years since 1900.
fr: Le nombre d'années écoulées depuis 1900.

note: type: Plain text
en: The number of days since Sunday, in the range 0 to 6.
fr: Le nombre de jours écoulés depuis dimanche, dans l'intervalle 0 à 6.

note: type: Plain text
en: The number of days since January 1, in the range 0 to 365.
fr: Le nombre de jours écoulés depuis le 1er janvier, dans l'intervalle 0 à 365.

note: type: Plain text
en: A flag that indicates whether daylight saving time is in effect at the time described.  The value is positive if daylight saving time is in effect, zero if it is not, and negative if the information is not available.
fr: Un drapeau indiquant si le décalage heure d'hiver, heure d'été est en cours au moment de l'appel. La valeur renvoyée est positive si le décalage est actif, nulle s'il ne l'est pas et négative si l'information n'est pas disponible.

note: type: Plain text
en: On error, B<mktime>()  returns the value I<(time_t)\ -1>.  The remaining functions return NULL on error.  On error, I<errno> is set to indicate the cause of the error.
fr: En cas d'erreur, toutes les fonctions renvoient NULL, sauf B<mktime>() qui renvoie la valeur I<(time_t)\ -1>. I<errno> est alors définie pour indiquer la cause de l'erreur.

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

note: type: Plain text
en: The glibc version of I<struct tm> has additional fields
fr: La structure I<tm> de la glibc possède des champs supplémentaires

note: type: Plain text
en: const char *tm_zone;      /* Timezone abbreviation */
fr: const char *tm_zone;  /* Abréviation du nom du fuseau horaire */

note: type: Plain text
en: defined when B<_BSD_SOURCE> was set before including I<E<lt>time.hE<gt>>.  This is a BSD extension, present in 4.3BSD-Reno.
fr: définis lorsque B<_BSD_SOURCE> est définie avant l'inclusion de I<E<lt>time.hE<gt>>. Cela est une extension BSD présente dans 4.3BSD-Reno.

note: type: Plain text
en: This page is part of release 5.10 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.10 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies et la dernière version de cette page peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.

note: type: TH
en: 2021-03-22
fr: 22 mars 2021

note: type: Plain text
en: B<char *asctime(const struct tm *>I<tm>B<);>
    B<char *asctime_r(const struct tm *restrict >I<tm>B<, char *restrict >I<buf>B<);>
fr: B<char *asctime(const struct tm *>I<tm>B<);>
    B<char *asctime_r(const struct tm *restrict >I<tm>B<, char *restrict >I<tampon>B<);>

note: type: Plain text
en: B<char *ctime(const time_t *>I<timep>B<);>
    B<char *ctime_r(const time_t *restrict >I<timep>B<, char *restrict >I<buf>B<);>
fr: B<char *ctime(const time_t *>I<timep>B<);>
    B<char *ctime_r(const time_t *restrict >I<timep>B<, char *restrict >I<tampon>B<);>

note: type: Plain text
en: long tm_gmtoff;           /* Seconds east of UTC */
    const char *tm_zone;      /* Timezone abbreviation */
fr: long  tm_gmtoff;      /* Secondes à l'est du temps universel */
    const char *tm_zone;  /* Abréviation du nom du fuseau horaire */

note: type: Plain text
en: This page is part of release 5.13 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.13 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies et la dernière version de cette page peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.

note: type: TH
en: 2017-09-15
fr: 15 septembre 2017

note: type: Plain text
en: The B<ctime>(), B<gmtime>()  and B<localtime>()  functions all take an argument of data type I<time_t>, which represents calendar time.  When interpreted as an absolute time value, it represents the number of seconds elapsed since the Epoch, 1970-01-01 00:00:00 +0000 (UTC).
fr: Les fonctions B<ctime>(), B<gmtime>() et B<localtime>() prennent toutes un paramètre de type I<time_t> qui représente un temps calendaire. Si l'on interprète ce paramètre comme une valeur absolue, il s'agit du nombre de secondes écoulées depuis l'époque POSIX, 1er janvier 1970 à 00:00:00 (UTC).

note: type: Plain text
en: The four functions B<asctime>(), B<ctime>(), B<gmtime>()  and B<localtime>()  return a pointer to static data and hence are not thread-safe.  The thread-safe versions, B<asctime_r>(), B<ctime_r>(), B<gmtime_r>()  and B<localtime_r>(), are specified by SUSv2.
fr: Les quatre fonctions B<asctime>(), B<ctime>(), B<gmtime>() et B<localtime>() renvoient un pointeur vers des données statiques et ne sont donc pas sûres dans un contexte multithread. Les versions sûres dans un contexte multithread, B<asctime_r>(), B<ctime_r>(), B<gmtime_r>() et B<localtime_r>() sont spécifiées dans SUSv2.

note: See http://thread.gmane.org/gmane.comp.time.tz/2034/ type: Plain text
en: According to POSIX.1-2004, B<localtime>()  is required to behave as though B<tzset>(3)  was called, while B<localtime_r>()  does not have this requirement.  For portable code, B<tzset>(3)  should be called before B<localtime_r>().
fr: Selon POSIX.1-2004, B<localtime>() doit se comporter comme si B<tzset>(3) avait été appelée, alors que B<localtime_r>() n'est pas soumise à cette exigence. Pour un code portable, B<tzset>(3) doit être appelée avant B<localtime_r>().

note: type: Plain text
en: This page is part of release 4.16 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 4.16 du projet I<man-pages> Linux. Une description du projet et des instructions pour signaler des anomalies et la dernière version de cette page peuvent être trouvées à l'adresse \%https://www.kernel.org/doc/man-pages/.

en: The number of minutes after the hour, in the range 0 to 59.
fr: Le nombre de minutes écoulées depuis le dernier changement d'heure, dans
