src/strftime.c

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