1 /* -*- buffer-read-only: t -*- vi: set ro: */
2 /* DO NOT EDIT! GENERATED AUTOMATICALLY! */
3 /* Copyright (C) 1991-2001, 2003-2007, 2009-2014 Free Software Foundation, Inc.
5 NOTE: The canonical source of this file is maintained with the GNU C Library.
6 Bugs can be reported to bug-glibc@prep.ai.mit.edu.
8 This program is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 # define HAVE_STRUCT_ERA_ENTRY 1
23 # define HAVE_TM_GMTOFF 1
24 # define HAVE_TM_ZONE 1
25 # define HAVE_TZNAME 1
27 # include "../locale/localeinfo.h"
31 # include "fprintftime.h"
33 # include "strftime.h"
40 #if HAVE_TZNAME && !HAVE_DECL_TZNAME
41 extern char *tzname[];
44 /* Do multibyte processing if multibyte encodings are supported, unless
45 multibyte sequences are safe in formats. Multibyte sequences are
46 safe if they cannot contain byte sequences that look like format
47 conversion specifications. The multibyte encodings used by the
48 C library on the various platforms (UTF-8, GB2312, GBK, CP936,
49 GB18030, EUC-TW, BIG5, BIG5-HKSCS, CP950, EUC-JP, EUC-KR, CP949,
50 SHIFT_JIS, CP932, JOHAB) are safe for formats, because the byte '%'
51 cannot occur in a multibyte character except in the first byte.
53 The DEC-HANYU encoding used on OSF/1 is not safe for formats, but
54 this encoding has never been seen in real-life use, so we ignore
56 #if !(defined __osf__ && 0)
57 # define MULTIBYTE_IS_FORMAT_SAFE 1
59 #define DO_MULTIBYTE (! MULTIBYTE_IS_FORMAT_SAFE)
63 static const mbstate_t mbstate_zero;
74 # define CHAR_T wchar_t
75 # define UCHAR_T unsigned int
76 # define L_(Str) L##Str
77 # define NLW(Sym) _NL_W##Sym
79 # define MEMCPY(d, s, n) __wmemcpy (d, s, n)
80 # define STRLEN(s) __wcslen (s)
84 # define UCHAR_T unsigned char
88 # define MEMCPY(d, s, n) memcpy (d, s, n)
89 # define STRLEN(s) strlen (s)
93 /* Shift A right by B bits portably, by dividing A by 2**B and
94 truncating towards minus infinity. A and B should be free of side
95 effects, and B should be in the range 0 <= B <= INT_BITS - 2, where
96 INT_BITS is the number of useful bits in an int. GNU code can
97 assume that INT_BITS is at least 32.
99 ISO C99 says that A >> B is implementation-defined if A < 0. Some
100 implementations (e.g., UNICOS 9.0 on a Cray Y-MP EL) don't shift
101 right in the usual way when A < 0, so SHR falls back on division if
102 ordinary A >> B doesn't seem to be the usual signed shift. */
106 : (a) / (1 << (b)) - ((a) % (1 << (b)) < 0))
108 /* Bound on length of the string representing an integer type or expression T.
109 Subtract 1 for the sign bit if t is signed; log10 (2.0) < 146/485;
110 add 1 for integer division truncation; add 1 more for a minus sign
112 #define INT_STRLEN_BOUND(t) \
113 ((sizeof (t) * CHAR_BIT - 1) * 146 / 485 + 2)
115 #define TM_YEAR_BASE 1900
118 /* Nonzero if YEAR is a leap year (every 4 years,
119 except every 100th isn't, and every 400th is). */
120 # define __isleap(year) \
121 ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
126 # define tzname __tzname
127 # define tzset __tzset
131 /* Portable standalone applications should supply a "time.h" that
132 declares a POSIX-compliant localtime_r, for the benefit of older
133 implementations that lack localtime_r or have a nonstandard one.
134 See the gnulib time_r module for one way to implement this. */
136 # undef __localtime_r
137 # define __gmtime_r gmtime_r
138 # define __localtime_r localtime_r
143 # define FPRINTFTIME 0
147 # define STREAM_OR_CHAR_T FILE
148 # define STRFTIME_ARG(x) /* empty */
150 # define STREAM_OR_CHAR_T CHAR_T
151 # define STRFTIME_ARG(x) x,
155 # define memset_byte(P, Len, Byte) \
156 do { size_t _i; for (_i = 0; _i < Len; _i++) fputc (Byte, P); } while (0)
157 # define memset_space(P, Len) memset_byte (P, Len, ' ')
158 # define memset_zero(P, Len) memset_byte (P, Len, '0')
159 #elif defined COMPILE_WIDE
160 # define memset_space(P, Len) (wmemset (P, L' ', Len), (P) += (Len))
161 # define memset_zero(P, Len) (wmemset (P, L'0', Len), (P) += (Len))
163 # define memset_space(P, Len) (memset (P, ' ', Len), (P) += (Len))
164 # define memset_zero(P, Len) (memset (P, '0', Len), (P) += (Len))
168 # define advance(P, N)
170 # define advance(P, N) ((P) += (N))
177 size_t _w = (width < 0 ? 0 : width); \
178 size_t _incr = _n < _w ? _w : _n; \
179 if (_incr >= maxsize - i) \
183 if (digits == 0 && _n < _w) \
185 size_t _delta = width - _n; \
186 if (pad == L_('0')) \
187 memset_zero (p, _delta); \
189 memset_space (p, _delta); \
198 # define add1(C) add (1, fputc (C, p))
200 # define add1(C) add (1, *p = C)
209 fwrite_lowcase (p, (s), _n); \
210 else if (to_uppcase) \
211 fwrite_uppcase (p, (s), _n); \
214 /* Ignore the value of fwrite. The caller can determine whether \
215 an error occurred by inspecting ferror (P). All known fwrite \
216 implementations set the stream's error indicator when they \
217 fail due to ENOMEM etc., even though C11 and POSIX.1-2008 do \
218 not require this. */ \
219 fwrite (s, _n, 1, p); \
228 memcpy_lowcase (p, (s), _n LOCALE_ARG); \
229 else if (to_uppcase) \
230 memcpy_uppcase (p, (s), _n LOCALE_ARG); \
232 MEMCPY ((void *) p, (void const *) (s), _n))
236 # ifndef USE_IN_EXTENDED_LOCALE_MODEL
237 # undef __mbsrtowcs_l
238 # define __mbsrtowcs_l(d, s, l, st, loc) __mbsrtowcs (d, s, l, st)
240 # define widen(os, ws, l) \
243 const char *__s = os; \
244 memset (&__st, '\0', sizeof (__st)); \
245 l = __mbsrtowcs_l (NULL, &__s, 0, &__st, loc); \
246 ws = (wchar_t *) alloca ((l + 1) * sizeof (wchar_t)); \
247 (void) __mbsrtowcs_l (ws, &__s, l, &__st, loc); \
252 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
253 /* We use this code also for the extended locale handling where the
254 function gets as an additional argument the locale which has to be
255 used. To access the values we have to redefine the _NL_CURRENT
257 # define strftime __strftime_l
258 # define wcsftime __wcsftime_l
260 # define _NL_CURRENT(category, item) \
261 (current->values[_NL_ITEM_INDEX (item)].string)
262 # define LOCALE_ARG , loc
263 # define LOCALE_PARAM_PROTO , __locale_t loc
264 # define HELPER_LOCALE_ARG , current
266 # define LOCALE_PARAM_PROTO
269 # define HELPER_LOCALE_ARG , _NL_CURRENT_DATA (LC_TIME)
271 # define HELPER_LOCALE_ARG
276 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
277 # define TOUPPER(Ch, L) __towupper_l (Ch, L)
278 # define TOLOWER(Ch, L) __towlower_l (Ch, L)
280 # define TOUPPER(Ch, L) towupper (Ch)
281 # define TOLOWER(Ch, L) towlower (Ch)
284 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
285 # define TOUPPER(Ch, L) __toupper_l (Ch, L)
286 # define TOLOWER(Ch, L) __tolower_l (Ch, L)
288 # define TOUPPER(Ch, L) toupper (Ch)
289 # define TOLOWER(Ch, L) tolower (Ch)
292 /* We don't use 'isdigit' here since the locale dependent
293 interpretation is not what we want here. We only need to accept
294 the arabic digits in the ASCII range. One day there is perhaps a
295 more reliable way to accept other sets of digits. */
296 #define ISDIGIT(Ch) ((unsigned int) (Ch) - L_('0') <= 9)
300 fwrite_lowcase (FILE *fp, const CHAR_T *src, size_t len)
304 fputc (TOLOWER ((UCHAR_T) *src, loc), fp);
310 fwrite_uppcase (FILE *fp, const CHAR_T *src, size_t len)
314 fputc (TOUPPER ((UCHAR_T) *src, loc), fp);
320 memcpy_lowcase (CHAR_T *dest, const CHAR_T *src,
321 size_t len LOCALE_PARAM_PROTO)
324 dest[len] = TOLOWER ((UCHAR_T) src[len], loc);
329 memcpy_uppcase (CHAR_T *dest, const CHAR_T *src,
330 size_t len LOCALE_PARAM_PROTO)
333 dest[len] = TOUPPER ((UCHAR_T) src[len], loc);
340 /* Yield the difference between *A and *B,
341 measured in seconds, ignoring leap seconds. */
342 # define tm_diff ftime_tm_diff
344 tm_diff (const struct tm *a, const struct tm *b)
346 /* Compute intervening leap days correctly even if year is negative.
347 Take care to avoid int overflow in leap day calculations,
348 but it's OK to assume that A and B are close to each other. */
349 int a4 = SHR (a->tm_year, 2) + SHR (TM_YEAR_BASE, 2) - ! (a->tm_year & 3);
350 int b4 = SHR (b->tm_year, 2) + SHR (TM_YEAR_BASE, 2) - ! (b->tm_year & 3);
351 int a100 = a4 / 25 - (a4 % 25 < 0);
352 int b100 = b4 / 25 - (b4 % 25 < 0);
353 int a400 = SHR (a100, 2);
354 int b400 = SHR (b100, 2);
355 int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
356 int years = a->tm_year - b->tm_year;
357 int days = (365 * years + intervening_leap_days
358 + (a->tm_yday - b->tm_yday));
359 return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
360 + (a->tm_min - b->tm_min))
361 + (a->tm_sec - b->tm_sec));
363 #endif /* ! HAVE_TM_GMTOFF */
367 /* The number of days from the first day of the first ISO week of this
368 year to the year day YDAY with week day WDAY. ISO weeks start on
369 Monday; the first ISO week has the year's first Thursday. YDAY may
370 be as small as YDAY_MINIMUM. */
371 #define ISO_WEEK_START_WDAY 1 /* Monday */
372 #define ISO_WEEK1_WDAY 4 /* Thursday */
373 #define YDAY_MINIMUM (-366)
378 iso_week_days (int yday, int wday)
380 /* Add enough to the first operand of % to make it nonnegative. */
381 int big_enough_multiple_of_7 = (-YDAY_MINIMUM / 7 + 2) * 7;
383 - (yday - wday + ISO_WEEK1_WDAY + big_enough_multiple_of_7) % 7
384 + ISO_WEEK1_WDAY - ISO_WEEK_START_WDAY);
388 /* When compiling this file, GNU applications can #define my_strftime
389 to a symbol (typically nstrftime) to get an extended strftime with
390 extra arguments UT and NS. Emacs is a special case for now, but
391 this Emacs-specific code can be removed once Emacs's config.h
392 defines my_strftime. */
393 #if defined emacs && !defined my_strftime
394 # define my_strftime nstrftime
399 # define my_strftime fprintftime
403 # define extra_args , ut, ns
404 # define extra_args_spec , int ut, int ns
406 # if defined COMPILE_WIDE
407 # define my_strftime wcsftime
408 # define nl_get_alt_digit _nl_get_walt_digit
410 # define my_strftime strftime
411 # define nl_get_alt_digit _nl_get_alt_digit
414 # define extra_args_spec
415 /* We don't have this information in general. */
421 /* Just like my_strftime, below, but with one more parameter, UPCASE,
422 to indicate that the result should be converted to upper case. */
424 strftime_case_ (bool upcase, STREAM_OR_CHAR_T *s,
425 STRFTIME_ARG (size_t maxsize)
426 const CHAR_T *format,
427 const struct tm *tp extra_args_spec LOCALE_PARAM_PROTO)
429 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
430 struct locale_data *const current = loc->__locales[LC_TIME];
433 size_t maxsize = (size_t) -1;
436 int hour12 = tp->tm_hour;
438 /* We cannot make the following values variables since we must delay
439 the evaluation of these values until really needed since some
440 expressions might not be valid in every situation. The 'struct tm'
441 might be generated by a strptime() call that initialized
442 only a few elements. Dereference the pointers only if the format
443 requires this. Then it is ok to fail if the pointers are invalid. */
445 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABDAY_1) + tp->tm_wday))
447 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(DAY_1) + tp->tm_wday))
449 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABMON_1) + tp->tm_mon))
451 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(MON_1) + tp->tm_mon))
453 ((const CHAR_T *) _NL_CURRENT (LC_TIME, tp->tm_hour > 11 \
454 ? NLW(PM_STR) : NLW(AM_STR)))
456 # define aw_len STRLEN (a_wkday)
457 # define am_len STRLEN (a_month)
458 # define ap_len STRLEN (ampm)
462 STREAM_OR_CHAR_T *p = s;
464 #if DO_MULTIBYTE && !defined COMPILE_WIDE
465 const char *format_end = NULL;
468 #if ! defined _LIBC && ! HAVE_RUN_TZSET_TEST
469 /* Solaris 2.5.x and 2.6 tzset sometimes modify the storage returned
470 by localtime. On such systems, we must either use the tzset and
471 localtime wrappers to work around the bug (which sets
472 HAVE_RUN_TZSET_TEST) or make a copy of the structure. */
473 struct tm copy = *tp;
479 /* The POSIX test suite assumes that setting
480 the environment variable TZ to a new value before calling strftime()
481 will influence the result (the %Z format) even if the information in
482 TP is computed with a totally different time zone.
483 This is bogus: though POSIX allows bad behavior like this,
484 POSIX does not require it. Do the right thing instead. */
485 zone = (const char *) tp->tm_zone;
490 if (! (zone && *zone))
495 /* POSIX.1 requires that local time zone information be used as
496 though strftime called tzset. */
509 for (f = format; *f != '\0'; ++f)
511 int pad = 0; /* Padding for number ('-', '_', or 0). */
512 int modifier; /* Field modifier ('E', 'O', or 0). */
513 int digits = 0; /* Max digits for numeric format. */
514 int number_value; /* Numeric value to be printed. */
515 unsigned int u_number_value; /* (unsigned int) number_value. */
516 bool negative_number; /* The number is negative. */
517 bool always_output_a_sign; /* +/- should always be output. */
518 int tz_colon_mask; /* Bitmask of where ':' should appear. */
519 const CHAR_T *subfmt;
523 + 2 /* for the two colons in a %::z or %:::z time zone */
524 + (sizeof (int) < sizeof (time_t)
525 ? INT_STRLEN_BOUND (time_t)
526 : INT_STRLEN_BOUND (int))];
528 bool to_lowcase = false;
529 bool to_uppcase = upcase;
531 bool change_case = false;
534 #if DO_MULTIBYTE && !defined COMPILE_WIDE
540 case L_('\b'): case L_('\t'): case L_('\n'):
541 case L_('\v'): case L_('\f'): case L_('\r'):
542 case L_(' '): case L_('!'): case L_('"'): case L_('#'): case L_('&'):
543 case L_('\''): case L_('('): case L_(')'): case L_('*'): case L_('+'):
544 case L_(','): case L_('-'): case L_('.'): case L_('/'): case L_('0'):
545 case L_('1'): case L_('2'): case L_('3'): case L_('4'): case L_('5'):
546 case L_('6'): case L_('7'): case L_('8'): case L_('9'): case L_(':'):
547 case L_(';'): case L_('<'): case L_('='): case L_('>'): case L_('?'):
548 case L_('A'): case L_('B'): case L_('C'): case L_('D'): case L_('E'):
549 case L_('F'): case L_('G'): case L_('H'): case L_('I'): case L_('J'):
550 case L_('K'): case L_('L'): case L_('M'): case L_('N'): case L_('O'):
551 case L_('P'): case L_('Q'): case L_('R'): case L_('S'): case L_('T'):
552 case L_('U'): case L_('V'): case L_('W'): case L_('X'): case L_('Y'):
553 case L_('Z'): case L_('['): case L_('\\'): case L_(']'): case L_('^'):
554 case L_('_'): case L_('a'): case L_('b'): case L_('c'): case L_('d'):
555 case L_('e'): case L_('f'): case L_('g'): case L_('h'): case L_('i'):
556 case L_('j'): case L_('k'): case L_('l'): case L_('m'): case L_('n'):
557 case L_('o'): case L_('p'): case L_('q'): case L_('r'): case L_('s'):
558 case L_('t'): case L_('u'): case L_('v'): case L_('w'): case L_('x'):
559 case L_('y'): case L_('z'): case L_('{'): case L_('|'): case L_('}'):
561 /* The C Standard requires these 98 characters (plus '%') to
562 be in the basic execution character set. None of these
563 characters can start a multibyte sequence, so they need
564 not be analyzed further. */
569 /* Copy this multibyte sequence until we reach its end, find
570 an error, or come back to the initial shift state. */
572 mbstate_t mbstate = mbstate_zero;
577 format_end = f + strlen (f) + 1;
578 fsize = format_end - f;
582 size_t bytes = mbrlen (f + len, fsize - len, &mbstate);
587 if (bytes == (size_t) -2)
589 len += strlen (f + len);
593 if (bytes == (size_t) -1)
601 while (! mbsinit (&mbstate));
609 #else /* ! DO_MULTIBYTE */
611 /* Either multibyte encodings are not supported, they are
612 safe for formats, so any non-'%' byte can be copied through,
613 or this is the wide character version. */
620 #endif /* ! DO_MULTIBYTE */
622 /* Check for flags that can modify a format. */
627 /* This influences the number formats. */
634 /* This changes textual output. */
648 /* As a GNU extension we allow to specify the field width. */
654 if (width > INT_MAX / 10
655 || (width == INT_MAX / 10 && *f - L_('0') > INT_MAX % 10))
656 /* Avoid overflow. */
661 width += *f - L_('0');
665 while (ISDIGIT (*f));
668 /* Check for modifiers. */
681 /* Now do the specified format. */
685 #define DO_NUMBER(d, v) \
693 #define DO_SIGNED_NUMBER(d, negative, v) \
697 negative_number = negative; \
698 u_number_value = v; \
699 goto do_signed_number; \
703 /* The mask is not what you might think.
704 When the ordinal i'th bit is set, insert a colon
705 before the i'th digit of the time zone representation. */
706 #define DO_TZ_OFFSET(d, negative, mask, v) \
710 negative_number = negative; \
711 tz_colon_mask = mask; \
712 u_number_value = v; \
716 #define DO_NUMBER_SPACEPAD(d, v) \
721 goto do_number_spacepad; \
740 cpy (aw_len, a_wkday);
743 goto underlying_strftime;
755 cpy (STRLEN (f_wkday), f_wkday);
758 goto underlying_strftime;
771 cpy (am_len, a_month);
774 goto underlying_strftime;
786 cpy (STRLEN (f_month), f_month);
789 goto underlying_strftime;
793 if (modifier == L_('O'))
796 if (! (modifier == 'E'
798 (const CHAR_T *) _NL_CURRENT (LC_TIME,
801 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_T_FMT));
803 goto underlying_strftime;
808 size_t len = strftime_case_ (to_uppcase,
809 NULL, STRFTIME_ARG ((size_t) -1)
811 tp extra_args LOCALE_ARG);
812 add (len, strftime_case_ (to_uppcase, p,
813 STRFTIME_ARG (maxsize - i)
815 tp extra_args LOCALE_ARG));
819 #if !(defined _NL_CURRENT && HAVE_STRUCT_ERA_ENTRY)
822 /* The relevant information is available only via the
823 underlying strftime implementation, so use that. */
826 char ubuf[1024]; /* enough for any single format in practice */
828 /* Make sure we're calling the actual underlying strftime.
829 In some cases, config.h contains something like
830 "#define strftime rpl_strftime". */
836 /* The space helps distinguish strftime failure from empty
844 len = strftime (ubuf, sizeof ubuf, ufmt, tp);
846 cpy (len - 1, ubuf + 1);
852 if (modifier == L_('O'))
854 if (modifier == L_('E'))
856 #if HAVE_STRUCT_ERA_ENTRY
857 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
861 size_t len = __wcslen (era->era_wname);
862 cpy (len, era->era_wname);
864 size_t len = strlen (era->era_name);
865 cpy (len, era->era_name);
870 goto underlying_strftime;
875 int century = tp->tm_year / 100 + TM_YEAR_BASE / 100;
876 century -= tp->tm_year % 100 < 0 && 0 < century;
877 DO_SIGNED_NUMBER (2, tp->tm_year < - TM_YEAR_BASE, century);
881 if (modifier == L_('O'))
884 if (! (modifier == L_('E')
886 (const CHAR_T *)_NL_CURRENT (LC_TIME, NLW(ERA_D_FMT)))
888 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_FMT));
891 goto underlying_strftime;
896 subfmt = L_("%m/%d/%y");
900 if (modifier == L_('E'))
903 DO_NUMBER (2, tp->tm_mday);
906 if (modifier == L_('E'))
909 DO_NUMBER_SPACEPAD (2, tp->tm_mday);
911 /* All numeric formats set DIGITS and NUMBER_VALUE (or U_NUMBER_VALUE)
912 and then jump to one of these labels. */
915 always_output_a_sign = true;
919 /* Force '_' flag unless overridden by '0' or '-' flag. */
920 if (pad != L_('0') && pad != L_('-'))
924 /* Format NUMBER_VALUE according to the MODIFIER flag. */
925 negative_number = number_value < 0;
926 u_number_value = number_value;
929 always_output_a_sign = false;
933 /* Format U_NUMBER_VALUE according to the MODIFIER flag.
934 NEGATIVE_NUMBER is nonzero if the original number was
935 negative; in this case it was converted directly to
936 unsigned int (i.e., modulo (UINT_MAX + 1)) without
938 if (modifier == L_('O') && !negative_number)
941 /* Get the locale specific alternate representation of
942 the number. If none exist NULL is returned. */
943 const CHAR_T *cp = nl_get_alt_digit (u_number_value
948 size_t digitlen = STRLEN (cp);
956 goto underlying_strftime;
960 bufp = buf + sizeof (buf) / sizeof (buf[0]);
963 u_number_value = - u_number_value;
967 if (tz_colon_mask & 1)
970 *--bufp = u_number_value % 10 + L_('0');
971 u_number_value /= 10;
973 while (u_number_value != 0 || tz_colon_mask != 0);
975 do_number_sign_and_padding:
979 sign_char = (negative_number ? L_('-')
980 : always_output_a_sign ? L_('+')
990 int padding = digits - (buf + (sizeof (buf) / sizeof (buf[0]))
991 - bufp) - !!sign_char;
997 if ((size_t) padding >= maxsize - i)
1001 memset_space (p, padding);
1003 width = width > padding ? width - padding : 0;
1009 if ((size_t) digits >= maxsize - i)
1016 memset_zero (p, padding);
1028 cpy (buf + sizeof (buf) / sizeof (buf[0]) - bufp, bufp);
1034 subfmt = L_("%Y-%m-%d");
1038 if (modifier == L_('E'))
1041 DO_NUMBER (2, tp->tm_hour);
1044 if (modifier == L_('E'))
1047 DO_NUMBER (2, hour12);
1049 case L_('k'): /* GNU extension. */
1050 if (modifier == L_('E'))
1053 DO_NUMBER_SPACEPAD (2, tp->tm_hour);
1055 case L_('l'): /* GNU extension. */
1056 if (modifier == L_('E'))
1059 DO_NUMBER_SPACEPAD (2, hour12);
1062 if (modifier == L_('E'))
1065 DO_SIGNED_NUMBER (3, tp->tm_yday < -1, tp->tm_yday + 1U);
1068 if (modifier == L_('E'))
1071 DO_NUMBER (2, tp->tm_min);
1074 if (modifier == L_('E'))
1077 DO_SIGNED_NUMBER (2, tp->tm_mon < -1, tp->tm_mon + 1U);
1080 case L_('N'): /* GNU extension. */
1081 if (modifier == L_('E'))
1089 /* Take an explicit width less than 9 as a precision. */
1091 for (j = width; j < 9; j++)
1095 DO_NUMBER (width, number_value);
1105 format_char = L_('p');
1119 goto underlying_strftime;
1123 subfmt = L_("%H:%M");
1128 if (*(subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME,
1131 subfmt = L_("%I:%M:%S %p");
1134 goto underlying_strftime;
1138 if (modifier == L_('E'))
1141 DO_NUMBER (2, tp->tm_sec);
1143 case L_('s'): /* GNU extension. */
1151 /* Generate string value for T using time_t arithmetic;
1152 this works even if sizeof (long) < sizeof (time_t). */
1154 bufp = buf + sizeof (buf) / sizeof (buf[0]);
1155 negative_number = t < 0;
1161 *--bufp = (negative_number ? -d : d) + L_('0');
1166 always_output_a_sign = false;
1167 goto do_number_sign_and_padding;
1171 if (modifier == L_('O'))
1174 if (! (modifier == L_('E')
1176 (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ERA_T_FMT)))
1178 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(T_FMT));
1181 goto underlying_strftime;
1184 subfmt = L_("%H:%M:%S");
1192 DO_NUMBER (1, (tp->tm_wday - 1 + 7) % 7 + 1);
1195 if (modifier == L_('E'))
1198 DO_NUMBER (2, (tp->tm_yday - tp->tm_wday + 7) / 7);
1203 if (modifier == L_('E'))
1206 /* YEAR is a leap year if and only if (tp->tm_year + TM_YEAR_BASE)
1207 is a leap year, except that YEAR and YEAR - 1 both work
1208 correctly even when (tp->tm_year + TM_YEAR_BASE) would
1210 int year = (tp->tm_year
1212 ? TM_YEAR_BASE % 400
1213 : TM_YEAR_BASE % 400 - 400));
1214 int year_adjust = 0;
1215 int days = iso_week_days (tp->tm_yday, tp->tm_wday);
1219 /* This ISO week belongs to the previous year. */
1221 days = iso_week_days (tp->tm_yday + (365 + __isleap (year - 1)),
1226 int d = iso_week_days (tp->tm_yday - (365 + __isleap (year)),
1230 /* This ISO week belongs to the next year. */
1240 int yy = (tp->tm_year % 100 + year_adjust) % 100;
1241 DO_NUMBER (2, (0 <= yy
1243 : tp->tm_year < -TM_YEAR_BASE - year_adjust
1249 DO_SIGNED_NUMBER (4, tp->tm_year < -TM_YEAR_BASE - year_adjust,
1250 (tp->tm_year + (unsigned int) TM_YEAR_BASE
1254 DO_NUMBER (2, days / 7 + 1);
1259 if (modifier == L_('E'))
1262 DO_NUMBER (2, (tp->tm_yday - (tp->tm_wday - 1 + 7) % 7 + 7) / 7);
1265 if (modifier == L_('E'))
1268 DO_NUMBER (1, tp->tm_wday);
1271 if (modifier == 'E')
1273 #if HAVE_STRUCT_ERA_ENTRY
1274 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
1277 # ifdef COMPILE_WIDE
1278 subfmt = era->era_wformat;
1280 subfmt = era->era_format;
1285 goto underlying_strftime;
1288 if (modifier == L_('O'))
1291 DO_SIGNED_NUMBER (4, tp->tm_year < -TM_YEAR_BASE,
1292 tp->tm_year + (unsigned int) TM_YEAR_BASE);
1295 if (modifier == L_('E'))
1297 #if HAVE_STRUCT_ERA_ENTRY
1298 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
1301 int delta = tp->tm_year - era->start_date[0];
1302 DO_NUMBER (1, (era->offset
1303 + delta * era->absolute_direction));
1306 goto underlying_strftime;
1311 int yy = tp->tm_year % 100;
1313 yy = tp->tm_year < - TM_YEAR_BASE ? -yy : yy + 100;
1325 /* The tzset() call might have changed the value. */
1326 if (!(zone && *zone) && tp->tm_isdst >= 0)
1327 zone = tzname[tp->tm_isdst != 0];
1334 /* The zone string is always given in multibyte form. We have
1335 to transform it first. */
1338 widen (zone, wczone, len);
1342 cpy (strlen (zone), zone);
1347 /* :, ::, and ::: are valid only just before 'z'.
1348 :::: etc. are rejected later. */
1349 for (colons = 1; f[colons] == L_(':'); colons++)
1351 if (f[colons] != L_('z'))
1354 goto do_z_conversion;
1360 if (tp->tm_isdst < 0)
1369 diff = tp->tm_gmtoff;
1382 if (lt == (time_t) -1)
1384 /* mktime returns -1 for errors, but -1 is also a
1385 valid time_t value. Check whether an error really
1389 if (! __localtime_r (<, &tm)
1390 || ((ltm.tm_sec ^ tm.tm_sec)
1391 | (ltm.tm_min ^ tm.tm_min)
1392 | (ltm.tm_hour ^ tm.tm_hour)
1393 | (ltm.tm_mday ^ tm.tm_mday)
1394 | (ltm.tm_mon ^ tm.tm_mon)
1395 | (ltm.tm_year ^ tm.tm_year)))
1399 if (! __gmtime_r (<, >m))
1402 diff = tm_diff (<m, >m);
1406 hour_diff = diff / 60 / 60;
1407 min_diff = diff / 60 % 60;
1408 sec_diff = diff % 60;
1413 DO_TZ_OFFSET (5, diff < 0, 0, hour_diff * 100 + min_diff);
1415 case 1: tz_hh_mm: /* +hh:mm */
1416 DO_TZ_OFFSET (6, diff < 0, 04, hour_diff * 100 + min_diff);
1418 case 2: tz_hh_mm_ss: /* +hh:mm:ss */
1419 DO_TZ_OFFSET (9, diff < 0, 024,
1420 hour_diff * 10000 + min_diff * 100 + sec_diff);
1422 case 3: /* +hh if possible, else +hh:mm, else +hh:mm:ss */
1427 DO_TZ_OFFSET (3, diff < 0, 0, hour_diff);
1434 case L_('\0'): /* GNU extension: % at end of format. */
1438 /* Unknown format; output the format, including the '%',
1439 since this is most likely the right thing to do if a
1440 multibyte string has been misparsed. */
1444 for (flen = 1; f[1 - flen] != L_('%'); flen++)
1446 cpy (flen, &f[1 - flen]);
1453 if (p && maxsize != 0)
1460 /* Write information from TP into S according to the format
1461 string FORMAT, writing no more that MAXSIZE characters
1462 (including the terminating '\0') and returning number of
1463 characters written. If S is NULL, nothing will be written
1464 anywhere, so to determine how many characters would be
1465 written, use NULL for S and (size_t) -1 for MAXSIZE. */
1467 my_strftime (STREAM_OR_CHAR_T *s, STRFTIME_ARG (size_t maxsize)
1468 const CHAR_T *format,
1469 const struct tm *tp extra_args_spec LOCALE_PARAM_PROTO)
1471 return strftime_case_ (false, s, STRFTIME_ARG (maxsize)
1472 format, tp extra_args LOCALE_ARG);
1475 #if defined _LIBC && ! FPRINTFTIME
1476 libc_hidden_def (my_strftime)
1480 #if defined emacs && ! FPRINTFTIME
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. */
1484 emacs_strftimeu (char *s, size_t maxsize, const char *format,
1485 const struct tm *tp, int ut)
1487 return my_strftime (s, maxsize, format, tp, ut, 0);