1 /* Copyright (C) 1991-2001, 2003-2007, 2009-2015 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 3 of the License, or
10 (at your option) any later version.
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
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 # define HAVE_STRUCT_ERA_ENTRY 1
22 # define HAVE_TM_GMTOFF 1
23 # define HAVE_TM_ZONE 1
24 # define HAVE_TZNAME 1
26 # include "../locale/localeinfo.h"
30 # include "fprintftime.h"
32 # include "strftime.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 tzname __tzname
126 # define tzset __tzset
130 /* Portable standalone applications should supply a "time.h" that
131 declares a POSIX-compliant localtime_r, for the benefit of older
132 implementations that lack localtime_r or have a nonstandard one.
133 See the gnulib time_r module for one way to implement this. */
135 # undef __localtime_r
136 # define __gmtime_r gmtime_r
137 # define __localtime_r localtime_r
142 # define FPRINTFTIME 0
146 # define STREAM_OR_CHAR_T FILE
147 # define STRFTIME_ARG(x) /* empty */
149 # define STREAM_OR_CHAR_T CHAR_T
150 # define STRFTIME_ARG(x) x,
154 # define memset_byte(P, Len, Byte) \
155 do { size_t _i; for (_i = 0; _i < Len; _i++) fputc (Byte, P); } while (0)
156 # define memset_space(P, Len) memset_byte (P, Len, ' ')
157 # define memset_zero(P, Len) memset_byte (P, Len, '0')
158 #elif defined COMPILE_WIDE
159 # define memset_space(P, Len) (wmemset (P, L' ', Len), (P) += (Len))
160 # define memset_zero(P, Len) (wmemset (P, L'0', Len), (P) += (Len))
162 # define memset_space(P, Len) (memset (P, ' ', Len), (P) += (Len))
163 # define memset_zero(P, Len) (memset (P, '0', Len), (P) += (Len))
167 # define advance(P, N)
169 # define advance(P, N) ((P) += (N))
176 size_t _w = (width < 0 ? 0 : width); \
177 size_t _incr = _n < _w ? _w : _n; \
178 if (_incr >= maxsize - i) \
182 if (digits == 0 && _n < _w) \
184 size_t _delta = width - _n; \
185 if (pad == L_('0')) \
186 memset_zero (p, _delta); \
188 memset_space (p, _delta); \
197 # define add1(C) add (1, fputc (C, p))
199 # define add1(C) add (1, *p = C)
208 fwrite_lowcase (p, (s), _n); \
209 else if (to_uppcase) \
210 fwrite_uppcase (p, (s), _n); \
213 /* Ignore the value of fwrite. The caller can determine whether \
214 an error occurred by inspecting ferror (P). All known fwrite \
215 implementations set the stream's error indicator when they \
216 fail due to ENOMEM etc., even though C11 and POSIX.1-2008 do \
217 not require this. */ \
218 fwrite (s, _n, 1, p); \
227 memcpy_lowcase (p, (s), _n LOCALE_ARG); \
228 else if (to_uppcase) \
229 memcpy_uppcase (p, (s), _n LOCALE_ARG); \
231 MEMCPY ((void *) p, (void const *) (s), _n))
235 # ifndef USE_IN_EXTENDED_LOCALE_MODEL
236 # undef __mbsrtowcs_l
237 # define __mbsrtowcs_l(d, s, l, st, loc) __mbsrtowcs (d, s, l, st)
239 # define widen(os, ws, l) \
242 const char *__s = os; \
243 memset (&__st, '\0', sizeof (__st)); \
244 l = __mbsrtowcs_l (NULL, &__s, 0, &__st, loc); \
245 ws = (wchar_t *) alloca ((l + 1) * sizeof (wchar_t)); \
246 (void) __mbsrtowcs_l (ws, &__s, l, &__st, loc); \
251 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
252 /* We use this code also for the extended locale handling where the
253 function gets as an additional argument the locale which has to be
254 used. To access the values we have to redefine the _NL_CURRENT
256 # define strftime __strftime_l
257 # define wcsftime __wcsftime_l
259 # define _NL_CURRENT(category, item) \
260 (current->values[_NL_ITEM_INDEX (item)].string)
261 # define LOCALE_ARG , loc
262 # define LOCALE_PARAM_PROTO , __locale_t loc
263 # define HELPER_LOCALE_ARG , current
265 # define LOCALE_PARAM_PROTO
268 # define HELPER_LOCALE_ARG , _NL_CURRENT_DATA (LC_TIME)
270 # define HELPER_LOCALE_ARG
275 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
276 # define TOUPPER(Ch, L) __towupper_l (Ch, L)
277 # define TOLOWER(Ch, L) __towlower_l (Ch, L)
279 # define TOUPPER(Ch, L) towupper (Ch)
280 # define TOLOWER(Ch, L) towlower (Ch)
283 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
284 # define TOUPPER(Ch, L) __toupper_l (Ch, L)
285 # define TOLOWER(Ch, L) __tolower_l (Ch, L)
287 # define TOUPPER(Ch, L) toupper (Ch)
288 # define TOLOWER(Ch, L) tolower (Ch)
291 /* We don't use 'isdigit' here since the locale dependent
292 interpretation is not what we want here. We only need to accept
293 the arabic digits in the ASCII range. One day there is perhaps a
294 more reliable way to accept other sets of digits. */
295 #define ISDIGIT(Ch) ((unsigned int) (Ch) - L_('0') <= 9)
299 fwrite_lowcase (FILE *fp
, const CHAR_T
*src
, size_t len
)
303 fputc (TOLOWER ((UCHAR_T
) *src
, loc
), fp
);
309 fwrite_uppcase (FILE *fp
, const CHAR_T
*src
, size_t len
)
313 fputc (TOUPPER ((UCHAR_T
) *src
, loc
), fp
);
319 memcpy_lowcase (CHAR_T
*dest
, const CHAR_T
*src
,
320 size_t len LOCALE_PARAM_PROTO
)
323 dest
[len
] = TOLOWER ((UCHAR_T
) src
[len
], loc
);
328 memcpy_uppcase (CHAR_T
*dest
, const CHAR_T
*src
,
329 size_t len LOCALE_PARAM_PROTO
)
332 dest
[len
] = TOUPPER ((UCHAR_T
) src
[len
], loc
);
339 /* Yield the difference between *A and *B,
340 measured in seconds, ignoring leap seconds. */
341 # define tm_diff ftime_tm_diff
343 tm_diff (const struct tm
*a
, const struct tm
*b
)
345 /* Compute intervening leap days correctly even if year is negative.
346 Take care to avoid int overflow in leap day calculations,
347 but it's OK to assume that A and B are close to each other. */
348 int a4
= SHR (a
->tm_year
, 2) + SHR (TM_YEAR_BASE
, 2) - ! (a
->tm_year
& 3);
349 int b4
= SHR (b
->tm_year
, 2) + SHR (TM_YEAR_BASE
, 2) - ! (b
->tm_year
& 3);
350 int a100
= a4
/ 25 - (a4
% 25 < 0);
351 int b100
= b4
/ 25 - (b4
% 25 < 0);
352 int a400
= SHR (a100
, 2);
353 int b400
= SHR (b100
, 2);
354 int intervening_leap_days
= (a4
- b4
) - (a100
- b100
) + (a400
- b400
);
355 int years
= a
->tm_year
- b
->tm_year
;
356 int days
= (365 * years
+ intervening_leap_days
357 + (a
->tm_yday
- b
->tm_yday
));
358 return (60 * (60 * (24 * days
+ (a
->tm_hour
- b
->tm_hour
))
359 + (a
->tm_min
- b
->tm_min
))
360 + (a
->tm_sec
- b
->tm_sec
));
362 #endif /* ! HAVE_TM_GMTOFF */
366 /* The number of days from the first day of the first ISO week of this
367 year to the year day YDAY with week day WDAY. ISO weeks start on
368 Monday; the first ISO week has the year's first Thursday. YDAY may
369 be as small as YDAY_MINIMUM. */
370 #define ISO_WEEK_START_WDAY 1 /* Monday */
371 #define ISO_WEEK1_WDAY 4 /* Thursday */
372 #define YDAY_MINIMUM (-366)
377 iso_week_days (int yday
, int wday
)
379 /* Add enough to the first operand of % to make it nonnegative. */
380 int big_enough_multiple_of_7
= (-YDAY_MINIMUM
/ 7 + 2) * 7;
382 - (yday
- wday
+ ISO_WEEK1_WDAY
+ big_enough_multiple_of_7
) % 7
383 + ISO_WEEK1_WDAY
- ISO_WEEK_START_WDAY
);
387 /* When compiling this file, GNU applications can #define my_strftime
388 to a symbol (typically nstrftime) to get an extended strftime with
389 extra arguments UT and NS. Emacs is a special case for now, but
390 this Emacs-specific code can be removed once Emacs's config.h
391 defines my_strftime. */
392 #if defined emacs && !defined my_strftime
393 # define my_strftime nstrftime
398 # define my_strftime fprintftime
402 # define extra_args , ut, ns
403 # define extra_args_spec , int ut, int ns
405 # if defined COMPILE_WIDE
406 # define my_strftime wcsftime
407 # define nl_get_alt_digit _nl_get_walt_digit
409 # define my_strftime strftime
410 # define nl_get_alt_digit _nl_get_alt_digit
413 # define extra_args_spec
414 /* We don't have this information in general. */
420 /* Just like my_strftime, below, but with one more parameter, UPCASE,
421 to indicate that the result should be converted to upper case. */
423 strftime_case_ (bool upcase
, STREAM_OR_CHAR_T
*s
,
424 STRFTIME_ARG (size_t maxsize
)
425 const CHAR_T
*format
,
426 const struct tm
*tp extra_args_spec LOCALE_PARAM_PROTO
)
428 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
429 struct locale_data
*const current
= loc
->__locales
[LC_TIME
];
432 size_t maxsize
= (size_t) -1;
435 int hour12
= tp
->tm_hour
;
437 /* We cannot make the following values variables since we must delay
438 the evaluation of these values until really needed since some
439 expressions might not be valid in every situation. The 'struct tm'
440 might be generated by a strptime() call that initialized
441 only a few elements. Dereference the pointers only if the format
442 requires this. Then it is ok to fail if the pointers are invalid. */
444 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABDAY_1) + tp->tm_wday))
446 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(DAY_1) + tp->tm_wday))
448 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABMON_1) + tp->tm_mon))
450 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(MON_1) + tp->tm_mon))
452 ((const CHAR_T *) _NL_CURRENT (LC_TIME, tp->tm_hour > 11 \
453 ? NLW(PM_STR) : NLW(AM_STR)))
455 # define aw_len STRLEN (a_wkday)
456 # define am_len STRLEN (a_month)
457 # define ap_len STRLEN (ampm)
461 STREAM_OR_CHAR_T
*p
= s
;
463 #if DO_MULTIBYTE && !defined COMPILE_WIDE
464 const char *format_end
= NULL
;
467 #if ! defined _LIBC && ! HAVE_RUN_TZSET_TEST
468 /* Solaris 2.5.x and 2.6 tzset sometimes modify the storage returned
469 by localtime. On such systems, we must either use the tzset and
470 localtime wrappers to work around the bug (which sets
471 HAVE_RUN_TZSET_TEST) or make a copy of the structure. */
472 struct tm copy
= *tp
;
478 /* The POSIX test suite assumes that setting
479 the environment variable TZ to a new value before calling strftime()
480 will influence the result (the %Z format) even if the information in
481 TP is computed with a totally different time zone.
482 This is bogus: though POSIX allows bad behavior like this,
483 POSIX does not require it. Do the right thing instead. */
484 zone
= (const char *) tp
->tm_zone
;
489 if (! (zone
&& *zone
))
494 /* POSIX.1 requires that local time zone information be used as
495 though strftime called tzset. */
508 for (f
= format
; *f
!= '\0'; ++f
)
510 int pad
= 0; /* Padding for number ('-', '_', or 0). */
511 int modifier
; /* Field modifier ('E', 'O', or 0). */
512 int digits
= 0; /* Max digits for numeric format. */
513 int number_value
; /* Numeric value to be printed. */
514 unsigned int u_number_value
; /* (unsigned int) number_value. */
515 bool negative_number
; /* The number is negative. */
516 bool always_output_a_sign
; /* +/- should always be output. */
517 int tz_colon_mask
; /* Bitmask of where ':' should appear. */
518 const CHAR_T
*subfmt
;
522 + 2 /* for the two colons in a %::z or %:::z time zone */
523 + (sizeof (int) < sizeof (time_t)
524 ? INT_STRLEN_BOUND (time_t)
525 : INT_STRLEN_BOUND (int))];
527 bool to_lowcase
= false;
528 bool to_uppcase
= upcase
;
530 bool change_case
= false;
533 #if DO_MULTIBYTE && !defined COMPILE_WIDE
539 case L_('\b'): case L_('\t'): case L_('\n'):
540 case L_('\v'): case L_('\f'): case L_('\r'):
541 case L_(' '): case L_('!'): case L_('"'): case L_('#'): case L_('&'):
542 case L_('\''): case L_('('): case L_(')'): case L_('*'): case L_('+'):
543 case L_(','): case L_('-'): case L_('.'): case L_('/'): case L_('0'):
544 case L_('1'): case L_('2'): case L_('3'): case L_('4'): case L_('5'):
545 case L_('6'): case L_('7'): case L_('8'): case L_('9'): case L_(':'):
546 case L_(';'): case L_('<'): case L_('='): case L_('>'): case L_('?'):
547 case L_('A'): case L_('B'): case L_('C'): case L_('D'): case L_('E'):
548 case L_('F'): case L_('G'): case L_('H'): case L_('I'): case L_('J'):
549 case L_('K'): case L_('L'): case L_('M'): case L_('N'): case L_('O'):
550 case L_('P'): case L_('Q'): case L_('R'): case L_('S'): case L_('T'):
551 case L_('U'): case L_('V'): case L_('W'): case L_('X'): case L_('Y'):
552 case L_('Z'): case L_('['): case L_('\\'): case L_(']'): case L_('^'):
553 case L_('_'): case L_('a'): case L_('b'): case L_('c'): case L_('d'):
554 case L_('e'): case L_('f'): case L_('g'): case L_('h'): case L_('i'):
555 case L_('j'): case L_('k'): case L_('l'): case L_('m'): case L_('n'):
556 case L_('o'): case L_('p'): case L_('q'): case L_('r'): case L_('s'):
557 case L_('t'): case L_('u'): case L_('v'): case L_('w'): case L_('x'):
558 case L_('y'): case L_('z'): case L_('{'): case L_('|'): case L_('}'):
560 /* The C Standard requires these 98 characters (plus '%') to
561 be in the basic execution character set. None of these
562 characters can start a multibyte sequence, so they need
563 not be analyzed further. */
568 /* Copy this multibyte sequence until we reach its end, find
569 an error, or come back to the initial shift state. */
571 mbstate_t mbstate
= mbstate_zero
;
576 format_end
= f
+ strlen (f
) + 1;
577 fsize
= format_end
- f
;
581 size_t bytes
= mbrlen (f
+ len
, fsize
- len
, &mbstate
);
586 if (bytes
== (size_t) -2)
588 len
+= strlen (f
+ len
);
592 if (bytes
== (size_t) -1)
600 while (! mbsinit (&mbstate
));
608 #else /* ! DO_MULTIBYTE */
610 /* Either multibyte encodings are not supported, they are
611 safe for formats, so any non-'%' byte can be copied through,
612 or this is the wide character version. */
619 #endif /* ! DO_MULTIBYTE */
621 /* Check for flags that can modify a format. */
626 /* This influences the number formats. */
633 /* This changes textual output. */
647 /* As a GNU extension we allow to specify the field width. */
653 if (width
> INT_MAX
/ 10
654 || (width
== INT_MAX
/ 10 && *f
- L_('0') > INT_MAX
% 10))
655 /* Avoid overflow. */
660 width
+= *f
- L_('0');
664 while (ISDIGIT (*f
));
667 /* Check for modifiers. */
680 /* Now do the specified format. */
684 #define DO_NUMBER(d, v) \
692 #define DO_SIGNED_NUMBER(d, negative, v) \
696 negative_number = negative; \
697 u_number_value = v; \
698 goto do_signed_number; \
702 /* The mask is not what you might think.
703 When the ordinal i'th bit is set, insert a colon
704 before the i'th digit of the time zone representation. */
705 #define DO_TZ_OFFSET(d, negative, mask, v) \
709 negative_number = negative; \
710 tz_colon_mask = mask; \
711 u_number_value = v; \
715 #define DO_NUMBER_SPACEPAD(d, v) \
720 goto do_number_spacepad; \
739 cpy (aw_len
, a_wkday
);
742 goto underlying_strftime
;
754 cpy (STRLEN (f_wkday
), f_wkday
);
757 goto underlying_strftime
;
770 cpy (am_len
, a_month
);
773 goto underlying_strftime
;
785 cpy (STRLEN (f_month
), f_month
);
788 goto underlying_strftime
;
792 if (modifier
== L_('O'))
795 if (! (modifier
== 'E'
797 (const CHAR_T
*) _NL_CURRENT (LC_TIME
,
800 subfmt
= (const CHAR_T
*) _NL_CURRENT (LC_TIME
, NLW(D_T_FMT
));
802 goto underlying_strftime
;
807 size_t len
= strftime_case_ (to_uppcase
,
808 NULL
, STRFTIME_ARG ((size_t) -1)
810 tp extra_args LOCALE_ARG
);
811 add (len
, strftime_case_ (to_uppcase
, p
,
812 STRFTIME_ARG (maxsize
- i
)
814 tp extra_args LOCALE_ARG
));
818 #if !(defined _NL_CURRENT && HAVE_STRUCT_ERA_ENTRY)
821 /* The relevant information is available only via the
822 underlying strftime implementation, so use that. */
825 char ubuf
[1024]; /* enough for any single format in practice */
827 /* Make sure we're calling the actual underlying strftime.
828 In some cases, config.h contains something like
829 "#define strftime rpl_strftime". */
835 /* The space helps distinguish strftime failure from empty
843 len
= strftime (ubuf
, sizeof ubuf
, ufmt
, tp
);
845 cpy (len
- 1, ubuf
+ 1);
851 if (modifier
== L_('O'))
853 if (modifier
== L_('E'))
855 #if HAVE_STRUCT_ERA_ENTRY
856 struct era_entry
*era
= _nl_get_era_entry (tp HELPER_LOCALE_ARG
);
860 size_t len
= __wcslen (era
->era_wname
);
861 cpy (len
, era
->era_wname
);
863 size_t len
= strlen (era
->era_name
);
864 cpy (len
, era
->era_name
);
869 goto underlying_strftime
;
874 int century
= tp
->tm_year
/ 100 + TM_YEAR_BASE
/ 100;
875 century
-= tp
->tm_year
% 100 < 0 && 0 < century
;
876 DO_SIGNED_NUMBER (2, tp
->tm_year
< - TM_YEAR_BASE
, century
);
880 if (modifier
== L_('O'))
883 if (! (modifier
== L_('E')
885 (const CHAR_T
*)_NL_CURRENT (LC_TIME
, NLW(ERA_D_FMT
)))
887 subfmt
= (const CHAR_T
*) _NL_CURRENT (LC_TIME
, NLW(D_FMT
));
890 goto underlying_strftime
;
895 subfmt
= L_("%m/%d/%y");
899 if (modifier
== L_('E'))
902 DO_NUMBER (2, tp
->tm_mday
);
905 if (modifier
== L_('E'))
908 DO_NUMBER_SPACEPAD (2, tp
->tm_mday
);
910 /* All numeric formats set DIGITS and NUMBER_VALUE (or U_NUMBER_VALUE)
911 and then jump to one of these labels. */
914 always_output_a_sign
= true;
918 /* Force '_' flag unless overridden by '0' or '-' flag. */
919 if (pad
!= L_('0') && pad
!= L_('-'))
923 /* Format NUMBER_VALUE according to the MODIFIER flag. */
924 negative_number
= number_value
< 0;
925 u_number_value
= number_value
;
928 always_output_a_sign
= false;
932 /* Format U_NUMBER_VALUE according to the MODIFIER flag.
933 NEGATIVE_NUMBER is nonzero if the original number was
934 negative; in this case it was converted directly to
935 unsigned int (i.e., modulo (UINT_MAX + 1)) without
937 if (modifier
== L_('O') && !negative_number
)
940 /* Get the locale specific alternate representation of
941 the number. If none exist NULL is returned. */
942 const CHAR_T
*cp
= nl_get_alt_digit (u_number_value
947 size_t digitlen
= STRLEN (cp
);
955 goto underlying_strftime
;
959 bufp
= buf
+ sizeof (buf
) / sizeof (buf
[0]);
962 u_number_value
= - u_number_value
;
966 if (tz_colon_mask
& 1)
969 *--bufp
= u_number_value
% 10 + L_('0');
970 u_number_value
/= 10;
972 while (u_number_value
!= 0 || tz_colon_mask
!= 0);
974 do_number_sign_and_padding
:
978 sign_char
= (negative_number
? L_('-')
979 : always_output_a_sign
? L_('+')
989 int padding
= digits
- (buf
+ (sizeof (buf
) / sizeof (buf
[0]))
990 - bufp
) - !!sign_char
;
996 if ((size_t) padding
>= maxsize
- i
)
1000 memset_space (p
, padding
);
1002 width
= width
> padding
? width
- padding
: 0;
1008 if ((size_t) digits
>= maxsize
- i
)
1015 memset_zero (p
, padding
);
1027 cpy (buf
+ sizeof (buf
) / sizeof (buf
[0]) - bufp
, bufp
);
1033 subfmt
= L_("%Y-%m-%d");
1037 if (modifier
== L_('E'))
1040 DO_NUMBER (2, tp
->tm_hour
);
1043 if (modifier
== L_('E'))
1046 DO_NUMBER (2, hour12
);
1048 case L_('k'): /* GNU extension. */
1049 if (modifier
== L_('E'))
1052 DO_NUMBER_SPACEPAD (2, tp
->tm_hour
);
1054 case L_('l'): /* GNU extension. */
1055 if (modifier
== L_('E'))
1058 DO_NUMBER_SPACEPAD (2, hour12
);
1061 if (modifier
== L_('E'))
1064 DO_SIGNED_NUMBER (3, tp
->tm_yday
< -1, tp
->tm_yday
+ 1U);
1067 if (modifier
== L_('E'))
1070 DO_NUMBER (2, tp
->tm_min
);
1073 if (modifier
== L_('E'))
1076 DO_SIGNED_NUMBER (2, tp
->tm_mon
< -1, tp
->tm_mon
+ 1U);
1079 case L_('N'): /* GNU extension. */
1080 if (modifier
== L_('E'))
1088 /* Take an explicit width less than 9 as a precision. */
1090 for (j
= width
; j
< 9; j
++)
1094 DO_NUMBER (width
, number_value
);
1104 format_char
= L_('p');
1118 goto underlying_strftime
;
1122 subfmt
= L_("%H:%M");
1127 if (*(subfmt
= (const CHAR_T
*) _NL_CURRENT (LC_TIME
,
1130 subfmt
= L_("%I:%M:%S %p");
1133 goto underlying_strftime
;
1137 if (modifier
== L_('E'))
1140 DO_NUMBER (2, tp
->tm_sec
);
1142 case L_('s'): /* GNU extension. */
1150 /* Generate string value for T using time_t arithmetic;
1151 this works even if sizeof (long) < sizeof (time_t). */
1153 bufp
= buf
+ sizeof (buf
) / sizeof (buf
[0]);
1154 negative_number
= t
< 0;
1160 *--bufp
= (negative_number
? -d
: d
) + L_('0');
1165 always_output_a_sign
= false;
1166 goto do_number_sign_and_padding
;
1170 if (modifier
== L_('O'))
1173 if (! (modifier
== L_('E')
1175 (const CHAR_T
*) _NL_CURRENT (LC_TIME
, NLW(ERA_T_FMT
)))
1177 subfmt
= (const CHAR_T
*) _NL_CURRENT (LC_TIME
, NLW(T_FMT
));
1180 goto underlying_strftime
;
1183 subfmt
= L_("%H:%M:%S");
1191 DO_NUMBER (1, (tp
->tm_wday
- 1 + 7) % 7 + 1);
1194 if (modifier
== L_('E'))
1197 DO_NUMBER (2, (tp
->tm_yday
- tp
->tm_wday
+ 7) / 7);
1202 if (modifier
== L_('E'))
1205 /* YEAR is a leap year if and only if (tp->tm_year + TM_YEAR_BASE)
1206 is a leap year, except that YEAR and YEAR - 1 both work
1207 correctly even when (tp->tm_year + TM_YEAR_BASE) would
1209 int year
= (tp
->tm_year
1211 ? TM_YEAR_BASE
% 400
1212 : TM_YEAR_BASE
% 400 - 400));
1213 int year_adjust
= 0;
1214 int days
= iso_week_days (tp
->tm_yday
, tp
->tm_wday
);
1218 /* This ISO week belongs to the previous year. */
1220 days
= iso_week_days (tp
->tm_yday
+ (365 + __isleap (year
- 1)),
1225 int d
= iso_week_days (tp
->tm_yday
- (365 + __isleap (year
)),
1229 /* This ISO week belongs to the next year. */
1239 int yy
= (tp
->tm_year
% 100 + year_adjust
) % 100;
1240 DO_NUMBER (2, (0 <= yy
1242 : tp
->tm_year
< -TM_YEAR_BASE
- year_adjust
1248 DO_SIGNED_NUMBER (4, tp
->tm_year
< -TM_YEAR_BASE
- year_adjust
,
1249 (tp
->tm_year
+ (unsigned int) TM_YEAR_BASE
1253 DO_NUMBER (2, days
/ 7 + 1);
1258 if (modifier
== L_('E'))
1261 DO_NUMBER (2, (tp
->tm_yday
- (tp
->tm_wday
- 1 + 7) % 7 + 7) / 7);
1264 if (modifier
== L_('E'))
1267 DO_NUMBER (1, tp
->tm_wday
);
1270 if (modifier
== 'E')
1272 #if HAVE_STRUCT_ERA_ENTRY
1273 struct era_entry
*era
= _nl_get_era_entry (tp HELPER_LOCALE_ARG
);
1276 # ifdef COMPILE_WIDE
1277 subfmt
= era
->era_wformat
;
1279 subfmt
= era
->era_format
;
1284 goto underlying_strftime
;
1287 if (modifier
== L_('O'))
1290 DO_SIGNED_NUMBER (4, tp
->tm_year
< -TM_YEAR_BASE
,
1291 tp
->tm_year
+ (unsigned int) TM_YEAR_BASE
);
1294 if (modifier
== L_('E'))
1296 #if HAVE_STRUCT_ERA_ENTRY
1297 struct era_entry
*era
= _nl_get_era_entry (tp HELPER_LOCALE_ARG
);
1300 int delta
= tp
->tm_year
- era
->start_date
[0];
1301 DO_NUMBER (1, (era
->offset
1302 + delta
* era
->absolute_direction
));
1305 goto underlying_strftime
;
1310 int yy
= tp
->tm_year
% 100;
1312 yy
= tp
->tm_year
< - TM_YEAR_BASE
? -yy
: yy
+ 100;
1324 /* The tzset() call might have changed the value. */
1325 if (!(zone
&& *zone
) && tp
->tm_isdst
>= 0)
1326 zone
= tzname
[tp
->tm_isdst
!= 0];
1333 /* The zone string is always given in multibyte form. We have
1334 to transform it first. */
1337 widen (zone
, wczone
, len
);
1341 cpy (strlen (zone
), zone
);
1346 /* :, ::, and ::: are valid only just before 'z'.
1347 :::: etc. are rejected later. */
1348 for (colons
= 1; f
[colons
] == L_(':'); colons
++)
1350 if (f
[colons
] != L_('z'))
1353 goto do_z_conversion
;
1359 if (tp
->tm_isdst
< 0)
1368 diff
= tp
->tm_gmtoff
;
1381 if (lt
== (time_t) -1)
1383 /* mktime returns -1 for errors, but -1 is also a
1384 valid time_t value. Check whether an error really
1388 if (! __localtime_r (<
, &tm
)
1389 || ((ltm
.tm_sec
^ tm
.tm_sec
)
1390 | (ltm
.tm_min
^ tm
.tm_min
)
1391 | (ltm
.tm_hour
^ tm
.tm_hour
)
1392 | (ltm
.tm_mday
^ tm
.tm_mday
)
1393 | (ltm
.tm_mon
^ tm
.tm_mon
)
1394 | (ltm
.tm_year
^ tm
.tm_year
)))
1398 if (! __gmtime_r (<
, >m
))
1401 diff
= tm_diff (<m
, >m
);
1405 hour_diff
= diff
/ 60 / 60;
1406 min_diff
= diff
/ 60 % 60;
1407 sec_diff
= diff
% 60;
1412 DO_TZ_OFFSET (5, diff
< 0, 0, hour_diff
* 100 + min_diff
);
1414 case 1: tz_hh_mm
: /* +hh:mm */
1415 DO_TZ_OFFSET (6, diff
< 0, 04, hour_diff
* 100 + min_diff
);
1417 case 2: tz_hh_mm_ss
: /* +hh:mm:ss */
1418 DO_TZ_OFFSET (9, diff
< 0, 024,
1419 hour_diff
* 10000 + min_diff
* 100 + sec_diff
);
1421 case 3: /* +hh if possible, else +hh:mm, else +hh:mm:ss */
1426 DO_TZ_OFFSET (3, diff
< 0, 0, hour_diff
);
1433 case L_('\0'): /* GNU extension: % at end of format. */
1437 /* Unknown format; output the format, including the '%',
1438 since this is most likely the right thing to do if a
1439 multibyte string has been misparsed. */
1443 for (flen
= 1; f
[1 - flen
] != L_('%'); flen
++)
1445 cpy (flen
, &f
[1 - flen
]);
1452 if (p
&& maxsize
!= 0)
1459 /* Write information from TP into S according to the format
1460 string FORMAT, writing no more that MAXSIZE characters
1461 (including the terminating '\0') and returning number of
1462 characters written. If S is NULL, nothing will be written
1463 anywhere, so to determine how many characters would be
1464 written, use NULL for S and (size_t) -1 for MAXSIZE. */
1466 my_strftime (STREAM_OR_CHAR_T
*s
, STRFTIME_ARG (size_t maxsize
)
1467 const CHAR_T
*format
,
1468 const struct tm
*tp extra_args_spec LOCALE_PARAM_PROTO
)
1470 return strftime_case_ (false, s
, STRFTIME_ARG (maxsize
)
1471 format
, tp extra_args LOCALE_ARG
);
1474 #if defined _LIBC && ! FPRINTFTIME
1475 libc_hidden_def (my_strftime
)
1479 #if defined emacs && ! FPRINTFTIME
1480 /* For Emacs we have a separate interface which corresponds to the normal
1481 strftime function plus the ut argument, but without the ns argument. */
1483 emacs_strftimeu (char *s
, size_t maxsize
, const char *format
,
1484 const struct tm
*tp
, int ut
)
1486 return my_strftime (s
, maxsize
, format
, tp
, ut
, 0);