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