time/strftime_l.c

   1 /* Copyright (C) 2002-2016 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           digits = d > width ? d : width;                                     \
 720           number_value = v; goto do_number
 721 #define DO_NUMBER_SPACEPAD(d, v) \
 722           digits = d > width ? d : width;                                     \
 723           number_value = v; goto do_number_spacepad
 724
 725         case L_('%'):
 726           if (modifier != 0)
 727             goto bad_format;
 728           add (1, *p = *f);
 729           break;
 730
 731         case L_('a'):
 732           if (modifier != 0)
 733             goto bad_format;
 734           if (change_case)
 735             {
 736               to_uppcase = 1;
 737               to_lowcase = 0;
 738             }
 739 #if defined _NL_CURRENT || !HAVE_STRFTIME
 740           cpy (aw_len, a_wkday);
 741           break;
 742 #else
 743           goto underlying_strftime;
 744 #endif
 745
 746         case 'A':
 747           if (modifier != 0)
 748             goto bad_format;
 749           if (change_case)
 750             {
 751               to_uppcase = 1;
 752               to_lowcase = 0;
 753             }
 754 #if defined _NL_CURRENT || !HAVE_STRFTIME
 755           cpy (STRLEN (f_wkday), f_wkday);
 756           break;
 757 #else
 758           goto underlying_strftime;
 759 #endif
 760
 761         case L_('b'):
 762         case L_('h'):
 763           if (change_case)
 764             {
 765               to_uppcase = 1;
 766               to_lowcase = 0;
 767             }
 768           if (modifier != 0)
 769             goto bad_format;
 770 #if defined _NL_CURRENT || !HAVE_STRFTIME
 771           cpy (am_len, a_month);
 772           break;
 773 #else
 774           goto underlying_strftime;
 775 #endif
 776
 777         case L_('B'):
 778           if (modifier != 0)
 779             goto bad_format;
 780           if (change_case)
 781             {
 782               to_uppcase = 1;
 783               to_lowcase = 0;
 784             }
 785 #if defined _NL_CURRENT || !HAVE_STRFTIME
 786           cpy (STRLEN (f_month), f_month);
 787           break;
 788 #else
 789           goto underlying_strftime;
 790 #endif
 791
 792         case L_('c'):
 793           if (modifier == L_('O'))
 794             goto bad_format;
 795 #ifdef _NL_CURRENT
 796           if (! (modifier == 'E'
 797                  && (*(subfmt =
 798                        (const CHAR_T *) _NL_CURRENT (LC_TIME,
 799                                                      NLW(ERA_D_T_FMT)))
 800                      != '\0')))
 801             subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_T_FMT));
 802 #else
 803 # if HAVE_STRFTIME
 804           goto underlying_strftime;
 805 # else
 806           subfmt = L_("%a %b %e %H:%M:%S %Y");
 807 # endif
 808 #endif
 809
 810         subformat:
 811           {
 812             CHAR_T *old_start = p;
 813             size_t len = __strftime_internal (NULL, (size_t) -1, subfmt,
 814                                               tp, tzset_called ut_argument
 815                                               LOCALE_ARG);
 816             add (len, __strftime_internal (p, maxsize - i, subfmt,
 817                                            tp, tzset_called ut_argument
 818                                            LOCALE_ARG));
 819
 820             if (to_uppcase)
 821               while (old_start < p)
 822                 {
 823                   *old_start = TOUPPER ((UCHAR_T) *old_start, loc);
 824                   ++old_start;
 825                 }
 826           }
 827           break;
 828
 829 #if HAVE_STRFTIME && ! (defined _NL_CURRENT && HAVE_STRUCT_ERA_ENTRY)
 830         underlying_strftime:
 831           {
 832             /* The relevant information is available only via the
 833                underlying strftime implementation, so use that.  */
 834             char ufmt[4];
 835             char *u = ufmt;
 836             char ubuf[1024]; /* enough for any single format in practice */
 837             size_t len;
 838             /* Make sure we're calling the actual underlying strftime.
 839                In some cases, config.h contains something like
 840                "#define strftime rpl_strftime".  */
 841 # ifdef strftime
 842 #  undef strftime
 843             size_t strftime ();
 844 # endif
 845
 846             *u++ = '%';
 847             if (modifier != 0)
 848               *u++ = modifier;
 849             *u++ = format_char;
 850             *u = '\0';
 851             len = strftime (ubuf, sizeof ubuf, ufmt, tp);
 852             if (len == 0 && ubuf[0] != '\0')
 853               return 0;
 854             cpy (len, ubuf);
 855           }
 856           break;
 857 #endif
 858
 859         case L_('C'):
 860           if (modifier == L_('E'))
 861             {
 862 #if HAVE_STRUCT_ERA_ENTRY
 863               struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
 864               if (era)
 865                 {
 866 # ifdef COMPILE_WIDE
 867                   size_t len = __wcslen (era->era_wname);
 868                   cpy (len, era->era_wname);
 869 # else
 870                   size_t len = strlen (era->era_name);
 871                   cpy (len, era->era_name);
 872 # endif
 873                   break;
 874                 }
 875 #else
 876 # if HAVE_STRFTIME
 877               goto underlying_strftime;
 878 # endif
 879 #endif
 880             }
 881
 882           {
 883             int year = tp->tm_year + TM_YEAR_BASE;
 884             DO_NUMBER (1, year / 100 - (year % 100 < 0));
 885           }
 886
 887         case L_('x'):
 888           if (modifier == L_('O'))
 889             goto bad_format;
 890 #ifdef _NL_CURRENT
 891           if (! (modifier == L_('E')
 892                  && (*(subfmt =
 893                        (const CHAR_T *)_NL_CURRENT (LC_TIME, NLW(ERA_D_FMT)))
 894                      != L_('\0'))))
 895             subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_FMT));
 896           goto subformat;
 897 #else
 898 # if HAVE_STRFTIME
 899           goto underlying_strftime;
 900 # else
 901           /* Fall through.  */
 902 # endif
 903 #endif
 904         case L_('D'):
 905           if (modifier != 0)
 906             goto bad_format;
 907           subfmt = L_("%m/%d/%y");
 908           goto subformat;
 909
 910         case L_('d'):
 911           if (modifier == L_('E'))
 912             goto bad_format;
 913
 914           DO_NUMBER (2, tp->tm_mday);
 915
 916         case L_('e'):
 917           if (modifier == L_('E'))
 918             goto bad_format;
 919
 920           DO_NUMBER_SPACEPAD (2, tp->tm_mday);
 921
 922           /* All numeric formats set DIGITS and NUMBER_VALUE and then
 923              jump to one of these two labels.  */
 924
 925         do_number_spacepad:
 926           /* Force `_' flag unless overwritten by `0' or '-' flag.  */
 927           if (pad != L_('0') && pad != L_('-'))
 928             pad = L_('_');
 929
 930         do_number:
 931           /* Format the number according to the MODIFIER flag.  */
 932
 933           if (modifier == L_('O') && 0 <= number_value)
 934             {
 935 #ifdef _NL_CURRENT
 936               /* Get the locale specific alternate representation of
 937                  the number NUMBER_VALUE.  If none exist NULL is returned.  */
 938               const CHAR_T *cp = nl_get_alt_digit (number_value
 939                                                    HELPER_LOCALE_ARG);
 940
 941               if (cp != NULL)
 942                 {
 943                   size_t digitlen = STRLEN (cp);
 944                   if (digitlen != 0)
 945                     {
 946                       cpy (digitlen, cp);
 947                       break;
 948                     }
 949                 }
 950 #else
 951 # if HAVE_STRFTIME
 952               goto underlying_strftime;
 953 # endif
 954 #endif
 955             }
 956           {
 957             unsigned int u = number_value;
 958
 959             bufp = buf + sizeof (buf) / sizeof (buf[0]);
 960             negative_number = number_value < 0;
 961
 962             if (negative_number)
 963               u = -u;
 964
 965             do
 966               *--bufp = u % 10 + L_('0');
 967             while ((u /= 10) != 0);
 968           }
 969
 970         do_number_sign_and_padding:
 971           if (negative_number)
 972             *--bufp = L_('-');
 973
 974           if (pad != L_('-'))
 975             {
 976               int padding = digits - (buf + (sizeof (buf) / sizeof (buf[0]))
 977                                       - bufp);
 978
 979               if (padding > 0)
 980                 {
 981                   if (pad == L_('_'))
 982                     {
 983                       if ((size_t) padding >= maxsize - i)
 984                         return 0;
 985
 986                       if (p)
 987                         memset_space (p, padding);
 988                       i += padding;
 989                       width = width > padding ? width - padding : 0;
 990                     }
 991                   else
 992                     {
 993                       if ((size_t) digits >= maxsize - i)
 994                         return 0;
 995
 996                       if (negative_number)
 997                         {
 998                           ++bufp;
 999
1000                           if (p)
1001                             *p++ = L_('-');
1002                           ++i;
1003                         }
1004
1005                       if (p)
1006                         memset_zero (p, padding);
1007                       i += padding;
1008                       width = 0;
1009                     }
1010                 }
1011             }
1012
1013           cpy (buf + sizeof (buf) / sizeof (buf[0]) - bufp, bufp);
1014           break;
1015
1016         case L_('F'):
1017           if (modifier != 0)
1018             goto bad_format;
1019           subfmt = L_("%Y-%m-%d");
1020           goto subformat;
1021
1022         case L_('H'):
1023           if (modifier == L_('E'))
1024             goto bad_format;
1025
1026           DO_NUMBER (2, tp->tm_hour);
1027
1028         case L_('I'):
1029           if (modifier == L_('E'))
1030             goto bad_format;
1031
1032           DO_NUMBER (2, hour12);
1033
1034         case L_('k'):           /* GNU extension.  */
1035           if (modifier == L_('E'))
1036             goto bad_format;
1037
1038           DO_NUMBER_SPACEPAD (2, tp->tm_hour);
1039
1040         case L_('l'):           /* GNU extension.  */
1041           if (modifier == L_('E'))
1042             goto bad_format;
1043
1044           DO_NUMBER_SPACEPAD (2, hour12);
1045
1046         case L_('j'):
1047           if (modifier == L_('E'))
1048             goto bad_format;
1049
1050           DO_NUMBER (3, 1 + tp->tm_yday);
1051
1052         case L_('M'):
1053           if (modifier == L_('E'))
1054             goto bad_format;
1055
1056           DO_NUMBER (2, tp->tm_min);
1057
1058         case L_('m'):
1059           if (modifier == L_('E'))
1060             goto bad_format;
1061
1062           DO_NUMBER (2, tp->tm_mon + 1);
1063
1064         case L_('n'):
1065           add (1, *p = L_('\n'));
1066           break;
1067
1068         case L_('P'):
1069           to_lowcase = 1;
1070 #if !defined _NL_CURRENT && HAVE_STRFTIME
1071           format_char = L_('p');
1072 #endif
1073           /* FALLTHROUGH */
1074
1075         case L_('p'):
1076           if (change_case)
1077             {
1078               to_uppcase = 0;
1079               to_lowcase = 1;
1080             }
1081 #if defined _NL_CURRENT || !HAVE_STRFTIME
1082           cpy (ap_len, ampm);
1083           break;
1084 #else
1085           goto underlying_strftime;
1086 #endif
1087
1088         case L_('R'):
1089           subfmt = L_("%H:%M");
1090           goto subformat;
1091
1092         case L_('r'):
1093 #if !defined _NL_CURRENT && HAVE_STRFTIME
1094           goto underlying_strftime;
1095 #else
1096 # ifdef _NL_CURRENT
1097           if (*(subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME,
1098                                                        NLW(T_FMT_AMPM)))
1099               == L_('\0'))
1100 # endif
1101             subfmt = L_("%I:%M:%S %p");
1102           goto subformat;
1103 #endif
1104
1105         case L_('S'):
1106           if (modifier == L_('E'))
1107             goto bad_format;
1108
1109           DO_NUMBER (2, tp->tm_sec);
1110
1111         case L_('s'):           /* GNU extension.  */
1112           {
1113             struct tm ltm;
1114             time_t t;
1115
1116             ltm = *tp;
1117             t = mktime (&ltm);
1118
1119             /* Generate string value for T using time_t arithmetic;
1120                this works even if sizeof (long) < sizeof (time_t).  */
1121
1122             bufp = buf + sizeof (buf) / sizeof (buf[0]);
1123             negative_number = t < 0;
1124
1125             do
1126               {
1127                 int d = t % 10;
1128                 t /= 10;
1129
1130                 if (negative_number)
1131                   {
1132                     d = -d;
1133
1134                     /* Adjust if division truncates to minus infinity.  */
1135                     if (0 < -1 % 10 && d < 0)
1136                       {
1137                         t++;
1138                         d += 10;
1139                       }
1140                   }
1141
1142                 *--bufp = d + L_('0');
1143               }
1144             while (t != 0);
1145
1146             digits = 1;
1147             goto do_number_sign_and_padding;
1148           }
1149
1150         case L_('X'):
1151           if (modifier == L_('O'))
1152             goto bad_format;
1153 #ifdef _NL_CURRENT
1154           if (! (modifier == L_('E')
1155                  && (*(subfmt =
1156                        (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ERA_T_FMT)))
1157                      != L_('\0'))))
1158             subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(T_FMT));
1159           goto subformat;
1160 #else
1161 # if HAVE_STRFTIME
1162           goto underlying_strftime;
1163 # else
1164           /* Fall through.  */
1165 # endif
1166 #endif
1167         case L_('T'):
1168           subfmt = L_("%H:%M:%S");
1169           goto subformat;
1170
1171         case L_('t'):
1172           add (1, *p = L_('\t'));
1173           break;
1174
1175         case L_('u'):
1176           DO_NUMBER (1, (tp->tm_wday - 1 + 7) % 7 + 1);
1177
1178         case L_('U'):
1179           if (modifier == L_('E'))
1180             goto bad_format;
1181
1182           DO_NUMBER (2, (tp->tm_yday - tp->tm_wday + 7) / 7);
1183
1184         case L_('V'):
1185         case L_('g'):
1186         case L_('G'):
1187           if (modifier == L_('E'))
1188             goto bad_format;
1189           {
1190             int year = tp->tm_year + TM_YEAR_BASE;
1191             int days = iso_week_days (tp->tm_yday, tp->tm_wday);
1192
1193             if (days < 0)
1194               {
1195                 /* This ISO week belongs to the previous year.  */
1196                 year--;
1197                 days = iso_week_days (tp->tm_yday + (365 + __isleap (year)),
1198                                       tp->tm_wday);
1199               }
1200             else
1201               {
1202                 int d = iso_week_days (tp->tm_yday - (365 + __isleap (year)),
1203                                        tp->tm_wday);
1204                 if (0 <= d)
1205                   {
1206                     /* This ISO week belongs to the next year.  */
1207                     year++;
1208                     days = d;
1209                   }
1210               }
1211
1212             switch (*f)
1213               {
1214               case L_('g'):
1215                 DO_NUMBER (2, (year % 100 + 100) % 100);
1216
1217               case L_('G'):
1218                 DO_NUMBER (1, year);
1219
1220               default:
1221                 DO_NUMBER (2, days / 7 + 1);
1222               }
1223           }
1224
1225         case L_('W'):
1226           if (modifier == L_('E'))
1227             goto bad_format;
1228
1229           DO_NUMBER (2, (tp->tm_yday - (tp->tm_wday - 1 + 7) % 7 + 7) / 7);
1230
1231         case L_('w'):
1232           if (modifier == L_('E'))
1233             goto bad_format;
1234
1235           DO_NUMBER (1, tp->tm_wday);
1236
1237         case L_('Y'):
1238           if (modifier == 'E')
1239             {
1240 #if HAVE_STRUCT_ERA_ENTRY
1241               struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
1242               if (era)
1243                 {
1244 # ifdef COMPILE_WIDE
1245                   subfmt = era->era_wformat;
1246 # else
1247                   subfmt = era->era_format;
1248 # endif
1249                   goto subformat;
1250                 }
1251 #else
1252 # if HAVE_STRFTIME
1253               goto underlying_strftime;
1254 # endif
1255 #endif
1256             }
1257           if (modifier == L_('O'))
1258             goto bad_format;
1259           else
1260             DO_NUMBER (1, tp->tm_year + TM_YEAR_BASE);
1261
1262         case L_('y'):
1263           if (modifier == L_('E'))
1264             {
1265 #if HAVE_STRUCT_ERA_ENTRY
1266               struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
1267               if (era)
1268                 {
1269                   int delta = tp->tm_year - era->start_date[0];
1270                   DO_NUMBER (1, (era->offset
1271                                  + delta * era->absolute_direction));
1272                 }
1273 #else
1274 # if HAVE_STRFTIME
1275               goto underlying_strftime;
1276 # endif
1277 #endif
1278             }
1279           DO_NUMBER (2, (tp->tm_year % 100 + 100) % 100);
1280
1281         case L_('Z'):
1282           if (change_case)
1283             {
1284               to_uppcase = 0;
1285               to_lowcase = 1;
1286             }
1287
1288 #if HAVE_TZNAME
1289           /* The tzset() call might have changed the value.  */
1290           if (!(zone && *zone) && tp->tm_isdst >= 0)
1291             {
1292               /* POSIX.1 requires that local time zone information is used as
1293                  though strftime called tzset.  */
1294 # if HAVE_TZSET
1295               if (!*tzset_called)
1296                 {
1297                   tzset ();
1298                   *tzset_called = true;
1299                 }
1300 # endif
1301               zone = tp->tm_isdst <= 1 ? tzname[tp->tm_isdst] : "?";
1302             }
1303 #endif
1304           if (! zone)
1305             zone = "";
1306
1307 #ifdef COMPILE_WIDE
1308           {
1309             /* The zone string is always given in multibyte form.  We have
1310                to transform it first.  */
1311             wchar_t *wczone;
1312             size_t len;
1313             widen (zone, wczone, len);
1314             cpy (len, wczone);
1315           }
1316 #else
1317           cpy (strlen (zone), zone);
1318 #endif
1319           break;
1320
1321         case L_('z'):
1322           if (tp->tm_isdst < 0)
1323             break;
1324
1325           {
1326             int diff;
1327 #if HAVE_TM_GMTOFF
1328             diff = tp->tm_gmtoff;
1329 #else
1330             if (ut)
1331               diff = 0;
1332             else
1333               {
1334                 struct tm gtm;
1335                 struct tm ltm;
1336                 time_t lt;
1337
1338                 /* POSIX.1 requires that local time zone information is used as
1339                    though strftime called tzset.  */
1340 # if HAVE_TZSET
1341                 if (!*tzset_called)
1342                   {
1343                     tzset ();
1344                     *tzset_called = true;
1345                   }
1346 # endif
1347
1348                 ltm = *tp;
1349                 lt = mktime (&ltm);
1350
1351                 if (lt == (time_t) -1)
1352                   {
1353                     /* mktime returns -1 for errors, but -1 is also a
1354                        valid time_t value.  Check whether an error really
1355                        occurred.  */
1356                     struct tm tm;
1357
1358                     if (! __localtime_r (&lt, &tm)
1359                         || ((ltm.tm_sec ^ tm.tm_sec)
1360                             | (ltm.tm_min ^ tm.tm_min)
1361                             | (ltm.tm_hour ^ tm.tm_hour)
1362                             | (ltm.tm_mday ^ tm.tm_mday)
1363                             | (ltm.tm_mon ^ tm.tm_mon)
1364                             | (ltm.tm_year ^ tm.tm_year)))
1365                       break;
1366                   }
1367
1368                 if (! __gmtime_r (&lt, &gtm))
1369                   break;
1370
1371                 diff = tm_diff (&ltm, &gtm);
1372               }
1373 #endif
1374
1375             if (diff < 0)
1376               {
1377                 add (1, *p = L_('-'));
1378                 diff = -diff;
1379               }
1380             else
1381               add (1, *p = L_('+'));
1382
1383             diff /= 60;
1384             DO_NUMBER (4, (diff / 60) * 100 + diff % 60);
1385           }
1386
1387         case L_('\0'):          /* GNU extension: % at end of format.  */
1388             --f;
1389             /* Fall through.  */
1390         default:
1391           /* Unknown format; output the format, including the '%',
1392              since this is most likely the right thing to do if a
1393              multibyte string has been misparsed.  */
1394         bad_format:
1395           {
1396             int flen;
1397             for (flen = 1; f[1 - flen] != L_('%'); flen++)
1398               continue;
1399             cpy (flen, &f[1 - flen]);
1400           }
1401           break;
1402         }
1403     }
1404
1405   if (p && maxsize != 0)
1406     *p = L_('\0');
1407   return i;
1408 }
1409
1410
1411 #ifdef emacs
1412 /* For Emacs we have a separate interface which corresponds to the normal
1413    strftime function and does not have the extra information whether the
1414    TP arguments comes from a `gmtime' call or not.  */
1415 size_t
1416 emacs_strftime (char *s, size_t maxsize, const char *format,
1417                 const struct tm *tp)
1418 {
1419   return my_strftime (s, maxsize, format, tp, 0);
1420 }
1421 #endif
1422
1423 #if defined _LIBC && !defined COMPILE_WIDE
1424 weak_alias (__strftime_l, strftime_l)
1425 #endif