src/strftime.c

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