home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 5 Edit / 05-Edit.zip / e20313sr.zip / emacs / 20.3.1 / src / strftime.c < prev    next >
C/C++ Source or Header  |  1999-07-31  |  30KB  |  1,220 lines
  1. /* Copyright (C) 1991,92,93,94,95,96,97,98 Free Software Foundation, Inc.
  2.  
  3.    NOTE: The canonical source of this file is maintained with the GNU C Library.
  4.    Bugs can be reported to bug-glibc@gnu.org.
  5.  
  6.    This program is free software; you can redistribute it and/or modify it
  7.    under the terms of the GNU General Public License as published by the
  8.    Free Software Foundation; either version 2, or (at your option) any
  9.    later version.
  10.  
  11.    This program is distributed in the hope that it will be useful,
  12.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.    GNU General Public License for more details.
  15.  
  16.    You should have received a copy of the GNU General Public License
  17.    along with this program; if not, write to the Free Software
  18.    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19.    USA.  */
  20.  
  21. #ifdef HAVE_CONFIG_H
  22. # include <config.h>
  23. #endif
  24.  
  25. /* Some hosts need this in order to declare localtime_r properly.  */
  26. #ifndef _REENTRANT
  27. # define _REENTRANT 1
  28. #endif
  29.  
  30. #ifdef _LIBC
  31. # define HAVE_LIMITS_H 1
  32. # define HAVE_MBLEN 1
  33. # define HAVE_MBRLEN 1
  34. # define HAVE_STRUCT_ERA_ENTRY 1
  35. # define HAVE_TM_GMTOFF 1
  36. # define HAVE_TM_ZONE 1
  37. # define HAVE_TZNAME 1
  38. # define HAVE_TZSET 1
  39. # define MULTIBYTE_IS_FORMAT_SAFE 1
  40. # define STDC_HEADERS 1
  41. # include "../locale/localeinfo.h"
  42. #endif
  43.  
  44. #if defined emacs && !defined HAVE_BCOPY
  45. # define HAVE_MEMCPY 1
  46. #endif
  47.  
  48. #include <ctype.h>
  49. #include <sys/types.h>        /* Some systems define `time_t' here.  */
  50.  
  51. #ifdef TIME_WITH_SYS_TIME
  52. # include <sys/time.h>
  53. # include <time.h>
  54. #else
  55. # ifdef HAVE_SYS_TIME_H
  56. #  include <sys/time.h>
  57. # else
  58. #  include <time.h>
  59. # endif
  60. #endif
  61. #if HAVE_TZNAME
  62. extern char *tzname[];
  63. #endif
  64.  
  65. /* Do multibyte processing if multibytes are supported, unless
  66.    multibyte sequences are safe in formats.  Multibyte sequences are
  67.    safe if they cannot contain byte sequences that look like format
  68.    conversion specifications.  The GNU C Library uses UTF8 multibyte
  69.    encoding, which is safe for formats, but strftime.c can be used
  70.    with other C libraries that use unsafe encodings.  */
  71. #define DO_MULTIBYTE (HAVE_MBLEN && ! MULTIBYTE_IS_FORMAT_SAFE)
  72.  
  73. #if DO_MULTIBYTE
  74. # if HAVE_MBRLEN
  75. #  include <wchar.h>
  76. # else
  77.    /* Simulate mbrlen with mblen as best we can.  */
  78. #  define mbstate_t int
  79. #  define mbrlen(s, n, ps) mblen (s, n)
  80. #  define mbsinit(ps) (*(ps) == 0)
  81. # endif
  82.   static const mbstate_t mbstate_zero;
  83. #endif
  84.  
  85. #if HAVE_LIMITS_H
  86. # include <limits.h>
  87. #endif
  88.  
  89. #if STDC_HEADERS
  90. # include <stddef.h>
  91. # include <stdlib.h>
  92. # include <string.h>
  93. #else
  94. # ifndef HAVE_MEMCPY
  95. #  define memcpy(d, s, n) bcopy ((s), (d), (n))
  96. # endif
  97. #endif
  98.  
  99. #ifdef _LIBC
  100. # define MEMPCPY(d, s, n) __mempcpy (d, s, n)
  101. #else
  102. # ifndef HAVE_MEMPCPY
  103. #  define MEMPCPY(d, s, n) ((void *) ((char *) memcpy (d, s, n) + (n)))
  104. # endif
  105. #endif
  106.  
  107. #ifndef __P
  108. # if defined (__GNUC__) || (defined (__STDC__) && __STDC__)
  109. #  define __P(args) args
  110. # else
  111. #  define __P(args) ()
  112. # endif  /* GCC.  */
  113. #endif  /* Not __P.  */
  114.  
  115. #ifndef PTR
  116. # ifdef __STDC__
  117. #  define PTR void *
  118. # else
  119. #  define PTR char *
  120. # endif
  121. #endif
  122.  
  123. #ifndef CHAR_BIT
  124. # define CHAR_BIT 8
  125. #endif
  126.  
  127. #ifndef NULL
  128. # define NULL 0
  129. #endif
  130.  
  131. #define TYPE_SIGNED(t) ((t) -1 < 0)
  132.  
  133. /* Bound on length of the string representing an integer value of type t.
  134.    Subtract one for the sign bit if t is signed;
  135.    302 / 1000 is log10 (2) rounded up;
  136.    add one for integer division truncation;
  137.    add one more for a minus sign if t is signed.  */
  138. #define INT_STRLEN_BOUND(t) \
  139.   ((sizeof (t) * CHAR_BIT - TYPE_SIGNED (t)) * 302 / 100 + 1 + TYPE_SIGNED (t))
  140.  
  141. #define TM_YEAR_BASE 1900
  142.  
  143. #ifndef __isleap
  144. /* Nonzero if YEAR is a leap year (every 4 years,
  145.    except every 100th isn't, and every 400th is).  */
  146. # define __isleap(year)    \
  147.   ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
  148. #endif
  149.  
  150.  
  151. #ifdef _LIBC
  152. # define gmtime_r __gmtime_r
  153. # define localtime_r __localtime_r
  154. # define tzname __tzname
  155. # define tzset __tzset
  156. #else
  157. # if ! HAVE_LOCALTIME_R
  158. #  if ! HAVE_TM_GMTOFF
  159. /* Approximate gmtime_r as best we can in its absence.  */
  160. #   undef gmtime_r
  161. #   define gmtime_r my_gmtime_r
  162. static struct tm *gmtime_r __P ((const time_t *, struct tm *));
  163. static struct tm *
  164. gmtime_r (t, tp)
  165.      const time_t *t;
  166.      struct tm *tp;
  167. {
  168.   struct tm *l = gmtime (t);
  169.   if (! l)
  170.     return 0;
  171.   *tp = *l;
  172.   return tp;
  173. }
  174. #  endif /* ! HAVE_TM_GMTOFF */
  175.  
  176. /* Approximate localtime_r as best we can in its absence.  */
  177. #  undef localtime_r
  178. #  define localtime_r my_ftime_localtime_r
  179. static struct tm *localtime_r __P ((const time_t *, struct tm *));
  180. static struct tm *
  181. localtime_r (t, tp)
  182.      const time_t *t;
  183.      struct tm *tp;
  184. {
  185.   struct tm *l = localtime (t);
  186.   if (! l)
  187.     return 0;
  188.   *tp = *l;
  189.   return tp;
  190. }
  191. # endif /* ! HAVE_LOCALTIME_R */
  192. #endif /* ! defined _LIBC */
  193.  
  194.  
  195. #if !defined memset && !defined HAVE_MEMSET && !defined _LIBC
  196. /* Some systems lack the `memset' function and we don't want to
  197.    introduce additional dependencies.  */
  198. /* The SGI compiler reportedly barfs on the trailing null
  199.    if we use a string constant as the initializer.  28 June 1997, rms.  */
  200. static const char spaces[16] = /* "                " */
  201.   { ' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ' };
  202. static const char zeroes[16] = /* "0000000000000000" */
  203.   { '0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0' };
  204.  
  205. # define memset_space(P, Len) \
  206.   do {                                          \
  207.     int _len = (Len);                                  \
  208.                                           \
  209.     do                                          \
  210.       {                                          \
  211.     int _this = _len > 16 ? 16 : _len;                      \
  212.     (P) = MEMPCPY ((P), spaces, _this);                      \
  213.     _len -= _this;                                  \
  214.       }                                          \
  215.     while (_len > 0);                                  \
  216.   } while (0)
  217.  
  218. # define memset_zero(P, Len) \
  219.   do {                                          \
  220.     int _len = (Len);                                  \
  221.                                           \
  222.     do                                          \
  223.       {                                          \
  224.     int _this = _len > 16 ? 16 : _len;                      \
  225.     (P) = MEMPCPY ((P), zeroes, _this);                      \
  226.     _len -= _this;                                  \
  227.       }                                          \
  228.     while (_len > 0);                                  \
  229.   } while (0)
  230. #else
  231. # define memset_space(P, Len) (memset ((P), ' ', (Len)), (P) += (Len))
  232. # define memset_zero(P, Len) (memset ((P), '0', (Len)), (P) += (Len))
  233. #endif
  234.  
  235. #define add(n, f)                                  \
  236.   do                                          \
  237.     {                                          \
  238.       int _n = (n);                                  \
  239.       int _delta = width - _n;                              \
  240.       int _incr = _n + (_delta > 0 ? _delta : 0);                  \
  241.       if (i + _incr >= maxsize)                              \
  242.     return 0;                                  \
  243.       if (p)                                      \
  244.     {                                      \
  245.       if (_delta > 0)                              \
  246.         {                                      \
  247.           if (pad == '0')                              \
  248.         memset_zero (p, _delta);                      \
  249.           else                                  \
  250.         memset_space (p, _delta);                      \
  251.         }                                      \
  252.       f;                                      \
  253.       p += _n;                                  \
  254.     }                                      \
  255.       i += _incr;                                  \
  256.     } while (0)
  257.  
  258. #define cpy(n, s) \
  259.     add ((n),                                      \
  260.      if (to_lowcase)                              \
  261.        memcpy_lowcase (p, (s), _n);                          \
  262.      else if (to_uppcase)                              \
  263.        memcpy_uppcase (p, (s), _n);                          \
  264.      else                                      \
  265.        memcpy ((PTR) p, (PTR) (s), _n))
  266.  
  267.  
  268.  
  269. #ifdef _LIBC
  270. # define TOUPPER(Ch) toupper (Ch)
  271. # define TOLOWER(Ch) tolower (Ch)
  272. #else
  273. # define TOUPPER(Ch) (islower (Ch) ? toupper (Ch) : (Ch))
  274. # define TOLOWER(Ch) (isupper (Ch) ? tolower (Ch) : (Ch))
  275. #endif
  276. /* We don't use `isdigit' here since the locale dependent
  277.    interpretation is not what we want here.  We only need to accept
  278.    the arabic digits in the ASCII range.  One day there is perhaps a
  279.    more reliable way to accept other sets of digits.  */
  280. #define ISDIGIT(Ch) ((unsigned int) (Ch) - '0' <= 9)
  281.  
  282. static char *memcpy_lowcase __P ((char *dest, const char *src, size_t len));
  283.  
  284. static char *
  285. memcpy_lowcase (dest, src, len)
  286.      char *dest;
  287.      const char *src;
  288.      size_t len;
  289. {
  290.   while (len-- > 0)
  291.     dest[len] = TOLOWER ((unsigned char) src[len]);
  292.   return dest;
  293. }
  294.  
  295. static char *memcpy_uppcase __P ((char *dest, const char *src, size_t len));
  296.  
  297. static char *
  298. memcpy_uppcase (dest, src, len)
  299.      char *dest;
  300.      const char *src;
  301.      size_t len;
  302. {
  303.   while (len-- > 0)
  304.     dest[len] = TOUPPER ((unsigned char) src[len]);
  305.   return dest;
  306. }
  307.  
  308.  
  309. #if ! HAVE_TM_GMTOFF
  310. /* Yield the difference between *A and *B,
  311.    measured in seconds, ignoring leap seconds.  */
  312. # define tm_diff ftime_tm_diff
  313. static int tm_diff __P ((const struct tm *, const struct tm *));
  314. static int
  315. tm_diff (a, b)
  316.      const struct tm *a;
  317.      const struct tm *b;
  318. {
  319.   /* Compute intervening leap days correctly even if year is negative.
  320.      Take care to avoid int overflow in leap day calculations,
  321.      but it's OK to assume that A and B are close to each other.  */
  322.   int a4 = (a->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (a->tm_year & 3);
  323.   int b4 = (b->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (b->tm_year & 3);
  324.   int a100 = a4 / 25 - (a4 % 25 < 0);
  325.   int b100 = b4 / 25 - (b4 % 25 < 0);
  326.   int a400 = a100 >> 2;
  327.   int b400 = b100 >> 2;
  328.   int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
  329.   int years = a->tm_year - b->tm_year;
  330.   int days = (365 * years + intervening_leap_days
  331.           + (a->tm_yday - b->tm_yday));
  332.   return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
  333.         + (a->tm_min - b->tm_min))
  334.       + (a->tm_sec - b->tm_sec));
  335. }
  336. #endif /* ! HAVE_TM_GMTOFF */
  337.  
  338.  
  339.  
  340. /* The number of days from the first day of the first ISO week of this
  341.    year to the year day YDAY with week day WDAY.  ISO weeks start on
  342.    Monday; the first ISO week has the year's first Thursday.  YDAY may
  343.    be as small as YDAY_MINIMUM.  */
  344. #define ISO_WEEK_START_WDAY 1 /* Monday */
  345. #define ISO_WEEK1_WDAY 4 /* Thursday */
  346. #define YDAY_MINIMUM (-366)
  347. static int iso_week_days __P ((int, int));
  348. #ifdef __GNUC__
  349. __inline__
  350. #endif
  351. static int
  352. iso_week_days (yday, wday)
  353.      int yday;
  354.      int wday;
  355. {
  356.   /* Add enough to the first operand of % to make it nonnegative.  */
  357.   int big_enough_multiple_of_7 = (-YDAY_MINIMUM / 7 + 2) * 7;
  358.   return (yday
  359.       - (yday - wday + ISO_WEEK1_WDAY + big_enough_multiple_of_7) % 7
  360.       + ISO_WEEK1_WDAY - ISO_WEEK_START_WDAY);
  361. }
  362.  
  363.  
  364. #if !(defined _NL_CURRENT || HAVE_STRFTIME)
  365. static char const weekday_name[][10] =
  366.   {
  367.     "Sunday", "Monday", "Tuesday", "Wednesday",
  368.     "Thursday", "Friday", "Saturday"
  369.   };
  370. static char const month_name[][10] =
  371.   {
  372.     "January", "February", "March", "April", "May", "June",
  373.     "July", "August", "September", "October", "November", "December"
  374.   };
  375. #endif
  376.  
  377.  
  378. #ifdef emacs
  379. # define my_strftime emacs_strftime
  380. #else
  381. # define my_strftime strftime
  382. #endif
  383.  
  384. #if !defined _LIBC && HAVE_TZNAME && HAVE_TZSET
  385.   /* Solaris 2.5 tzset sometimes modifies the storage returned by localtime.
  386.      Work around this bug by copying *tp before it might be munged.  */
  387.   size_t _strftime_copytm __P ((char *, size_t, const char *,
  388.                     const struct tm *));
  389.   size_t
  390.   my_strftime (s, maxsize, format, tp)
  391.       char *s;
  392.       size_t maxsize;
  393.       const char *format;
  394.       const struct tm *tp;
  395.   {
  396.     struct tm tmcopy;
  397.     tmcopy = *tp;
  398.     return _strftime_copytm (s, maxsize, format, &tmcopy);
  399.   }
  400. # undef my_strftime
  401. # define my_strftime(S, Maxsize, Format, Tp) \
  402.   _strftime_copytm (S, Maxsize, Format, Tp)
  403. #endif
  404.  
  405.  
  406. /* Write information from TP into S according to the format
  407.    string FORMAT, writing no more that MAXSIZE characters
  408.    (including the terminating '\0') and returning number of
  409.    characters written.  If S is NULL, nothing will be written
  410.    anywhere, so to determine how many characters would be
  411.    written, use NULL for S and (size_t) UINT_MAX for MAXSIZE.  */
  412. size_t
  413. my_strftime (s, maxsize, format, tp)
  414.       char *s;
  415.       size_t maxsize;
  416.       const char *format;
  417.       const struct tm *tp;
  418. {
  419.   int hour12 = tp->tm_hour;
  420. #ifdef _NL_CURRENT
  421.   const char *const a_wkday = _NL_CURRENT (LC_TIME, ABDAY_1 + tp->tm_wday);
  422.   const char *const f_wkday = _NL_CURRENT (LC_TIME, DAY_1 + tp->tm_wday);
  423.   const char *const a_month = _NL_CURRENT (LC_TIME, ABMON_1 + tp->tm_mon);
  424.   const char *const f_month = _NL_CURRENT (LC_TIME, MON_1 + tp->tm_mon);
  425.   const char *const ampm = _NL_CURRENT (LC_TIME,
  426.                     hour12 > 11 ? PM_STR : AM_STR);
  427.   size_t aw_len = strlen (a_wkday);
  428.   size_t am_len = strlen (a_month);
  429.   size_t ap_len = strlen (ampm);
  430. #else
  431. # if !HAVE_STRFTIME
  432.   const char *const f_wkday = weekday_name[tp->tm_wday];
  433.   const char *const f_month = month_name[tp->tm_mon];
  434.   const char *const a_wkday = f_wkday;
  435.   const char *const a_month = f_month;
  436.   const char *const ampm = "AMPM" + 2 * (hour12 > 11);
  437.   size_t aw_len = 3;
  438.   size_t am_len = 3;
  439.   size_t ap_len = 2;
  440. # endif
  441. #endif
  442. #if defined _NL_CURRENT || !HAVE_STRFTIME
  443.   size_t wkday_len = strlen (f_wkday);
  444.   size_t month_len = strlen (f_month);
  445. #endif
  446.   const char *zone;
  447.   size_t zonelen;
  448.   size_t i = 0;
  449.   char *p = s;
  450.   const char *f;
  451.  
  452.   zone = NULL;
  453. #if HAVE_TM_ZONE
  454.   /* The POSIX test suite assumes that setting
  455.      the environment variable TZ to a new value before calling strftime()
  456.      will influence the result (the %Z format) even if the information in
  457.      TP is computed with a totally different time zone.
  458.      This is bogus: though POSIX allows bad behavior like this,
  459.      POSIX does not require it.  Do the right thing instead.  */
  460.   zone = (const char *) tp->tm_zone;
  461. #endif
  462. #if HAVE_TZNAME
  463.   /* POSIX.1 8.1.1 requires that whenever strftime() is called, the
  464.      time zone names contained in the external variable `tzname' shall
  465.      be set as if the tzset() function had been called.  */
  466. # if HAVE_TZSET
  467.   tzset ();
  468. # endif
  469.  
  470.   if (!(zone && *zone) && tp->tm_isdst >= 0)
  471.     zone = tzname[tp->tm_isdst];
  472. #endif
  473.   if (! zone)
  474.     zone = "";        /* POSIX.2 requires the empty string here.  */
  475.  
  476.   zonelen = strlen (zone);
  477.  
  478.   if (hour12 > 12)
  479.     hour12 -= 12;
  480.   else
  481.     if (hour12 == 0) hour12 = 12;
  482.  
  483.   for (f = format; *f != '\0'; ++f)
  484.     {
  485.       int pad = 0;        /* Padding for number ('-', '_', or 0).  */
  486.       int modifier;        /* Field modifier ('E', 'O', or 0).  */
  487.       int digits;        /* Max digits for numeric format.  */
  488.       int number_value;     /* Numeric value to be printed.  */
  489.       int negative_number;    /* 1 if the number is negative.  */
  490.       const char *subfmt;
  491.       char *bufp;
  492.       char buf[1 + (sizeof (int) < sizeof (time_t)
  493.             ? INT_STRLEN_BOUND (time_t)
  494.             : INT_STRLEN_BOUND (int))];
  495.       int width = -1;
  496.       int to_lowcase = 0;
  497.       int to_uppcase = 0;
  498.       int change_case = 0;
  499.       int format_char;
  500.  
  501. #if DO_MULTIBYTE
  502.  
  503.        switch (*f)
  504.     {
  505.     case '%':
  506.       break;
  507.  
  508.     case '\a': case '\b': case '\t': case '\n':
  509.     case '\v': case '\f': case '\r':
  510.     case ' ': case '!': case '"': case '#': case '&': case'\'':
  511.     case '(': case ')': case '*': case '+': case ',': case '-':
  512.     case '.': case '/': case '0': case '1': case '2': case '3':
  513.     case '4': case '5': case '6': case '7': case '8': case '9':
  514.     case ':': case ';': case '<': case '=': case '>': case '?':
  515.     case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
  516.     case 'G': case 'H': case 'I': case 'J': case 'K': case 'L':
  517.     case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R':
  518.     case 'S': case 'T': case 'U': case 'V': case 'W': case 'X':
  519.     case 'Y': case 'Z': case '[': case'\\': case ']': case '^':
  520.     case '_': case 'a': case 'b': case 'c': case 'd': case 'e':
  521.     case 'f': case 'g': case 'h': case 'i': case 'j': case 'k':
  522.     case 'l': case 'm': case 'n': case 'o': case 'p': case 'q':
  523.     case 'r': case 's': case 't': case 'u': case 'v': case 'w':
  524.     case 'x': case 'y': case 'z': case '{': case '|': case '}':
  525.     case '~':
  526.       /* The C Standard requires these 98 characters (plus '%') to
  527.          be in the basic execution character set.  None of these
  528.          characters can start a multibyte sequence, so they need
  529.          not be analyzed further.  */
  530.       add (1, *p = *f);
  531.       continue;
  532.  
  533.     default:
  534.       /* Copy this multibyte sequence until we reach its end, find
  535.          an error, or come back to the initial shift state.  */
  536.       {
  537.         mbstate_t mbstate = mbstate_zero;
  538.         size_t len = 0;
  539.  
  540.         do
  541.           {
  542.         size_t bytes = mbrlen (f + len, (size_t) -1, &mbstate);
  543.  
  544.         if (bytes == 0)
  545.           break;
  546.  
  547.         if (bytes == (size_t) -2 || bytes == (size_t) -1)
  548.           {
  549.             len++;
  550.             break;
  551.           }
  552.  
  553.         len += bytes;
  554.           }
  555.         while (! mbsinit (&mbstate));
  556.  
  557.         cpy (len, f);
  558.         continue;
  559.       }
  560.     }
  561.  
  562. #else /* ! DO_MULTIBYTE */
  563.  
  564.       /* Either multibyte encodings are not supported, or they are
  565.      safe for formats, so any non-'%' byte can be copied through.  */
  566.       if (*f != '%')
  567.     {
  568.       add (1, *p = *f);
  569.       continue;
  570.     }
  571.  
  572. #endif /* ! DO_MULTIBYTE */
  573.  
  574.       /* Check for flags that can modify a format.  */
  575.       while (1)
  576.     {
  577.       switch (*++f)
  578.         {
  579.           /* This influences the number formats.  */
  580.         case '_':
  581.         case '-':
  582.         case '0':
  583.           pad = *f;
  584.           continue;
  585.  
  586.           /* This changes textual output.  */
  587.         case '^':
  588.           to_uppcase = 1;
  589.           continue;
  590.         case '#':
  591.           change_case = 1;
  592.           continue;
  593.  
  594.         default:
  595.           break;
  596.         }
  597.       break;
  598.     }
  599.  
  600.       /* As a GNU extension we allow to specify the field width.  */
  601.       if (ISDIGIT (*f))
  602.     {
  603.       width = 0;
  604.       do
  605.         {
  606.           width *= 10;
  607.           width += *f - '0';
  608.           ++f;
  609.         }
  610.       while (ISDIGIT (*f));
  611.     }
  612.  
  613.       /* Check for modifiers.  */
  614.       switch (*f)
  615.     {
  616.     case 'E':
  617.     case 'O':
  618.       modifier = *f++;
  619.       break;
  620.  
  621.     default:
  622.       modifier = 0;
  623.       break;
  624.     }
  625.  
  626.       /* Now do the specified format.  */
  627.       format_char = *f;
  628.       switch (format_char)
  629.     {
  630. #define DO_NUMBER(d, v) \
  631.       digits = width == -1 ? d : width;                      \
  632.       number_value = v; goto do_number
  633. #define DO_NUMBER_SPACEPAD(d, v) \
  634.       digits = width == -1 ? d : width;                      \
  635.       number_value = v; goto do_number_spacepad
  636.  
  637.     case '%':
  638.       if (modifier != 0)
  639.         goto bad_format;
  640.       add (1, *p = *f);
  641.       break;
  642.  
  643.     case 'a':
  644.       if (modifier != 0)
  645.         goto bad_format;
  646.       if (change_case)
  647.         {
  648.           to_uppcase = 1;
  649.           to_lowcase = 0;
  650.         }
  651. #if defined _NL_CURRENT || !HAVE_STRFTIME
  652.       cpy (aw_len, a_wkday);
  653.       break;
  654. #else
  655.       goto underlying_strftime;
  656. #endif
  657.  
  658.     case 'A':
  659.       if (modifier != 0)
  660.         goto bad_format;
  661.       if (change_case)
  662.         {
  663.           to_uppcase = 1;
  664.           to_lowcase = 0;
  665.         }
  666. #if defined _NL_CURRENT || !HAVE_STRFTIME
  667.       cpy (wkday_len, f_wkday);
  668.       break;
  669. #else
  670.       goto underlying_strftime;
  671. #endif
  672.  
  673.     case 'b':
  674.     case 'h':        /* POSIX.2 extension.  */
  675.       if (modifier != 0)
  676.         goto bad_format;
  677. #if defined _NL_CURRENT || !HAVE_STRFTIME
  678.       cpy (am_len, a_month);
  679.       break;
  680. #else
  681.       goto underlying_strftime;
  682. #endif
  683.  
  684.     case 'B':
  685.       if (modifier != 0)
  686.         goto bad_format;
  687.       if (change_case)
  688.         {
  689.           to_uppcase = 1;
  690.           to_lowcase = 0;
  691.         }
  692. #if defined _NL_CURRENT || !HAVE_STRFTIME
  693.       cpy (month_len, f_month);
  694.       break;
  695. #else
  696.       goto underlying_strftime;
  697. #endif
  698.  
  699.     case 'c':
  700.       if (modifier == 'O')
  701.         goto bad_format;
  702. #ifdef _NL_CURRENT
  703.       if (! (modifier == 'E'
  704.          && *(subfmt = _NL_CURRENT (LC_TIME, ERA_D_T_FMT)) != '\0'))
  705.         subfmt = _NL_CURRENT (LC_TIME, D_T_FMT);
  706. #else
  707. # if HAVE_STRFTIME
  708.       goto underlying_strftime;
  709. # else
  710.       subfmt = "%a %b %e %H:%M:%S %Y";
  711. # endif
  712. #endif
  713.  
  714.     subformat:
  715.       {
  716.         char *old_start = p;
  717.         size_t len = my_strftime (NULL, maxsize - i, subfmt, tp);
  718.         if (len == 0 && *subfmt)
  719.           return 0;
  720.         add (len, my_strftime (p, maxsize - i, subfmt, tp));
  721.  
  722.         if (to_uppcase)
  723.           while (old_start < p)
  724.         {
  725.           *old_start = TOUPPER ((unsigned char) *old_start);
  726.           ++old_start;
  727.         }
  728.       }
  729.       break;
  730.  
  731. #if HAVE_STRFTIME && ! (defined _NL_CURRENT && HAVE_STRUCT_ERA_ENTRY)
  732.     underlying_strftime:
  733.       {
  734.         /* The relevant information is available only via the
  735.            underlying strftime implementation, so use that.  */
  736.         char ufmt[4];
  737.         char *u = ufmt;
  738.         char ubuf[1024]; /* enough for any single format in practice */
  739.         size_t len;
  740.         *u++ = '%';
  741.         if (modifier != 0)
  742.           *u++ = modifier;
  743.         *u++ = format_char;
  744.         *u = '\0';
  745.         len = strftime (ubuf, sizeof ubuf, ufmt, tp);
  746.         if (len == 0)
  747.           return 0;
  748.         cpy (len, ubuf);
  749.       }
  750.       break;
  751. #endif
  752.  
  753.     case 'C':        /* POSIX.2 extension.  */
  754.       if (modifier == 'O')
  755.         goto bad_format;
  756.       if (modifier == 'E')
  757.         {
  758. #if HAVE_STRUCT_ERA_ENTRY
  759.           struct era_entry *era = _nl_get_era_entry (tp);
  760.           if (era)
  761.         {
  762.           size_t len = strlen (era->name_fmt);
  763.           cpy (len, era->name_fmt);
  764.           break;
  765.         }
  766. #else
  767. # if HAVE_STRFTIME
  768.           goto underlying_strftime;
  769. # endif
  770. #endif
  771.         }
  772.  
  773.       {
  774.         int year = tp->tm_year + TM_YEAR_BASE;
  775.         DO_NUMBER (1, year / 100 - (year % 100 < 0));
  776.       }
  777.  
  778.     case 'x':
  779.       if (modifier == 'O')
  780.         goto bad_format;
  781. #ifdef _NL_CURRENT
  782.       if (! (modifier == 'E'
  783.          && *(subfmt = _NL_CURRENT (LC_TIME, ERA_D_FMT)) != '\0'))
  784.         subfmt = _NL_CURRENT (LC_TIME, D_FMT);
  785.       goto subformat;
  786. #else
  787. # if HAVE_STRFTIME
  788.       goto underlying_strftime;
  789. # else
  790.       /* Fall through.  */
  791. # endif
  792. #endif
  793.     case 'D':        /* POSIX.2 extension.  */
  794.       if (modifier != 0)
  795.         goto bad_format;
  796.       subfmt = "%m/%d/%y";
  797.       goto subformat;
  798.  
  799.     case 'd':
  800.       if (modifier == 'E')
  801.         goto bad_format;
  802.  
  803.       DO_NUMBER (2, tp->tm_mday);
  804.  
  805.     case 'e':        /* POSIX.2 extension.  */
  806.       if (modifier == 'E')
  807.         goto bad_format;
  808.  
  809.       DO_NUMBER_SPACEPAD (2, tp->tm_mday);
  810.  
  811.       /* All numeric formats set DIGITS and NUMBER_VALUE and then
  812.          jump to one of these two labels.  */
  813.  
  814.     do_number_spacepad:
  815.       /* Force `_' flag unless overwritten by `0' flag.  */
  816.       if (pad != '0')
  817.         pad = '_';
  818.  
  819.     do_number:
  820.       /* Format the number according to the MODIFIER flag.  */
  821.  
  822.       if (modifier == 'O' && 0 <= number_value)
  823.         {
  824. #ifdef _NL_CURRENT
  825.           /* Get the locale specific alternate representation of
  826.          the number NUMBER_VALUE.  If none exist NULL is returned.  */
  827.           const char *cp = _nl_get_alt_digit (number_value);
  828.  
  829.           if (cp != NULL)
  830.         {
  831.           size_t digitlen = strlen (cp);
  832.           if (digitlen != 0)
  833.             {
  834.               cpy (digitlen, cp);
  835.               break;
  836.             }
  837.         }
  838. #else
  839. # if HAVE_STRFTIME
  840.           goto underlying_strftime;
  841. # endif
  842. #endif
  843.         }
  844.       {
  845.         unsigned int u = number_value;
  846.  
  847.         bufp = buf + sizeof (buf);
  848.         negative_number = number_value < 0;
  849.  
  850.         if (negative_number)
  851.           u = -u;
  852.  
  853.         do
  854.           *--bufp = u % 10 + '0';
  855.         while ((u /= 10) != 0);
  856.         }
  857.  
  858.     do_number_sign_and_padding:
  859.       if (negative_number)
  860.         *--bufp = '-';
  861.  
  862.       if (pad != '-')
  863.         {
  864.           int padding = digits - (buf + sizeof (buf) - bufp);
  865.  
  866.           if (pad == '_')
  867.         {
  868.           while (0 < padding--)
  869.             *--bufp = ' ';
  870.         }
  871.           else
  872.         {
  873.           bufp += negative_number;
  874.           while (0 < padding--)
  875.             *--bufp = '0';
  876.           if (negative_number)
  877.             *--bufp = '-';
  878.         }
  879.         }
  880.  
  881.       cpy (buf + sizeof (buf) - bufp, bufp);
  882.       break;
  883.  
  884.     case 'F':
  885.       if (modifier != 0)
  886.         goto bad_format;
  887.       subfmt = "%Y-%m-%d";
  888.       goto subformat;
  889.  
  890.     case 'H':
  891.       if (modifier == 'E')
  892.         goto bad_format;
  893.  
  894.       DO_NUMBER (2, tp->tm_hour);
  895.  
  896.     case 'I':
  897.       if (modifier == 'E')
  898.         goto bad_format;
  899.  
  900.       DO_NUMBER (2, hour12);
  901.  
  902.     case 'k':        /* GNU extension.  */
  903.       if (modifier == 'E')
  904.         goto bad_format;
  905.  
  906.       DO_NUMBER_SPACEPAD (2, tp->tm_hour);
  907.  
  908.     case 'l':        /* GNU extension.  */
  909.       if (modifier == 'E')
  910.         goto bad_format;
  911.  
  912.       DO_NUMBER_SPACEPAD (2, hour12);
  913.  
  914.     case 'j':
  915.       if (modifier == 'E')
  916.         goto bad_format;
  917.  
  918.       DO_NUMBER (3, 1 + tp->tm_yday);
  919.  
  920.     case 'M':
  921.       if (modifier == 'E')
  922.         goto bad_format;
  923.  
  924.       DO_NUMBER (2, tp->tm_min);
  925.  
  926.     case 'm':
  927.       if (modifier == 'E')
  928.         goto bad_format;
  929.  
  930.       DO_NUMBER (2, tp->tm_mon + 1);
  931.  
  932.     case 'n':        /* POSIX.2 extension.  */
  933.       add (1, *p = '\n');
  934.       break;
  935.  
  936.     case 'P':
  937.       to_lowcase = 1;
  938. #if !defined _NL_CURRENT && HAVE_STRFTIME
  939.       format_char = 'p';
  940. #endif
  941.       /* FALLTHROUGH */
  942.  
  943.     case 'p':
  944.       if (change_case)
  945.         {
  946.           to_uppcase = 0;
  947.           to_lowcase = 1;
  948.         }
  949. #if defined _NL_CURRENT || !HAVE_STRFTIME
  950.       cpy (ap_len, ampm);
  951.       break;
  952. #else
  953.       goto underlying_strftime;
  954. #endif
  955.  
  956.     case 'R':        /* GNU extension.  */
  957.       subfmt = "%H:%M";
  958.       goto subformat;
  959.  
  960.     case 'r':        /* POSIX.2 extension.  */
  961. #ifdef _NL_CURRENT
  962.       if (*(subfmt = _NL_CURRENT (LC_TIME, T_FMT_AMPM)) == '\0')
  963. #endif
  964.         subfmt = "%I:%M:%S %p";
  965.       goto subformat;
  966.  
  967.     case 'S':
  968.       if (modifier == 'E')
  969.         goto bad_format;
  970.  
  971.       DO_NUMBER (2, tp->tm_sec);
  972.  
  973.     case 's':        /* GNU extension.  */
  974.         {
  975.         struct tm ltm;
  976.         time_t t;
  977.  
  978.         ltm = *tp;
  979.         t = mktime (<m);
  980.  
  981.         /* Generate string value for T using time_t arithmetic;
  982.            this works even if sizeof (long) < sizeof (time_t).  */
  983.  
  984.         bufp = buf + sizeof (buf);
  985.         negative_number = t < 0;
  986.  
  987.         do
  988.           {
  989.         int d = t % 10;
  990.         t /= 10;
  991.  
  992.         if (negative_number)
  993.           {
  994.             d = -d;
  995.  
  996.             /* Adjust if division truncates to minus infinity.  */
  997.             if (0 < -1 % 10 && d < 0)
  998.               {
  999.             t++;
  1000.             d += 10;
  1001.               }
  1002.           }
  1003.  
  1004.         *--bufp = d + '0';
  1005.           }
  1006.         while (t != 0);
  1007.  
  1008.         digits = 1;
  1009.         goto do_number_sign_and_padding;
  1010.       }
  1011.  
  1012.     case 'X':
  1013.       if (modifier == 'O')
  1014.         goto bad_format;
  1015. #ifdef _NL_CURRENT
  1016.       if (! (modifier == 'E'
  1017.          && *(subfmt = _NL_CURRENT (LC_TIME, ERA_T_FMT)) != '\0'))
  1018.         subfmt = _NL_CURRENT (LC_TIME, T_FMT);
  1019.       goto subformat;
  1020. #else
  1021. # if HAVE_STRFTIME
  1022.       goto underlying_strftime;
  1023. # else
  1024.       /* Fall through.  */
  1025. # endif
  1026. #endif
  1027.     case 'T':        /* POSIX.2 extension.  */
  1028.       subfmt = "%H:%M:%S";
  1029.       goto subformat;
  1030.  
  1031.     case 't':        /* POSIX.2 extension.  */
  1032.       add (1, *p = '\t');
  1033.       break;
  1034.  
  1035.     case 'f':
  1036.     case 'u':        /* POSIX.2 extension.  */
  1037.       DO_NUMBER (1, (tp->tm_wday - 1 + 7) % 7 + 1);
  1038.  
  1039.     case 'U':
  1040.       if (modifier == 'E')
  1041.         goto bad_format;
  1042.  
  1043.       DO_NUMBER (2, (tp->tm_yday - tp->tm_wday + 7) / 7);
  1044.  
  1045.     case 'V':
  1046.     case 'g':        /* GNU extension.  */
  1047.     case 'G':        /* GNU extension.  */
  1048.       if (modifier == 'E')
  1049.         goto bad_format;
  1050.       {
  1051.         int year = tp->tm_year + TM_YEAR_BASE;
  1052.         int days = iso_week_days (tp->tm_yday, tp->tm_wday);
  1053.  
  1054.         if (days < 0)
  1055.           {
  1056.         /* This ISO week belongs to the previous year.  */
  1057.         year--;
  1058.         days = iso_week_days (tp->tm_yday + (365 + __isleap (year)),
  1059.                       tp->tm_wday);
  1060.           }
  1061.         else
  1062.           {
  1063.         int d = iso_week_days (tp->tm_yday - (365 + __isleap (year)),
  1064.                        tp->tm_wday);
  1065.         if (0 <= d)
  1066.           {
  1067.             /* This ISO week belongs to the next year.  */
  1068.             year++;
  1069.             days = d;
  1070.           }
  1071.           }
  1072.  
  1073.         switch (*f)
  1074.           {
  1075.           case 'g':
  1076.         DO_NUMBER (2, (year % 100 + 100) % 100);
  1077.  
  1078.           case 'G':
  1079.         DO_NUMBER (1, year);
  1080.  
  1081.           default:
  1082.         DO_NUMBER (2, days / 7 + 1);
  1083.           }
  1084.       }
  1085.  
  1086.     case 'W':
  1087.       if (modifier == 'E')
  1088.         goto bad_format;
  1089.  
  1090.       DO_NUMBER (2, (tp->tm_yday - (tp->tm_wday - 1 + 7) % 7 + 7) / 7);
  1091.  
  1092.     case 'w':
  1093.       if (modifier == 'E')
  1094.         goto bad_format;
  1095.  
  1096.       DO_NUMBER (1, tp->tm_wday);
  1097.  
  1098.     case 'Y':
  1099.       if (modifier == 'E')
  1100.         {
  1101. #if HAVE_STRUCT_ERA_ENTRY
  1102.           struct era_entry *era = _nl_get_era_entry (tp);
  1103.           if (era)
  1104.         {
  1105.           subfmt = strchr (era->name_fmt, '\0') + 1;
  1106.           goto subformat;
  1107.         }
  1108. #else
  1109. # if HAVE_STRFTIME
  1110.           goto underlying_strftime;
  1111. # endif
  1112. #endif
  1113.         }
  1114.       if (modifier == 'O')
  1115.         goto bad_format;
  1116.       else
  1117.         DO_NUMBER (1, tp->tm_year + TM_YEAR_BASE);
  1118.  
  1119.     case 'y':
  1120.       if (modifier == 'E')
  1121.         {
  1122. #if HAVE_STRUCT_ERA_ENTRY
  1123.           struct era_entry *era = _nl_get_era_entry (tp);
  1124.           if (era)
  1125.         {
  1126.           int delta = tp->tm_year - era->start_date[0];
  1127.           DO_NUMBER (1, (era->offset
  1128.                  + (era->direction == '-' ? -delta : delta)));
  1129.         }
  1130. #else
  1131. # if HAVE_STRFTIME
  1132.           goto underlying_strftime;
  1133. # endif
  1134. #endif
  1135.         }
  1136.       DO_NUMBER (2, (tp->tm_year % 100 + 100) % 100);
  1137.  
  1138.     case 'Z':
  1139.       if (change_case)
  1140.         {
  1141.           to_uppcase = 0;
  1142.           to_lowcase = 1;
  1143.         }
  1144.       cpy (zonelen, zone);
  1145.       break;
  1146.  
  1147.     case 'z':        /* GNU extension.  */
  1148.       if (tp->tm_isdst < 0)
  1149.         break;
  1150.  
  1151.       {
  1152.         int diff;
  1153. #if HAVE_TM_GMTOFF
  1154.         diff = tp->tm_gmtoff;
  1155. #else
  1156.         struct tm gtm;
  1157.         struct tm ltm;
  1158.         time_t lt;
  1159.  
  1160.         ltm = *tp;
  1161.         lt = mktime (<m);
  1162.  
  1163.         if (lt == (time_t) -1)
  1164.           {
  1165.         /* mktime returns -1 for errors, but -1 is also a
  1166.            valid time_t value.  Check whether an error really
  1167.            occurred.  */
  1168.         struct tm tm;
  1169.  
  1170.         if (! localtime_r (<, &tm)
  1171.             || ((ltm.tm_sec ^ tm.tm_sec)
  1172.             | (ltm.tm_min ^ tm.tm_min)
  1173.             | (ltm.tm_hour ^ tm.tm_hour)
  1174.             | (ltm.tm_mday ^ tm.tm_mday)
  1175.             | (ltm.tm_mon ^ tm.tm_mon)
  1176.             | (ltm.tm_year ^ tm.tm_year)))
  1177.           break;
  1178.           }
  1179.  
  1180.         if (! gmtime_r (<, >m))
  1181.           break;
  1182.  
  1183.         diff = tm_diff (<m, >m);
  1184. #endif
  1185.  
  1186.         if (diff < 0)
  1187.           {
  1188.         add (1, *p = '-');
  1189.         diff = -diff;
  1190.           }
  1191.         else
  1192.           add (1, *p = '+');
  1193.  
  1194.         diff /= 60;
  1195.         DO_NUMBER (4, (diff / 60) * 100 + diff % 60);
  1196.       }
  1197.  
  1198.     case '\0':        /* GNU extension: % at end of format.  */
  1199.         --f;
  1200.         /* Fall through.  */
  1201.     default:
  1202.       /* Unknown format; output the format, including the '%',
  1203.          since this is most likely the right thing to do if a
  1204.          multibyte string has been misparsed.  */
  1205.     bad_format:
  1206.       {
  1207.         int flen;
  1208.         for (flen = 1; f[1 - flen] != '%'; flen++)
  1209.           continue;
  1210.         cpy (flen, &f[1 - flen]);
  1211.       }
  1212.       break;
  1213.     }
  1214.     }
  1215.  
  1216.   if (p)
  1217.     *p = '\0';
  1218.   return i;
  1219. }
  1220.