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