src/strftime.c

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