time/strftime.c

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