src/strftime.c

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