1 /* Copyright (C) 1991-1999, 2000, 2001, 2003, 2004, 2005, 2006 Free Software
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.
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)
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.
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. */
23 # define HAVE_MBRLEN 1
24 # define HAVE_STRUCT_ERA_ENTRY 1
25 # define HAVE_TM_GMTOFF 1
26 # define HAVE_TM_ZONE 1
27 # define HAVE_TZNAME 1
29 # define MULTIBYTE_IS_FORMAT_SAFE 1
30 # include "../locale/localeinfo.h"
34 # include "fprintftime.h"
39 #include <sys/types.h> /* Some systems define `time_t' here. */
41 #ifdef TIME_WITH_SYS_TIME
42 # include <sys/time.h>
45 # ifdef HAVE_SYS_TIME_H
46 # include <sys/time.h>
51 #if HAVE_TZNAME && ! defined tzname
52 extern char *tzname[];
55 /* Do multibyte processing if multibytes are supported, unless
56 multibyte sequences are safe in formats. Multibyte sequences are
57 safe if they cannot contain byte sequences that look like format
58 conversion specifications. The GNU C Library uses UTF8 multibyte
59 encoding, which is safe for formats, but strftime.c can be used
60 with other C libraries that use unsafe encodings. */
61 #define DO_MULTIBYTE (HAVE_MBLEN && HAVE_WCHAR_H && ! MULTIBYTE_IS_FORMAT_SAFE)
67 /* Simulate mbrlen with mblen as best we can. */
68 # define mbstate_t int
69 # define mbrlen(s, n, ps) mblen (s, n)
70 # define mbsinit(ps) (*(ps) == 0)
72 static const mbstate_t mbstate_zero;
83 # define CHAR_T wchar_t
84 # define UCHAR_T unsigned int
85 # define L_(Str) L##Str
86 # define NLW(Sym) _NL_W##Sym
88 # define MEMCPY(d, s, n) __wmemcpy (d, s, n)
89 # define STRLEN(s) __wcslen (s)
93 # define UCHAR_T unsigned char
97 # define MEMCPY(d, s, n) memcpy (d, s, n)
98 # define STRLEN(s) strlen (s)
101 # define MEMPCPY(d, s, n) __mempcpy (d, s, n)
103 # ifndef HAVE_MEMPCPY
104 # define MEMPCPY(d, s, n) ((void *) ((char *) memcpy (d, s, n) + (n)))
109 /* Shift A right by B bits portably, by dividing A by 2**B and
110 truncating towards minus infinity. A and B should be free of side
111 effects, and B should be in the range 0 <= B <= INT_BITS - 2, where
112 INT_BITS is the number of useful bits in an int. GNU code can
113 assume that INT_BITS is at least 32.
115 ISO C99 says that A >> B is implementation-defined if A < 0. Some
116 implementations (e.g., UNICOS 9.0 on a Cray Y-MP EL) don't shift
117 right in the usual way when A < 0, so SHR falls back on division if
118 ordinary A >> B doesn't seem to be the usual signed shift. */
122 : (a) / (1 << (b)) - ((a) % (1 << (b)) < 0))
124 /* Bound on length of the string representing an integer type or expression T.
125 Subtract 1 for the sign bit if t is signed; log10 (2.0) < 146/485;
126 add 1 for integer division truncation; add 1 more for a minus sign
128 #define INT_STRLEN_BOUND(t) \
129 ((sizeof (t) * CHAR_BIT - 1) * 146 / 485 + 2)
131 #define TM_YEAR_BASE 1900
134 /* Nonzero if YEAR is a leap year (every 4 years,
135 except every 100th isn't, and every 400th is). */
136 # define __isleap(year) \
137 ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
142 # define tzname __tzname
143 # define tzset __tzset
147 /* Portable standalone applications should supply a "time_r.h" that
148 declares a POSIX-compliant localtime_r, for the benefit of older
149 implementations that lack localtime_r or have a nonstandard one.
150 See the gnulib time_r module for one way to implement this. */
153 # undef __localtime_r
154 # define __gmtime_r gmtime_r
155 # define __localtime_r localtime_r
160 # define FPRINTFTIME 0
164 # define STREAM_OR_CHAR_T FILE
165 # define STRFTIME_ARG(x) /* empty */
167 # define STREAM_OR_CHAR_T CHAR_T
168 # define STRFTIME_ARG(x) x,
172 # define memset_byte(P, Len, Byte) \
173 do { size_t _i; for (_i = 0; _i < Len; _i++) fputc (Byte, P); } while (0)
174 # define memset_space(P, Len) memset_byte (P, Len, ' ')
175 # define memset_zero(P, Len) memset_byte (P, Len, '0')
176 #elif defined COMPILE_WIDE
177 # define memset_space(P, Len) (wmemset (P, L' ', Len), (P) += (Len))
178 # define memset_zero(P, Len) (wmemset (P, L'0', Len), (P) += (Len))
180 # define memset_space(P, Len) (memset (P, ' ', Len), (P) += (Len))
181 # define memset_zero(P, Len) (memset (P, '0', Len), (P) += (Len))
185 # define advance(P, N)
187 # define advance(P, N) ((P) += (N))
194 int _delta = width - _n; \
195 int _incr = _n + (_delta > 0 ? _delta : 0); \
196 if ((size_t) _incr >= maxsize - i) \
200 if (digits == 0 && _delta > 0) \
202 if (pad == L_('0')) \
203 memset_zero (p, _delta); \
205 memset_space (p, _delta); \
214 # define add1(C) add (1, fputc (C, p))
216 # define add1(C) add (1, *p = C)
223 fwrite_lowcase (p, (s), _n); \
224 else if (to_uppcase) \
225 fwrite_uppcase (p, (s), _n); \
227 fwrite ((s), _n, 1, p))
232 memcpy_lowcase (p, (s), _n LOCALE_ARG); \
233 else if (to_uppcase) \
234 memcpy_uppcase (p, (s), _n LOCALE_ARG); \
236 MEMCPY ((void *) p, (void const *) (s), _n))
240 # ifndef USE_IN_EXTENDED_LOCALE_MODEL
241 # undef __mbsrtowcs_l
242 # define __mbsrtowcs_l(d, s, l, st, loc) __mbsrtowcs (d, s, l, st)
244 # define widen(os, ws, l) \
247 const char *__s = os; \
248 memset (&__st, '\0', sizeof (__st)); \
249 l = __mbsrtowcs_l (NULL, &__s, 0, &__st, loc); \
250 ws = (wchar_t *) alloca ((l + 1) * sizeof (wchar_t)); \
251 (void) __mbsrtowcs_l (ws, &__s, l, &__st, loc); \
256 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
257 /* We use this code also for the extended locale handling where the
258 function gets as an additional argument the locale which has to be
259 used. To access the values we have to redefine the _NL_CURRENT
261 # define strftime __strftime_l
262 # define wcsftime __wcsftime_l
264 # define _NL_CURRENT(category, item) \
265 (current->values[_NL_ITEM_INDEX (item)].string)
266 # define LOCALE_ARG , loc
267 # define LOCALE_PARAM_PROTO , __locale_t loc
268 # define HELPER_LOCALE_ARG , current
270 # define LOCALE_PARAM_PROTO
273 # define HELPER_LOCALE_ARG , _NL_CURRENT_DATA (LC_TIME)
275 # define HELPER_LOCALE_ARG
280 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
281 # define TOUPPER(Ch, L) __towupper_l (Ch, L)
282 # define TOLOWER(Ch, L) __towlower_l (Ch, L)
284 # define TOUPPER(Ch, L) towupper (Ch)
285 # define TOLOWER(Ch, L) towlower (Ch)
288 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
289 # define TOUPPER(Ch, L) __toupper_l (Ch, L)
290 # define TOLOWER(Ch, L) __tolower_l (Ch, L)
292 # define TOUPPER(Ch, L) toupper (Ch)
293 # define TOLOWER(Ch, L) tolower (Ch)
296 /* We don't use `isdigit' here since the locale dependent
297 interpretation is not what we want here. We only need to accept
298 the arabic digits in the ASCII range. One day there is perhaps a
299 more reliable way to accept other sets of digits. */
300 #define ISDIGIT(Ch) ((unsigned int) (Ch) - L_('0') <= 9)
304 fwrite_lowcase (FILE *fp, const CHAR_T *src, size_t len)
308 fputc (TOLOWER ((UCHAR_T) *src, loc), fp);
314 fwrite_uppcase (FILE *fp, const CHAR_T *src, size_t len)
318 fputc (TOUPPER ((UCHAR_T) *src, loc), fp);
324 memcpy_lowcase (CHAR_T *dest, const CHAR_T *src,
325 size_t len LOCALE_PARAM_PROTO)
328 dest[len] = TOLOWER ((UCHAR_T) src[len], loc);
333 memcpy_uppcase (CHAR_T *dest, const CHAR_T *src,
334 size_t len LOCALE_PARAM_PROTO)
337 dest[len] = TOUPPER ((UCHAR_T) src[len], loc);
344 /* Yield the difference between *A and *B,
345 measured in seconds, ignoring leap seconds. */
346 # define tm_diff ftime_tm_diff
348 tm_diff (const struct tm *a, const struct tm *b)
350 /* Compute intervening leap days correctly even if year is negative.
351 Take care to avoid int overflow in leap day calculations,
352 but it's OK to assume that A and B are close to each other. */
353 int a4 = SHR (a->tm_year, 2) + SHR (TM_YEAR_BASE, 2) - ! (a->tm_year & 3);
354 int b4 = SHR (b->tm_year, 2) + SHR (TM_YEAR_BASE, 2) - ! (b->tm_year & 3);
355 int a100 = a4 / 25 - (a4 % 25 < 0);
356 int b100 = b4 / 25 - (b4 % 25 < 0);
357 int a400 = SHR (a100, 2);
358 int b400 = SHR (b100, 2);
359 int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
360 int years = a->tm_year - b->tm_year;
361 int days = (365 * years + intervening_leap_days
362 + (a->tm_yday - b->tm_yday));
363 return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
364 + (a->tm_min - b->tm_min))
365 + (a->tm_sec - b->tm_sec));
367 #endif /* ! HAVE_TM_GMTOFF */
371 /* The number of days from the first day of the first ISO week of this
372 year to the year day YDAY with week day WDAY. ISO weeks start on
373 Monday; the first ISO week has the year's first Thursday. YDAY may
374 be as small as YDAY_MINIMUM. */
375 #define ISO_WEEK_START_WDAY 1 /* Monday */
376 #define ISO_WEEK1_WDAY 4 /* Thursday */
377 #define YDAY_MINIMUM (-366)
382 iso_week_days (int yday, int wday)
384 /* Add enough to the first operand of % to make it nonnegative. */
385 int big_enough_multiple_of_7 = (-YDAY_MINIMUM / 7 + 2) * 7;
387 - (yday - wday + ISO_WEEK1_WDAY + big_enough_multiple_of_7) % 7
388 + ISO_WEEK1_WDAY - ISO_WEEK_START_WDAY);
392 /* When compiling this file, GNU applications can #define my_strftime
393 to a symbol (typically nstrftime) to get an extended strftime with
394 extra arguments UT and NS. Emacs is a special case for now, but
395 this Emacs-specific code can be removed once Emacs's config.h
396 defines my_strftime. */
397 #if defined emacs && !defined my_strftime
398 # define my_strftime nstrftime
403 # define my_strftime fprintftime
407 # define extra_args , ut, ns
408 # define extra_args_spec , int ut, int ns
410 # if defined COMPILE_WIDE
411 # define my_strftime wcsftime
412 # define nl_get_alt_digit _nl_get_walt_digit
414 # define my_strftime strftime
415 # define nl_get_alt_digit _nl_get_alt_digit
418 # define extra_args_spec
419 /* We don't have this information in general. */
425 /* Just like my_strftime, below, but with one more parameter, UPCASE,
426 to indicate that the result should be converted to upper case. */
428 strftime_case_ (bool upcase, STREAM_OR_CHAR_T *s,
429 STRFTIME_ARG (size_t maxsize)
430 const CHAR_T *format,
431 const struct tm *tp extra_args_spec LOCALE_PARAM_PROTO)
433 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
434 struct locale_data *const current = loc->__locales[LC_TIME];
437 size_t maxsize = (size_t) -1;
440 int hour12 = tp->tm_hour;
442 /* We cannot make the following values variables since we must delay
443 the evaluation of these values until really needed since some
444 expressions might not be valid in every situation. The `struct tm'
445 might be generated by a strptime() call that initialized
446 only a few elements. Dereference the pointers only if the format
447 requires this. Then it is ok to fail if the pointers are invalid. */
449 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABDAY_1) + tp->tm_wday))
451 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(DAY_1) + tp->tm_wday))
453 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABMON_1) + tp->tm_mon))
455 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(MON_1) + tp->tm_mon))
457 ((const CHAR_T *) _NL_CURRENT (LC_TIME, tp->tm_hour > 11 \
458 ? NLW(PM_STR) : NLW(AM_STR)))
460 # define aw_len STRLEN (a_wkday)
461 # define am_len STRLEN (a_month)
462 # define ap_len STRLEN (ampm)
466 STREAM_OR_CHAR_T *p = s;
468 #if DO_MULTIBYTE && !defined COMPILE_WIDE
469 const char *format_end = NULL;
472 #if ! defined _LIBC && ! HAVE_RUN_TZSET_TEST
473 /* Solaris 2.5.x and 2.6 tzset sometimes modify the storage returned
474 by localtime. On such systems, we must either use the tzset and
475 localtime wrappers to work around the bug (which sets
476 HAVE_RUN_TZSET_TEST) or make a copy of the structure. */
477 struct tm copy = *tp;
483 /* The POSIX test suite assumes that setting
484 the environment variable TZ to a new value before calling strftime()
485 will influence the result (the %Z format) even if the information in
486 TP is computed with a totally different time zone.
487 This is bogus: though POSIX allows bad behavior like this,
488 POSIX does not require it. Do the right thing instead. */
489 zone = (const char *) tp->tm_zone;
494 if (! (zone && *zone))
499 /* POSIX.1 requires that local time zone information be used as
500 though strftime called tzset. */
513 for (f = format; *f != '\0'; ++f)
515 int pad = 0; /* Padding for number ('-', '_', or 0). */
516 int modifier; /* Field modifier ('E', 'O', or 0). */
517 int digits = 0; /* Max digits for numeric format. */
518 int number_value; /* Numeric value to be printed. */
519 unsigned int u_number_value; /* (unsigned int) number_value. */
520 bool negative_number; /* The number is negative. */
521 bool always_output_a_sign; /* +/- should always be output. */
522 int tz_colon_mask; /* Bitmask of where ':' should appear. */
523 const CHAR_T *subfmt;
527 + 2 /* for the two colons in a %::z or %:::z time zone */
528 + (sizeof (int) < sizeof (time_t)
529 ? INT_STRLEN_BOUND (time_t)
530 : INT_STRLEN_BOUND (int))];
532 bool to_lowcase = false;
533 bool to_uppcase = upcase;
535 bool change_case = false;
538 #if DO_MULTIBYTE && !defined COMPILE_WIDE
544 case L_('\b'): case L_('\t'): case L_('\n'):
545 case L_('\v'): case L_('\f'): case L_('\r'):
546 case L_(' '): case L_('!'): case L_('"'): case L_('#'): case L_('&'):
547 case L_('\''): case L_('('): case L_(')'): case L_('*'): case L_('+'):
548 case L_(','): case L_('-'): case L_('.'): case L_('/'): case L_('0'):
549 case L_('1'): case L_('2'): case L_('3'): case L_('4'): case L_('5'):
550 case L_('6'): case L_('7'): case L_('8'): case L_('9'): case L_(':'):
551 case L_(';'): case L_('<'): case L_('='): case L_('>'): case L_('?'):
552 case L_('A'): case L_('B'): case L_('C'): case L_('D'): case L_('E'):
553 case L_('F'): case L_('G'): case L_('H'): case L_('I'): case L_('J'):
554 case L_('K'): case L_('L'): case L_('M'): case L_('N'): case L_('O'):
555 case L_('P'): case L_('Q'): case L_('R'): case L_('S'): case L_('T'):
556 case L_('U'): case L_('V'): case L_('W'): case L_('X'): case L_('Y'):
557 case L_('Z'): case L_('['): case L_('\\'): case L_(']'): case L_('^'):
558 case L_('_'): case L_('a'): case L_('b'): case L_('c'): case L_('d'):
559 case L_('e'): case L_('f'): case L_('g'): case L_('h'): case L_('i'):
560 case L_('j'): case L_('k'): case L_('l'): case L_('m'): case L_('n'):
561 case L_('o'): case L_('p'): case L_('q'): case L_('r'): case L_('s'):
562 case L_('t'): case L_('u'): case L_('v'): case L_('w'): case L_('x'):
563 case L_('y'): case L_('z'): case L_('{'): case L_('|'): case L_('}'):
565 /* The C Standard requires these 98 characters (plus '%') to
566 be in the basic execution character set. None of these
567 characters can start a multibyte sequence, so they need
568 not be analyzed further. */
573 /* Copy this multibyte sequence until we reach its end, find
574 an error, or come back to the initial shift state. */
576 mbstate_t mbstate = mbstate_zero;
581 format_end = f + strlen (f) + 1;
582 fsize = format_end - f;
586 size_t bytes = mbrlen (f + len, fsize - len, &mbstate);
591 if (bytes == (size_t) -2)
593 len += strlen (f + len);
597 if (bytes == (size_t) -1)
605 while (! mbsinit (&mbstate));
613 #else /* ! DO_MULTIBYTE */
615 /* Either multibyte encodings are not supported, they are
616 safe for formats, so any non-'%' byte can be copied through,
617 or this is the wide character version. */
624 #endif /* ! DO_MULTIBYTE */
626 /* Check for flags that can modify a format. */
631 /* This influences the number formats. */
638 /* This changes textual output. */
652 /* As a GNU extension we allow to specify the field width. */
658 if (width > INT_MAX / 10
659 || (width == INT_MAX / 10 && *f - L_('0') > INT_MAX % 10))
660 /* Avoid overflow. */
665 width += *f - L_('0');
669 while (ISDIGIT (*f));
672 /* Check for modifiers. */
685 /* Now do the specified format. */
689 #define DO_NUMBER(d, v) \
691 number_value = v; goto do_number
692 #define DO_SIGNED_NUMBER(d, negative, v) \
694 negative_number = negative; \
695 u_number_value = v; goto do_signed_number
697 /* The mask is not what you might think.
698 When the ordinal i'th bit is set, insert a colon
699 before the i'th digit of the time zone representation. */
700 #define DO_TZ_OFFSET(d, negative, mask, v) \
702 negative_number = negative; \
703 tz_colon_mask = mask; \
704 u_number_value = v; goto do_tz_offset
705 #define DO_NUMBER_SPACEPAD(d, v) \
707 number_value = v; goto do_number_spacepad
724 cpy (aw_len, a_wkday);
727 goto underlying_strftime;
739 cpy (STRLEN (f_wkday), f_wkday);
742 goto underlying_strftime;
755 cpy (am_len, a_month);
758 goto underlying_strftime;
770 cpy (STRLEN (f_month), f_month);
773 goto underlying_strftime;
777 if (modifier == L_('O'))
780 if (! (modifier == 'E'
782 (const CHAR_T *) _NL_CURRENT (LC_TIME,
785 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_T_FMT));
787 goto underlying_strftime;
792 size_t len = strftime_case_ (to_uppcase,
793 NULL, STRFTIME_ARG ((size_t) -1)
795 tp extra_args LOCALE_ARG);
796 add (len, strftime_case_ (to_uppcase, p,
797 STRFTIME_ARG (maxsize - i)
799 tp extra_args LOCALE_ARG));
803 #if !(defined _NL_CURRENT && HAVE_STRUCT_ERA_ENTRY)
806 /* The relevant information is available only via the
807 underlying strftime implementation, so use that. */
810 char ubuf[1024]; /* enough for any single format in practice */
812 /* Make sure we're calling the actual underlying strftime.
813 In some cases, config.h contains something like
814 "#define strftime rpl_strftime". */
820 /* The space helps distinguish strftime failure from empty
828 len = strftime (ubuf, sizeof ubuf, ufmt, tp);
830 cpy (len - 1, ubuf + 1);
836 if (modifier == L_('O'))
838 if (modifier == L_('E'))
840 #if HAVE_STRUCT_ERA_ENTRY
841 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
845 size_t len = __wcslen (era->era_wname);
846 cpy (len, era->era_wname);
848 size_t len = strlen (era->era_name);
849 cpy (len, era->era_name);
854 goto underlying_strftime;
859 int century = tp->tm_year / 100 + TM_YEAR_BASE / 100;
860 century -= tp->tm_year % 100 < 0 && 0 < century;
861 DO_SIGNED_NUMBER (2, tp->tm_year < - TM_YEAR_BASE, century);
865 if (modifier == L_('O'))
868 if (! (modifier == L_('E')
870 (const CHAR_T *)_NL_CURRENT (LC_TIME, NLW(ERA_D_FMT)))
872 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_FMT));
875 goto underlying_strftime;
880 subfmt = L_("%m/%d/%y");
884 if (modifier == L_('E'))
887 DO_NUMBER (2, tp->tm_mday);
890 if (modifier == L_('E'))
893 DO_NUMBER_SPACEPAD (2, tp->tm_mday);
895 /* All numeric formats set DIGITS and NUMBER_VALUE (or U_NUMBER_VALUE)
896 and then jump to one of these labels. */
899 always_output_a_sign = true;
903 /* Force `_' flag unless overridden by `0' or `-' flag. */
904 if (pad != L_('0') && pad != L_('-'))
908 /* Format NUMBER_VALUE according to the MODIFIER flag. */
909 negative_number = number_value < 0;
910 u_number_value = number_value;
913 always_output_a_sign = false;
917 /* Format U_NUMBER_VALUE according to the MODIFIER flag.
918 NEGATIVE_NUMBER is nonzero if the original number was
919 negative; in this case it was converted directly to
920 unsigned int (i.e., modulo (UINT_MAX + 1)) without
922 if (modifier == L_('O') && !negative_number)
925 /* Get the locale specific alternate representation of
926 the number. If none exist NULL is returned. */
927 const CHAR_T *cp = nl_get_alt_digit (u_number_value
932 size_t digitlen = STRLEN (cp);
940 goto underlying_strftime;
944 bufp = buf + sizeof (buf) / sizeof (buf[0]);
947 u_number_value = - u_number_value;
951 if (tz_colon_mask & 1)
954 *--bufp = u_number_value % 10 + L_('0');
955 u_number_value /= 10;
957 while (u_number_value != 0 || tz_colon_mask != 0);
959 do_number_sign_and_padding:
963 sign_char = (negative_number ? L_('-')
964 : always_output_a_sign ? L_('+')
974 int padding = digits - (buf + (sizeof (buf) / sizeof (buf[0]))
975 - bufp) - !!sign_char;
981 if ((size_t) padding >= maxsize - i)
985 memset_space (p, padding);
987 width = width > padding ? width - padding : 0;
993 if ((size_t) digits >= maxsize - i)
1000 memset_zero (p, padding);
1012 cpy (buf + sizeof (buf) / sizeof (buf[0]) - bufp, bufp);
1018 subfmt = L_("%Y-%m-%d");
1022 if (modifier == L_('E'))
1025 DO_NUMBER (2, tp->tm_hour);
1028 if (modifier == L_('E'))
1031 DO_NUMBER (2, hour12);
1033 case L_('k'): /* GNU extension. */
1034 if (modifier == L_('E'))
1037 DO_NUMBER_SPACEPAD (2, tp->tm_hour);
1039 case L_('l'): /* GNU extension. */
1040 if (modifier == L_('E'))
1043 DO_NUMBER_SPACEPAD (2, hour12);
1046 if (modifier == L_('E'))
1049 DO_SIGNED_NUMBER (3, tp->tm_yday < -1, tp->tm_yday + 1U);
1052 if (modifier == L_('E'))
1055 DO_NUMBER (2, tp->tm_min);
1058 if (modifier == L_('E'))
1061 DO_SIGNED_NUMBER (2, tp->tm_mon < -1, tp->tm_mon + 1U);
1064 case L_('N'): /* GNU extension. */
1065 if (modifier == L_('E'))
1073 /* Take an explicit width less than 9 as a precision. */
1075 for (j = width; j < 9; j++)
1079 DO_NUMBER (width, number_value);
1089 format_char = L_('p');
1103 goto underlying_strftime;
1107 subfmt = L_("%H:%M");
1112 if (*(subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME,
1115 subfmt = L_("%I:%M:%S %p");
1118 goto underlying_strftime;
1122 if (modifier == L_('E'))
1125 DO_NUMBER (2, tp->tm_sec);
1127 case L_('s'): /* GNU extension. */
1135 /* Generate string value for T using time_t arithmetic;
1136 this works even if sizeof (long) < sizeof (time_t). */
1138 bufp = buf + sizeof (buf) / sizeof (buf[0]);
1139 negative_number = t < 0;
1145 *--bufp = (negative_number ? -d : d) + L_('0');
1150 always_output_a_sign = false;
1151 goto do_number_sign_and_padding;
1155 if (modifier == L_('O'))
1158 if (! (modifier == L_('E')
1160 (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ERA_T_FMT)))
1162 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(T_FMT));
1165 goto underlying_strftime;
1168 subfmt = L_("%H:%M:%S");
1176 DO_NUMBER (1, (tp->tm_wday - 1 + 7) % 7 + 1);
1179 if (modifier == L_('E'))
1182 DO_NUMBER (2, (tp->tm_yday - tp->tm_wday + 7) / 7);
1187 if (modifier == L_('E'))
1190 /* YEAR is a leap year if and only if (tp->tm_year + TM_YEAR_BASE)
1191 is a leap year, except that YEAR and YEAR - 1 both work
1192 correctly even when (tp->tm_year + TM_YEAR_BASE) would
1194 int year = (tp->tm_year
1196 ? TM_YEAR_BASE % 400
1197 : TM_YEAR_BASE % 400 - 400));
1198 int year_adjust = 0;
1199 int days = iso_week_days (tp->tm_yday, tp->tm_wday);
1203 /* This ISO week belongs to the previous year. */
1205 days = iso_week_days (tp->tm_yday + (365 + __isleap (year - 1)),
1210 int d = iso_week_days (tp->tm_yday - (365 + __isleap (year)),
1214 /* This ISO week belongs to the next year. */
1224 int yy = (tp->tm_year % 100 + year_adjust) % 100;
1225 DO_NUMBER (2, (0 <= yy
1227 : tp->tm_year < -TM_YEAR_BASE - year_adjust
1233 DO_SIGNED_NUMBER (4, tp->tm_year < -TM_YEAR_BASE - year_adjust,
1234 (tp->tm_year + (unsigned int) TM_YEAR_BASE
1238 DO_NUMBER (2, days / 7 + 1);
1243 if (modifier == L_('E'))
1246 DO_NUMBER (2, (tp->tm_yday - (tp->tm_wday - 1 + 7) % 7 + 7) / 7);
1249 if (modifier == L_('E'))
1252 DO_NUMBER (1, tp->tm_wday);
1255 if (modifier == 'E')
1257 #if HAVE_STRUCT_ERA_ENTRY
1258 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
1261 # ifdef COMPILE_WIDE
1262 subfmt = era->era_wformat;
1264 subfmt = era->era_format;
1269 goto underlying_strftime;
1272 if (modifier == L_('O'))
1275 DO_SIGNED_NUMBER (4, tp->tm_year < -TM_YEAR_BASE,
1276 tp->tm_year + (unsigned int) TM_YEAR_BASE);
1279 if (modifier == L_('E'))
1281 #if HAVE_STRUCT_ERA_ENTRY
1282 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
1285 int delta = tp->tm_year - era->start_date[0];
1286 DO_NUMBER (1, (era->offset
1287 + delta * era->absolute_direction));
1290 goto underlying_strftime;
1295 int yy = tp->tm_year % 100;
1297 yy = tp->tm_year < - TM_YEAR_BASE ? -yy : yy + 100;
1309 /* The tzset() call might have changed the value. */
1310 if (!(zone && *zone) && tp->tm_isdst >= 0)
1311 zone = tzname[tp->tm_isdst != 0];
1318 /* The zone string is always given in multibyte form. We have
1319 to transform it first. */
1322 widen (zone, wczone, len);
1326 cpy (strlen (zone), zone);
1331 /* :, ::, and ::: are valid only just before 'z'.
1332 :::: etc. are rejected later. */
1333 for (colons = 1; f[colons] == L_(':'); colons++)
1335 if (f[colons] != L_('z'))
1338 goto do_z_conversion;
1344 if (tp->tm_isdst < 0)
1353 diff = tp->tm_gmtoff;
1366 if (lt == (time_t) -1)
1368 /* mktime returns -1 for errors, but -1 is also a
1369 valid time_t value. Check whether an error really
1373 if (! __localtime_r (<, &tm)
1374 || ((ltm.tm_sec ^ tm.tm_sec)
1375 | (ltm.tm_min ^ tm.tm_min)
1376 | (ltm.tm_hour ^ tm.tm_hour)
1377 | (ltm.tm_mday ^ tm.tm_mday)
1378 | (ltm.tm_mon ^ tm.tm_mon)
1379 | (ltm.tm_year ^ tm.tm_year)))
1383 if (! __gmtime_r (<, >m))
1386 diff = tm_diff (<m, >m);
1390 hour_diff = diff / 60 / 60;
1391 min_diff = diff / 60 % 60;
1392 sec_diff = diff % 60;
1397 DO_TZ_OFFSET (5, diff < 0, 0, hour_diff * 100 + min_diff);
1399 case 1: tz_hh_mm: /* +hh:mm */
1400 DO_TZ_OFFSET (6, diff < 0, 04, hour_diff * 100 + min_diff);
1402 case 2: tz_hh_mm_ss: /* +hh:mm:ss */
1403 DO_TZ_OFFSET (9, diff < 0, 024,
1404 hour_diff * 10000 + min_diff * 100 + sec_diff);
1406 case 3: /* +hh if possible, else +hh:mm, else +hh:mm:ss */
1411 DO_TZ_OFFSET (3, diff < 0, 0, hour_diff);
1418 case L_('\0'): /* GNU extension: % at end of format. */
1422 /* Unknown format; output the format, including the '%',
1423 since this is most likely the right thing to do if a
1424 multibyte string has been misparsed. */
1428 for (flen = 1; f[1 - flen] != L_('%'); flen++)
1430 cpy (flen, &f[1 - flen]);
1437 if (p && maxsize != 0)
1444 /* Write information from TP into S according to the format
1445 string FORMAT, writing no more that MAXSIZE characters
1446 (including the terminating '\0') and returning number of
1447 characters written. If S is NULL, nothing will be written
1448 anywhere, so to determine how many characters would be
1449 written, use NULL for S and (size_t) -1 for MAXSIZE. */
1451 my_strftime (STREAM_OR_CHAR_T *s, STRFTIME_ARG (size_t maxsize)
1452 const CHAR_T *format,
1453 const struct tm *tp extra_args_spec LOCALE_PARAM_PROTO)
1455 return strftime_case_ (false, s, STRFTIME_ARG (maxsize)
1456 format, tp extra_args LOCALE_ARG);
1459 #if defined _LIBC && ! FPRINTFTIME
1460 libc_hidden_def (my_strftime)
1464 #if defined emacs && ! FPRINTFTIME
1465 /* For Emacs we have a separate interface which corresponds to the normal
1466 strftime function plus the ut argument, but without the ns argument. */
1468 emacs_strftimeu (char *s, size_t maxsize, const char *format,
1469 const struct tm *tp, int ut)
1471 return my_strftime (s, maxsize, format, tp, ut, 0);