external/gpl2/xcvs/dist/lib/strftime.c

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