lib/strftime.c

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