1 /* Copyright (C) 1991-2017 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public
6 License as published by the Free Software Foundation; either
7 version 3 of the License, or (at your option) any later version.
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 General Public License for more details.
14 You should have received a copy of the GNU General Public
15 License along with the GNU C Library; if not, see
16 <http://www.gnu.org/licenses/>. */
19 # define USE_IN_EXTENDED_LOCALE_MODEL 1
20 # define HAVE_STRUCT_ERA_ENTRY 1
21 # define HAVE_TM_GMTOFF 1
22 # define HAVE_TM_ZONE 1
23 # define HAVE_TZNAME 1
25 # include "../locale/localeinfo.h"
29 # include "fprintftime.h"
31 # include "strftime.h"
33 # include "time-internal.h"
39 #if HAVE_TZNAME && !HAVE_DECL_TZNAME
40 extern char *tzname
[];
43 /* Do multibyte processing if multibyte encodings are supported, unless
44 multibyte sequences are safe in formats. Multibyte sequences are
45 safe if they cannot contain byte sequences that look like format
46 conversion specifications. The multibyte encodings used by the
47 C library on the various platforms (UTF-8, GB2312, GBK, CP936,
48 GB18030, EUC-TW, BIG5, BIG5-HKSCS, CP950, EUC-JP, EUC-KR, CP949,
49 SHIFT_JIS, CP932, JOHAB) are safe for formats, because the byte '%'
50 cannot occur in a multibyte character except in the first byte.
52 The DEC-HANYU encoding used on OSF/1 is not safe for formats, but
53 this encoding has never been seen in real-life use, so we ignore
55 #if !(defined __osf__ && 0)
56 # define MULTIBYTE_IS_FORMAT_SAFE 1
58 #define DO_MULTIBYTE (! MULTIBYTE_IS_FORMAT_SAFE)
62 static const mbstate_t mbstate_zero
;
73 # define CHAR_T wchar_t
74 # define UCHAR_T unsigned int
75 # define L_(Str) L##Str
76 # define NLW(Sym) _NL_W##Sym
78 # define MEMCPY(d, s, n) __wmemcpy (d, s, n)
79 # define STRLEN(s) __wcslen (s)
83 # define UCHAR_T unsigned char
87 # define MEMCPY(d, s, n) memcpy (d, s, n)
88 # define STRLEN(s) strlen (s)
92 /* Shift A right by B bits portably, by dividing A by 2**B and
93 truncating towards minus infinity. A and B should be free of side
94 effects, and B should be in the range 0 <= B <= INT_BITS - 2, where
95 INT_BITS is the number of useful bits in an int. GNU code can
96 assume that INT_BITS is at least 32.
98 ISO C99 says that A >> B is implementation-defined if A < 0. Some
99 implementations (e.g., UNICOS 9.0 on a Cray Y-MP EL) don't shift
100 right in the usual way when A < 0, so SHR falls back on division if
101 ordinary A >> B doesn't seem to be the usual signed shift. */
105 : (a) / (1 << (b)) - ((a) % (1 << (b)) < 0))
107 /* Bound on length of the string representing an integer type or expression T.
108 Subtract 1 for the sign bit if t is signed; log10 (2.0) < 146/485;
109 add 1 for integer division truncation; add 1 more for a minus sign
111 #define INT_STRLEN_BOUND(t) \
112 ((sizeof (t) * CHAR_BIT - 1) * 146 / 485 + 2)
114 #define TM_YEAR_BASE 1900
117 /* Nonzero if YEAR is a leap year (every 4 years,
118 except every 100th isn't, and every 400th is). */
119 # define __isleap(year) \
120 ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
125 # define mktime_z(tz, tm) mktime (tm)
126 # define tzname __tzname
127 # define tzset __tzset
131 # define FPRINTFTIME 0
135 # define STREAM_OR_CHAR_T FILE
136 # define STRFTIME_ARG(x) /* empty */
138 # define STREAM_OR_CHAR_T CHAR_T
139 # define STRFTIME_ARG(x) x,
143 # define memset_byte(P, Len, Byte) \
144 do { size_t _i; for (_i = 0; _i < Len; _i++) fputc (Byte, P); } while (0)
145 # define memset_space(P, Len) memset_byte (P, Len, ' ')
146 # define memset_zero(P, Len) memset_byte (P, Len, '0')
147 #elif defined COMPILE_WIDE
148 # define memset_space(P, Len) (wmemset (P, L' ', Len), (P) += (Len))
149 # define memset_zero(P, Len) (wmemset (P, L'0', Len), (P) += (Len))
151 # define memset_space(P, Len) (memset (P, ' ', Len), (P) += (Len))
152 # define memset_zero(P, Len) (memset (P, '0', Len), (P) += (Len))
156 # define advance(P, N)
158 # define advance(P, N) ((P) += (N))
165 size_t _w = (width < 0 ? 0 : width); \
166 size_t _incr = _n < _w ? _w : _n; \
167 if (_incr >= maxsize - i) \
171 if (digits == 0 && _n < _w) \
173 size_t _delta = width - _n; \
174 if (pad == L_('0')) \
175 memset_zero (p, _delta); \
177 memset_space (p, _delta); \
186 # define add1(C) add (1, fputc (C, p))
188 # define add1(C) add (1, *p = C)
197 fwrite_lowcase (p, (s), _n); \
198 else if (to_uppcase) \
199 fwrite_uppcase (p, (s), _n); \
202 /* Ignore the value of fwrite. The caller can determine whether \
203 an error occurred by inspecting ferror (P). All known fwrite \
204 implementations set the stream's error indicator when they \
205 fail due to ENOMEM etc., even though C11 and POSIX.1-2008 do \
206 not require this. */ \
207 fwrite (s, _n, 1, p); \
216 memcpy_lowcase (p, (s), _n LOCALE_ARG); \
217 else if (to_uppcase) \
218 memcpy_uppcase (p, (s), _n LOCALE_ARG); \
220 MEMCPY ((void *) p, (void const *) (s), _n))
224 # ifndef USE_IN_EXTENDED_LOCALE_MODEL
225 # undef __mbsrtowcs_l
226 # define __mbsrtowcs_l(d, s, l, st, loc) __mbsrtowcs (d, s, l, st)
228 # define widen(os, ws, l) \
231 const char *__s = os; \
232 memset (&__st, '\0', sizeof (__st)); \
233 l = __mbsrtowcs_l (NULL, &__s, 0, &__st, loc); \
234 ws = (wchar_t *) alloca ((l + 1) * sizeof (wchar_t)); \
235 (void) __mbsrtowcs_l (ws, &__s, l, &__st, loc); \
240 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
241 /* We use this code also for the extended locale handling where the
242 function gets as an additional argument the locale which has to be
243 used. To access the values we have to redefine the _NL_CURRENT
245 # define strftime __strftime_l
246 # define wcsftime __wcsftime_l
248 # define _NL_CURRENT(category, item) \
249 (current->values[_NL_ITEM_INDEX (item)].string)
250 # define LOCALE_PARAM , __locale_t loc
251 # define LOCALE_ARG , loc
252 # define HELPER_LOCALE_ARG , current
254 # define LOCALE_PARAM
257 # define HELPER_LOCALE_ARG , _NL_CURRENT_DATA (LC_TIME)
259 # define HELPER_LOCALE_ARG
264 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
265 # define TOUPPER(Ch, L) __towupper_l (Ch, L)
266 # define TOLOWER(Ch, L) __towlower_l (Ch, L)
268 # define TOUPPER(Ch, L) towupper (Ch)
269 # define TOLOWER(Ch, L) towlower (Ch)
272 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
273 # define TOUPPER(Ch, L) __toupper_l (Ch, L)
274 # define TOLOWER(Ch, L) __tolower_l (Ch, L)
276 # define TOUPPER(Ch, L) toupper (Ch)
277 # define TOLOWER(Ch, L) tolower (Ch)
280 /* We don't use 'isdigit' here since the locale dependent
281 interpretation is not what we want here. We only need to accept
282 the arabic digits in the ASCII range. One day there is perhaps a
283 more reliable way to accept other sets of digits. */
284 #define ISDIGIT(Ch) ((unsigned int) (Ch) - L_('0') <= 9)
288 fwrite_lowcase (FILE *fp
, const CHAR_T
*src
, size_t len
)
292 fputc (TOLOWER ((UCHAR_T
) *src
, loc
), fp
);
298 fwrite_uppcase (FILE *fp
, const CHAR_T
*src
, size_t len
)
302 fputc (TOUPPER ((UCHAR_T
) *src
, loc
), fp
);
307 static CHAR_T
*memcpy_lowcase (CHAR_T
*dest
, const CHAR_T
*src
,
308 size_t len LOCALE_PARAM
);
311 memcpy_lowcase (CHAR_T
*dest
, const CHAR_T
*src
, size_t len LOCALE_PARAM
)
314 dest
[len
] = TOLOWER ((UCHAR_T
) src
[len
], loc
);
318 static CHAR_T
*memcpy_uppcase (CHAR_T
*dest
, const CHAR_T
*src
,
319 size_t len LOCALE_PARAM
);
322 memcpy_uppcase (CHAR_T
*dest
, const CHAR_T
*src
, size_t len LOCALE_PARAM
)
325 dest
[len
] = TOUPPER ((UCHAR_T
) src
[len
], loc
);
332 /* Yield the difference between *A and *B,
333 measured in seconds, ignoring leap seconds. */
334 # define tm_diff ftime_tm_diff
335 static int tm_diff (const struct tm
*, const struct tm
*);
337 tm_diff (const struct tm
*a
, const struct tm
*b
)
339 /* Compute intervening leap days correctly even if year is negative.
340 Take care to avoid int overflow in leap day calculations,
341 but it's OK to assume that A and B are close to each other. */
342 int a4
= SHR (a
->tm_year
, 2) + SHR (TM_YEAR_BASE
, 2) - ! (a
->tm_year
& 3);
343 int b4
= SHR (b
->tm_year
, 2) + SHR (TM_YEAR_BASE
, 2) - ! (b
->tm_year
& 3);
344 int a100
= a4
/ 25 - (a4
% 25 < 0);
345 int b100
= b4
/ 25 - (b4
% 25 < 0);
346 int a400
= SHR (a100
, 2);
347 int b400
= SHR (b100
, 2);
348 int intervening_leap_days
= (a4
- b4
) - (a100
- b100
) + (a400
- b400
);
349 int years
= a
->tm_year
- b
->tm_year
;
350 int days
= (365 * years
+ intervening_leap_days
351 + (a
->tm_yday
- b
->tm_yday
));
352 return (60 * (60 * (24 * days
+ (a
->tm_hour
- b
->tm_hour
))
353 + (a
->tm_min
- b
->tm_min
))
354 + (a
->tm_sec
- b
->tm_sec
));
356 #endif /* ! HAVE_TM_GMTOFF */
360 /* The number of days from the first day of the first ISO week of this
361 year to the year day YDAY with week day WDAY. ISO weeks start on
362 Monday; the first ISO week has the year's first Thursday. YDAY may
363 be as small as YDAY_MINIMUM. */
364 #define ISO_WEEK_START_WDAY 1 /* Monday */
365 #define ISO_WEEK1_WDAY 4 /* Thursday */
366 #define YDAY_MINIMUM (-366)
367 static int iso_week_days (int, int);
372 iso_week_days (int yday
, int wday
)
374 /* Add enough to the first operand of % to make it nonnegative. */
375 int big_enough_multiple_of_7
= (-YDAY_MINIMUM
/ 7 + 2) * 7;
377 - (yday
- wday
+ ISO_WEEK1_WDAY
+ big_enough_multiple_of_7
) % 7
378 + ISO_WEEK1_WDAY
- ISO_WEEK_START_WDAY
);
382 /* When compiling this file, GNU applications can #define my_strftime
383 to a symbol (typically nstrftime) to get an extended strftime with
384 extra arguments TZ and NS. */
388 # define my_strftime fprintftime
393 # define extra_args , tz, ns
394 # define extra_args_spec , timezone_t tz, int ns
396 # if defined COMPILE_WIDE
397 # define my_strftime wcsftime
398 # define nl_get_alt_digit _nl_get_walt_digit
400 # define my_strftime strftime
401 # define nl_get_alt_digit _nl_get_alt_digit
404 # define extra_args_spec
405 /* We don't have this information in general. */
410 static size_t __strftime_internal (STREAM_OR_CHAR_T
*, STRFTIME_ARG (size_t)
411 const CHAR_T
*, const struct tm
*,
413 extra_args_spec LOCALE_PARAM
);
415 /* Write information from TP into S according to the format
416 string FORMAT, writing no more that MAXSIZE characters
417 (including the terminating '\0') and returning number of
418 characters written. If S is NULL, nothing will be written
419 anywhere, so to determine how many characters would be
420 written, use NULL for S and (size_t) -1 for MAXSIZE. */
422 my_strftime (STREAM_OR_CHAR_T
*s
, STRFTIME_ARG (size_t maxsize
)
423 const CHAR_T
*format
,
424 const struct tm
*tp extra_args_spec LOCALE_PARAM
)
426 bool tzset_called
= false;
427 return __strftime_internal (s
, STRFTIME_ARG (maxsize
) format
, tp
,
428 false, &tzset_called extra_args LOCALE_ARG
);
430 #if defined _LIBC && ! FPRINTFTIME
431 libc_hidden_def (my_strftime
)
434 /* Just like my_strftime, above, but with two more parameters.
435 UPCASE indicate that the result should be converted to upper case,
436 and *TZSET_CALLED indicates whether tzset has been called here. */
438 __strftime_internal (STREAM_OR_CHAR_T
*s
, STRFTIME_ARG (size_t maxsize
)
439 const CHAR_T
*format
,
440 const struct tm
*tp
, bool upcase
, bool *tzset_called
441 extra_args_spec LOCALE_PARAM
)
443 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
444 struct __locale_data
*const current
= loc
->__locales
[LC_TIME
];
447 size_t maxsize
= (size_t) -1;
450 int hour12
= tp
->tm_hour
;
452 /* We cannot make the following values variables since we must delay
453 the evaluation of these values until really needed since some
454 expressions might not be valid in every situation. The 'struct tm'
455 might be generated by a strptime() call that initialized
456 only a few elements. Dereference the pointers only if the format
457 requires this. Then it is ok to fail if the pointers are invalid. */
459 ((const CHAR_T *) (tp->tm_wday < 0 || tp->tm_wday > 6 \
460 ? "?" : _NL_CURRENT (LC_TIME, NLW(ABDAY_1) + tp->tm_wday)))
462 ((const CHAR_T *) (tp->tm_wday < 0 || tp->tm_wday > 6 \
463 ? "?" : _NL_CURRENT (LC_TIME, NLW(DAY_1) + tp->tm_wday)))
465 ((const CHAR_T *) (tp->tm_mon < 0 || tp->tm_mon > 11 \
466 ? "?" : _NL_CURRENT (LC_TIME, NLW(ABMON_1) + tp->tm_mon)))
468 ((const CHAR_T *) (tp->tm_mon < 0 || tp->tm_mon > 11 \
469 ? "?" : _NL_CURRENT (LC_TIME, NLW(MON_1) + tp->tm_mon)))
471 ((const CHAR_T *) _NL_CURRENT (LC_TIME, tp->tm_hour > 11 \
472 ? NLW(PM_STR) : NLW(AM_STR)))
474 # define aw_len STRLEN (a_wkday)
475 # define am_len STRLEN (a_month)
476 # define ap_len STRLEN (ampm)
479 char **tzname_vec
= tzname
;
483 STREAM_OR_CHAR_T
*p
= s
;
485 #if DO_MULTIBYTE && !defined COMPILE_WIDE
486 const char *format_end
= NULL
;
489 #if ! defined _LIBC && ! HAVE_RUN_TZSET_TEST
490 /* Solaris 2.5.x and 2.6 tzset sometimes modify the storage returned
491 by localtime. On such systems, we must either use the tzset and
492 localtime wrappers to work around the bug (which sets
493 HAVE_RUN_TZSET_TEST) or make a copy of the structure. */
494 struct tm copy
= *tp
;
500 /* The POSIX test suite assumes that setting
501 the environment variable TZ to a new value before calling strftime()
502 will influence the result (the %Z format) even if the information in
503 TP is computed with a totally different time zone.
504 This is bogus: though POSIX allows bad behavior like this,
505 POSIX does not require it. Do the right thing instead. */
506 zone
= (const char *) tp
->tm_zone
;
511 if (! (zone
&& *zone
))
517 /* Infer the zone name from *TZ instead of from TZNAME. */
518 tzname_vec
= tz
->tzname_copy
;
521 /* The tzset() call might have changed the value. */
522 if (!(zone
&& *zone
) && tp
->tm_isdst
>= 0)
524 /* POSIX.1 requires that local time zone information be used as
525 though strftime called tzset. */
530 *tzset_called
= true;
533 zone
= tzname_vec
[tp
->tm_isdst
!= 0];
545 for (f
= format
; *f
!= '\0'; ++f
)
547 int pad
= 0; /* Padding for number ('-', '_', or 0). */
548 int modifier
; /* Field modifier ('E', 'O', or 0). */
549 int digits
= 0; /* Max digits for numeric format. */
550 int number_value
; /* Numeric value to be printed. */
551 unsigned int u_number_value
; /* (unsigned int) number_value. */
552 bool negative_number
; /* The number is negative. */
553 bool always_output_a_sign
; /* +/- should always be output. */
554 int tz_colon_mask
; /* Bitmask of where ':' should appear. */
555 const CHAR_T
*subfmt
;
559 + 2 /* for the two colons in a %::z or %:::z time zone */
560 + (sizeof (int) < sizeof (time_t)
561 ? INT_STRLEN_BOUND (time_t)
562 : INT_STRLEN_BOUND (int))];
564 bool to_lowcase
= false;
565 bool to_uppcase
= upcase
;
567 bool change_case
= false;
570 #if DO_MULTIBYTE && !defined COMPILE_WIDE
576 case L_('\b'): case L_('\t'): case L_('\n'):
577 case L_('\v'): case L_('\f'): case L_('\r'):
578 case L_(' '): case L_('!'): case L_('"'): case L_('#'): case L_('&'):
579 case L_('\''): case L_('('): case L_(')'): case L_('*'): case L_('+'):
580 case L_(','): case L_('-'): case L_('.'): case L_('/'): case L_('0'):
581 case L_('1'): case L_('2'): case L_('3'): case L_('4'): case L_('5'):
582 case L_('6'): case L_('7'): case L_('8'): case L_('9'): case L_(':'):
583 case L_(';'): case L_('<'): case L_('='): case L_('>'): case L_('?'):
584 case L_('A'): case L_('B'): case L_('C'): case L_('D'): case L_('E'):
585 case L_('F'): case L_('G'): case L_('H'): case L_('I'): case L_('J'):
586 case L_('K'): case L_('L'): case L_('M'): case L_('N'): case L_('O'):
587 case L_('P'): case L_('Q'): case L_('R'): case L_('S'): case L_('T'):
588 case L_('U'): case L_('V'): case L_('W'): case L_('X'): case L_('Y'):
589 case L_('Z'): case L_('['): case L_('\\'): case L_(']'): case L_('^'):
590 case L_('_'): case L_('a'): case L_('b'): case L_('c'): case L_('d'):
591 case L_('e'): case L_('f'): case L_('g'): case L_('h'): case L_('i'):
592 case L_('j'): case L_('k'): case L_('l'): case L_('m'): case L_('n'):
593 case L_('o'): case L_('p'): case L_('q'): case L_('r'): case L_('s'):
594 case L_('t'): case L_('u'): case L_('v'): case L_('w'): case L_('x'):
595 case L_('y'): case L_('z'): case L_('{'): case L_('|'): case L_('}'):
597 /* The C Standard requires these 98 characters (plus '%') to
598 be in the basic execution character set. None of these
599 characters can start a multibyte sequence, so they need
600 not be analyzed further. */
605 /* Copy this multibyte sequence until we reach its end, find
606 an error, or come back to the initial shift state. */
608 mbstate_t mbstate
= mbstate_zero
;
613 format_end
= f
+ strlen (f
) + 1;
614 fsize
= format_end
- f
;
618 size_t bytes
= mbrlen (f
+ len
, fsize
- len
, &mbstate
);
623 if (bytes
== (size_t) -2)
625 len
+= strlen (f
+ len
);
629 if (bytes
== (size_t) -1)
637 while (! mbsinit (&mbstate
));
645 #else /* ! DO_MULTIBYTE */
647 /* Either multibyte encodings are not supported, they are
648 safe for formats, so any non-'%' byte can be copied through,
649 or this is the wide character version. */
656 #endif /* ! DO_MULTIBYTE */
658 /* Check for flags that can modify a format. */
663 /* This influences the number formats. */
670 /* This changes textual output. */
684 /* As a GNU extension we allow the field width to be specified. */
690 if (width
> INT_MAX
/ 10
691 || (width
== INT_MAX
/ 10 && *f
- L_('0') > INT_MAX
% 10))
692 /* Avoid overflow. */
697 width
+= *f
- L_('0');
701 while (ISDIGIT (*f
));
704 /* Check for modifiers. */
717 /* Now do the specified format. */
721 #define DO_NUMBER(d, v) \
729 #define DO_SIGNED_NUMBER(d, negative, v) \
733 negative_number = negative; \
734 u_number_value = v; \
735 goto do_signed_number; \
739 /* The mask is not what you might think.
740 When the ordinal i'th bit is set, insert a colon
741 before the i'th digit of the time zone representation. */
742 #define DO_TZ_OFFSET(d, mask, v) \
746 tz_colon_mask = mask; \
747 u_number_value = v; \
751 #define DO_NUMBER_SPACEPAD(d, v) \
756 goto do_number_spacepad; \
775 cpy (aw_len
, a_wkday
);
778 goto underlying_strftime
;
790 cpy (STRLEN (f_wkday
), f_wkday
);
793 goto underlying_strftime
;
806 cpy (am_len
, a_month
);
809 goto underlying_strftime
;
821 cpy (STRLEN (f_month
), f_month
);
824 goto underlying_strftime
;
828 if (modifier
== L_('O'))
831 if (! (modifier
== 'E'
833 (const CHAR_T
*) _NL_CURRENT (LC_TIME
,
836 subfmt
= (const CHAR_T
*) _NL_CURRENT (LC_TIME
, NLW(D_T_FMT
));
838 goto underlying_strftime
;
843 size_t len
= __strftime_internal (NULL
, STRFTIME_ARG ((size_t) -1)
845 tp
, to_uppcase
, tzset_called
846 extra_args LOCALE_ARG
);
847 add (len
, __strftime_internal (p
,
848 STRFTIME_ARG (maxsize
- i
)
850 tp
, to_uppcase
, tzset_called
851 extra_args LOCALE_ARG
));
855 #if !(defined _NL_CURRENT && HAVE_STRUCT_ERA_ENTRY)
858 /* The relevant information is available only via the
859 underlying strftime implementation, so use that. */
862 char ubuf
[1024]; /* enough for any single format in practice */
864 /* Make sure we're calling the actual underlying strftime.
865 In some cases, config.h contains something like
866 "#define strftime rpl_strftime". */
872 /* The space helps distinguish strftime failure from empty
880 len
= strftime (ubuf
, sizeof ubuf
, ufmt
, tp
);
882 cpy (len
- 1, ubuf
+ 1);
888 if (modifier
== L_('E'))
890 #if HAVE_STRUCT_ERA_ENTRY
891 struct era_entry
*era
= _nl_get_era_entry (tp HELPER_LOCALE_ARG
);
895 size_t len
= __wcslen (era
->era_wname
);
896 cpy (len
, era
->era_wname
);
898 size_t len
= strlen (era
->era_name
);
899 cpy (len
, era
->era_name
);
904 goto underlying_strftime
;
909 int century
= tp
->tm_year
/ 100 + TM_YEAR_BASE
/ 100;
910 century
-= tp
->tm_year
% 100 < 0 && 0 < century
;
911 DO_SIGNED_NUMBER (2, tp
->tm_year
< - TM_YEAR_BASE
, century
);
915 if (modifier
== L_('O'))
918 if (! (modifier
== L_('E')
920 (const CHAR_T
*)_NL_CURRENT (LC_TIME
, NLW(ERA_D_FMT
)))
922 subfmt
= (const CHAR_T
*) _NL_CURRENT (LC_TIME
, NLW(D_FMT
));
925 goto underlying_strftime
;
930 subfmt
= L_("%m/%d/%y");
934 if (modifier
== L_('E'))
937 DO_NUMBER (2, tp
->tm_mday
);
940 if (modifier
== L_('E'))
943 DO_NUMBER_SPACEPAD (2, tp
->tm_mday
);
945 /* All numeric formats set DIGITS and NUMBER_VALUE (or U_NUMBER_VALUE)
946 and then jump to one of these labels. */
949 always_output_a_sign
= true;
953 /* Force '_' flag unless overridden by '0' or '-' flag. */
954 if (pad
!= L_('0') && pad
!= L_('-'))
958 /* Format NUMBER_VALUE according to the MODIFIER flag. */
959 negative_number
= number_value
< 0;
960 u_number_value
= number_value
;
963 always_output_a_sign
= false;
967 /* Format U_NUMBER_VALUE according to the MODIFIER flag.
968 NEGATIVE_NUMBER is nonzero if the original number was
969 negative; in this case it was converted directly to
970 unsigned int (i.e., modulo (UINT_MAX + 1)) without
972 if (modifier
== L_('O') && !negative_number
)
975 /* Get the locale specific alternate representation of
976 the number. If none exist NULL is returned. */
977 const CHAR_T
*cp
= nl_get_alt_digit (u_number_value
982 size_t digitlen
= STRLEN (cp
);
990 goto underlying_strftime
;
994 bufp
= buf
+ sizeof (buf
) / sizeof (buf
[0]);
997 u_number_value
= - u_number_value
;
1001 if (tz_colon_mask
& 1)
1003 tz_colon_mask
>>= 1;
1004 *--bufp
= u_number_value
% 10 + L_('0');
1005 u_number_value
/= 10;
1007 while (u_number_value
!= 0 || tz_colon_mask
!= 0);
1009 do_number_sign_and_padding
:
1013 sign_char
= (negative_number
? L_('-')
1014 : always_output_a_sign
? L_('+')
1024 int padding
= digits
- (buf
+ (sizeof (buf
) / sizeof (buf
[0]))
1025 - bufp
) - !!sign_char
;
1031 if ((size_t) padding
>= maxsize
- i
)
1035 memset_space (p
, padding
);
1037 width
= width
> padding
? width
- padding
: 0;
1043 if ((size_t) digits
>= maxsize
- i
)
1050 memset_zero (p
, padding
);
1062 cpy (buf
+ sizeof (buf
) / sizeof (buf
[0]) - bufp
, bufp
);
1068 subfmt
= L_("%Y-%m-%d");
1072 if (modifier
== L_('E'))
1075 DO_NUMBER (2, tp
->tm_hour
);
1078 if (modifier
== L_('E'))
1081 DO_NUMBER (2, hour12
);
1083 case L_('k'): /* GNU extension. */
1084 if (modifier
== L_('E'))
1087 DO_NUMBER_SPACEPAD (2, tp
->tm_hour
);
1089 case L_('l'): /* GNU extension. */
1090 if (modifier
== L_('E'))
1093 DO_NUMBER_SPACEPAD (2, hour12
);
1096 if (modifier
== L_('E'))
1099 DO_SIGNED_NUMBER (3, tp
->tm_yday
< -1, tp
->tm_yday
+ 1U);
1102 if (modifier
== L_('E'))
1105 DO_NUMBER (2, tp
->tm_min
);
1108 if (modifier
== L_('E'))
1111 DO_SIGNED_NUMBER (2, tp
->tm_mon
< -1, tp
->tm_mon
+ 1U);
1114 case L_('N'): /* GNU extension. */
1115 if (modifier
== L_('E'))
1123 /* Take an explicit width less than 9 as a precision. */
1125 for (j
= width
; j
< 9; j
++)
1129 DO_NUMBER (width
, number_value
);
1139 format_char
= L_('p');
1153 goto underlying_strftime
;
1156 case L_('q'): /* GNU extension. */
1157 DO_SIGNED_NUMBER (1, false, ((tp
->tm_mon
* 11) >> 5) + 1);
1161 subfmt
= L_("%H:%M");
1166 if (*(subfmt
= (const CHAR_T
*) _NL_CURRENT (LC_TIME
,
1169 subfmt
= L_("%I:%M:%S %p");
1172 goto underlying_strftime
;
1176 if (modifier
== L_('E'))
1179 DO_NUMBER (2, tp
->tm_sec
);
1181 case L_('s'): /* GNU extension. */
1187 t
= mktime_z (tz
, <m
);
1189 /* Generate string value for T using time_t arithmetic;
1190 this works even if sizeof (long) < sizeof (time_t). */
1192 bufp
= buf
+ sizeof (buf
) / sizeof (buf
[0]);
1193 negative_number
= t
< 0;
1199 *--bufp
= (negative_number
? -d
: d
) + L_('0');
1204 always_output_a_sign
= false;
1205 goto do_number_sign_and_padding
;
1209 if (modifier
== L_('O'))
1212 if (! (modifier
== L_('E')
1214 (const CHAR_T
*) _NL_CURRENT (LC_TIME
, NLW(ERA_T_FMT
)))
1216 subfmt
= (const CHAR_T
*) _NL_CURRENT (LC_TIME
, NLW(T_FMT
));
1219 goto underlying_strftime
;
1222 subfmt
= L_("%H:%M:%S");
1230 DO_NUMBER (1, (tp
->tm_wday
- 1 + 7) % 7 + 1);
1233 if (modifier
== L_('E'))
1236 DO_NUMBER (2, (tp
->tm_yday
- tp
->tm_wday
+ 7) / 7);
1241 if (modifier
== L_('E'))
1244 /* YEAR is a leap year if and only if (tp->tm_year + TM_YEAR_BASE)
1245 is a leap year, except that YEAR and YEAR - 1 both work
1246 correctly even when (tp->tm_year + TM_YEAR_BASE) would
1248 int year
= (tp
->tm_year
1250 ? TM_YEAR_BASE
% 400
1251 : TM_YEAR_BASE
% 400 - 400));
1252 int year_adjust
= 0;
1253 int days
= iso_week_days (tp
->tm_yday
, tp
->tm_wday
);
1257 /* This ISO week belongs to the previous year. */
1259 days
= iso_week_days (tp
->tm_yday
+ (365 + __isleap (year
- 1)),
1264 int d
= iso_week_days (tp
->tm_yday
- (365 + __isleap (year
)),
1268 /* This ISO week belongs to the next year. */
1278 int yy
= (tp
->tm_year
% 100 + year_adjust
) % 100;
1279 DO_NUMBER (2, (0 <= yy
1281 : tp
->tm_year
< -TM_YEAR_BASE
- year_adjust
1287 DO_SIGNED_NUMBER (4, tp
->tm_year
< -TM_YEAR_BASE
- year_adjust
,
1288 (tp
->tm_year
+ (unsigned int) TM_YEAR_BASE
1292 DO_NUMBER (2, days
/ 7 + 1);
1297 if (modifier
== L_('E'))
1300 DO_NUMBER (2, (tp
->tm_yday
- (tp
->tm_wday
- 1 + 7) % 7 + 7) / 7);
1303 if (modifier
== L_('E'))
1306 DO_NUMBER (1, tp
->tm_wday
);
1309 if (modifier
== 'E')
1311 #if HAVE_STRUCT_ERA_ENTRY
1312 struct era_entry
*era
= _nl_get_era_entry (tp HELPER_LOCALE_ARG
);
1315 # ifdef COMPILE_WIDE
1316 subfmt
= era
->era_wformat
;
1318 subfmt
= era
->era_format
;
1323 goto underlying_strftime
;
1326 if (modifier
== L_('O'))
1329 DO_SIGNED_NUMBER (4, tp
->tm_year
< -TM_YEAR_BASE
,
1330 tp
->tm_year
+ (unsigned int) TM_YEAR_BASE
);
1333 if (modifier
== L_('E'))
1335 #if HAVE_STRUCT_ERA_ENTRY
1336 struct era_entry
*era
= _nl_get_era_entry (tp HELPER_LOCALE_ARG
);
1339 int delta
= tp
->tm_year
- era
->start_date
[0];
1340 DO_NUMBER (1, (era
->offset
1341 + delta
* era
->absolute_direction
));
1344 goto underlying_strftime
;
1349 int yy
= tp
->tm_year
% 100;
1351 yy
= tp
->tm_year
< - TM_YEAR_BASE
? -yy
: yy
+ 100;
1364 /* The zone string is always given in multibyte form. We have
1365 to transform it first. */
1368 widen (zone
, wczone
, len
);
1372 cpy (strlen (zone
), zone
);
1377 /* :, ::, and ::: are valid only just before 'z'.
1378 :::: etc. are rejected later. */
1379 for (colons
= 1; f
[colons
] == L_(':'); colons
++)
1381 if (f
[colons
] != L_('z'))
1384 goto do_z_conversion
;
1390 if (tp
->tm_isdst
< 0)
1399 diff
= tp
->tm_gmtoff
;
1409 /* POSIX.1 requires that local time zone information be used as
1410 though strftime called tzset. */
1415 *tzset_called
= true;
1420 lt
= mktime_z (tz
, <m
);
1422 if (lt
== (time_t) -1)
1424 /* mktime returns -1 for errors, but -1 is also a
1425 valid time_t value. Check whether an error really
1429 if (! localtime_rz (tz
, <
, &tm
)
1430 || ((ltm
.tm_sec
^ tm
.tm_sec
)
1431 | (ltm
.tm_min
^ tm
.tm_min
)
1432 | (ltm
.tm_hour
^ tm
.tm_hour
)
1433 | (ltm
.tm_mday
^ tm
.tm_mday
)
1434 | (ltm
.tm_mon
^ tm
.tm_mon
)
1435 | (ltm
.tm_year
^ tm
.tm_year
)))
1439 if (! localtime_rz (0, <
, >m
))
1442 diff
= tm_diff (<m
, >m
);
1446 negative_number
= diff
< 0 || (diff
== 0 && *zone
== '-');
1447 hour_diff
= diff
/ 60 / 60;
1448 min_diff
= diff
/ 60 % 60;
1449 sec_diff
= diff
% 60;
1454 DO_TZ_OFFSET (5, 0, hour_diff
* 100 + min_diff
);
1456 case 1: tz_hh_mm
: /* +hh:mm */
1457 DO_TZ_OFFSET (6, 04, hour_diff
* 100 + min_diff
);
1459 case 2: tz_hh_mm_ss
: /* +hh:mm:ss */
1460 DO_TZ_OFFSET (9, 024,
1461 hour_diff
* 10000 + min_diff
* 100 + sec_diff
);
1463 case 3: /* +hh if possible, else +hh:mm, else +hh:mm:ss */
1468 DO_TZ_OFFSET (3, 0, hour_diff
);
1475 case L_('\0'): /* GNU extension: % at end of format. */
1479 /* Unknown format; output the format, including the '%',
1480 since this is most likely the right thing to do if a
1481 multibyte string has been misparsed. */
1485 for (flen
= 1; f
[1 - flen
] != L_('%'); flen
++)
1487 cpy (flen
, &f
[1 - flen
]);
1494 if (p
&& maxsize
!= 0)