# asctime

## PROLOG



           This manual page is part of the POSIX Programmer's Manual.  The
           Linux implementation of this interface may differ (consult the
           corresponding Linux manual page for details of Linux behavior), or
           the interface may not be implemented on Linux.
    


## NAME



           asctime, asctime_r — convert date and time to a string
    


## SYNOPSIS



           #include <time.h>
    
           char *asctime(const struct tm *_timeptr_);
           char *asctime_r(const struct tm *restrict _tm_ , char *restrict _buf_);
    


## DESCRIPTION



           For _asctime_(): The functionality described on this reference page
           is aligned with the ISO C standard. Any conflict between the
           requirements described here and the ISO C standard is
           unintentional. This volume of POSIX.1‐2017 defers to the ISO C
           standard.
    
           The _asctime_() function shall convert the broken-down time in the
           structure pointed to by _timeptr_ into a string in the form:
    
               Sun Sep 16 01:03:52 1973\n\0
    
           using the equivalent of the following algorithm:
    
               char *asctime(const struct tm *timeptr)
               {
                   static char wday_name[7][3] = {
                       "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
                   };
                   static char mon_name[12][3] = {
                       "Jan", "Feb", "Mar", "Apr", "May", "Jun",
                       "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
                   };
                   static char result[26];
    
                   sprintf(result, "%.3s %.3s%3d %.2d:%.2d:%.2d %d\n",
                       wday_name[timeptr->tm_wday],
                       mon_name[timeptr->tm_mon],
                       timeptr->tm_mday, timeptr->tm_hour,
                       timeptr->tm_min, timeptr->tm_sec,
                       1900 + timeptr->tm_year);
                   return result;
               }
    
           However, the behavior is undefined if _timeptr_ ->_tm_wday_ or
           _timeptr_ ->_tm_mon_ are not within the normal ranges as defined in
           _< time.h>_, or if _timeptr_ ->_tm_year_ exceeds {INT_MAX}-1990, or if the
           above algorithm would attempt to generate more than 26 bytes of
           output (including the terminating null).
    
           The **tm** structure is defined in the _< time.h>_ header.
    
           The _asctime_(), _ctime_(), _gmtime_(), and _localtime_() functions shall
           return values in one of two static objects: a broken-down time
           structure and an array of type **char**.  Execution of any of the
           functions may overwrite the information returned in either of
           these objects by any of the other functions.
    
           The _asctime_() function need not be thread-safe.
    
           The _asctime_r_() function shall convert the broken-down time in the
           structure pointed to by _tm_ into a string (of the same form as that
           returned by _asctime_(), and with the same undefined behavior when
           input or output is out of range) that is placed in the user-
           supplied buffer pointed to by _buf_ (which shall contain at least 26
           bytes) and then return _buf_.
    


## RETURN VALUE



           Upon successful completion, _asctime_() shall return a pointer to
           the string.  If the function is unsuccessful, it shall return
           NULL.
    
           Upon successful completion, _asctime_r_() shall return a pointer to
           a character string containing the date and time. This string is
           pointed to by the argument _buf_.  If the function is unsuccessful,
           it shall return NULL.
    


## ERRORS



           No errors are defined.
    
           _The following sections are informative._
    


## EXAMPLES



           None.
    


## APPLICATION USAGE



           These functions are included only for compatibility with older
           implementations. They have undefined behavior if the resulting
           string would be too long, so the use of these functions should be
           discouraged. On implementations that do not detect output string
           length overflow, it is possible to overflow the output buffers in
           such a way as to cause applications to fail, or possible system
           security violations. Also, these functions do not support
           localized date and time formats. To avoid these problems,
           applications should use _strftime_() to generate strings from
           broken-down times.
    
           Values for the broken-down time structure can be obtained by
           calling _gmtime_() or _localtime_().
    
           The _asctime_r_() function is thread-safe and shall return values in
           a user-supplied buffer instead of possibly using a static data
           area that may be overwritten by each call.
    


## RATIONALE



           The standard developers decided to mark the _asctime_() and
           _asctime_r_() functions obsolescent even though _asctime_() is in the
           ISO C standard due to the possibility of buffer overflow. The
           ISO C standard also provides the _strftime_() function which can be
           used to avoid these problems.
    


## FUTURE DIRECTIONS



           These functions may be removed in a future version.
    


* * *