time/strftime.c

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