time/strftime.c

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