time/strftime_l.c

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