src/strftime.c

   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 (&ltm);
 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 (&ltm);
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 (&lt, &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 (&lt, &gtm))
1181               break;
1182
1183             diff = tm_diff (&ltm, &gtm);
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 }