1 /* Copyright (C) 1991-1999, 2000, 2001, 2003, 2004, 2005 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. */
27 # define HAVE_MBRLEN 1
28 # define HAVE_STRUCT_ERA_ENTRY 1
29 # define HAVE_TM_GMTOFF 1
30 # define HAVE_TM_ZONE 1
31 # define HAVE_TZNAME 1
33 # define MULTIBYTE_IS_FORMAT_SAFE 1
34 # include "../locale/localeinfo.h"
38 #include <sys/types.h> /* Some systems define `time_t' here. */
40 #ifdef TIME_WITH_SYS_TIME
41 # include <sys/time.h>
44 # ifdef HAVE_SYS_TIME_H
45 # include <sys/time.h>
51 extern char *tzname[];
54 /* Do multibyte processing if multibytes are supported, unless
55 multibyte sequences are safe in formats. Multibyte sequences are
56 safe if they cannot contain byte sequences that look like format
57 conversion specifications. The GNU C Library uses UTF8 multibyte
58 encoding, which is safe for formats, but strftime.c can be used
59 with other C libraries that use unsafe encodings. */
60 #define DO_MULTIBYTE (HAVE_MBLEN && HAVE_WCHAR_H && ! MULTIBYTE_IS_FORMAT_SAFE)
66 /* Simulate mbrlen with mblen as best we can. */
67 # define mbstate_t int
68 # define mbrlen(s, n, ps) mblen (s, n)
69 # define mbsinit(ps) (*(ps) == 0)
71 static const mbstate_t mbstate_zero;
82 # define CHAR_T wchar_t
83 # define UCHAR_T unsigned int
84 # define L_(Str) L##Str
85 # define NLW(Sym) _NL_W##Sym
87 # define MEMCPY(d, s, n) __wmemcpy (d, s, n)
88 # define STRLEN(s) __wcslen (s)
92 # define UCHAR_T unsigned char
96 # define MEMCPY(d, s, n) memcpy (d, s, n)
97 # define STRLEN(s) strlen (s)
100 # define MEMPCPY(d, s, n) __mempcpy (d, s, n)
102 # ifndef HAVE_MEMPCPY
103 # define MEMPCPY(d, s, n) ((void *) ((char *) memcpy (d, s, n) + (n)))
108 /* Shift A right by B bits portably, by dividing A by 2**B and
109 truncating towards minus infinity. A and B should be free of side
110 effects, and B should be in the range 0 <= B <= INT_BITS - 2, where
111 INT_BITS is the number of useful bits in an int. GNU code can
112 assume that INT_BITS is at least 32.
114 ISO C99 says that A >> B is implementation-defined if A < 0. Some
115 implementations (e.g., UNICOS 9.0 on a Cray Y-MP EL) don't shift
116 right in the usual way when A < 0, so SHR falls back on division if
117 ordinary A >> B doesn't seem to be the usual signed shift. */
121 : (a) / (1 << (b)) - ((a) % (1 << (b)) < 0))
123 /* Bound on length of the string representing an integer type or expression T.
124 Subtract 1 for the sign bit if t is signed; log10 (2.0) < 146/485;
125 add 1 for integer division truncation; add 1 more for a minus sign
127 #define INT_STRLEN_BOUND(t) \
128 ((sizeof (t) * CHAR_BIT - 1) * 146 / 485 + 2)
130 #define TM_YEAR_BASE 1900
133 /* Nonzero if YEAR is a leap year (every 4 years,
134 except every 100th isn't, and every 400th is). */
135 # define __isleap(year) \
136 ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
141 # define tzname __tzname
142 # define tzset __tzset
146 /* Portable standalone applications should supply a "time_r.h" that
147 declares a POSIX-compliant localtime_r, for the benefit of older
148 implementations that lack localtime_r or have a nonstandard one.
149 See the gnulib time_r module for one way to implement this. */
152 # undef __localtime_r
153 # define __gmtime_r gmtime_r
154 # define __localtime_r localtime_r
159 # define FPRINTFTIME 0
163 # define STREAM_OR_CHAR_T FILE
164 # define STRFTIME_ARG(x) /* empty */
166 # define STREAM_OR_CHAR_T CHAR_T
167 # define STRFTIME_ARG(x) x,
171 # define memset_byte(P, Len, Byte) \
172 do { size_t _i; for (_i = 0; _i < Len; _i++) fputc (Byte, P); } while (0)
173 # define memset_space(P, Len) memset_byte (P, Len, ' ')
174 # define memset_zero(P, Len) memset_byte (P, Len, '0')
175 #elif defined COMPILE_WIDE
176 # define memset_space(P, Len) (wmemset (P, L' ', Len), (P) += (Len))
177 # define memset_zero(P, Len) (wmemset (P, L'0', Len), (P) += (Len))
179 # define memset_space(P, Len) (memset (P, ' ', Len), (P) += (Len))
180 # define memset_zero(P, Len) (memset (P, '0', Len), (P) += (Len))
187 int _delta = width - _n; \
188 int _incr = _n + (_delta > 0 ? _delta : 0); \
189 if ((size_t) _incr >= maxsize - i) \
193 if (digits == 0 && _delta > 0) \
195 if (pad == L_('0')) \
196 memset_zero (p, _delta); \
198 memset_space (p, _delta); \
201 p += FPRINTFTIME ? 0 : _n; \
207 # define add1(C) add (1, fputc (C, p))
209 # define add1(C) add (1, *p = C)
216 fwrite_lowcase (p, (s), _n); \
217 else if (to_uppcase) \
218 fwrite_uppcase (p, (s), _n); \
220 fwrite ((s), _n, 1, p))
225 memcpy_lowcase (p, (s), _n LOCALE_ARG); \
226 else if (to_uppcase) \
227 memcpy_uppcase (p, (s), _n LOCALE_ARG); \
229 MEMCPY ((void *) p, (void const *) (s), _n))
233 # ifndef USE_IN_EXTENDED_LOCALE_MODEL
234 # undef __mbsrtowcs_l
235 # define __mbsrtowcs_l(d, s, l, st, loc) __mbsrtowcs (d, s, l, st)
237 # define widen(os, ws, l) \
240 const char *__s = os; \
241 memset (&__st, '\0', sizeof (__st)); \
242 l = __mbsrtowcs_l (NULL, &__s, 0, &__st, loc); \
243 ws = (wchar_t *) alloca ((l + 1) * sizeof (wchar_t)); \
244 (void) __mbsrtowcs_l (ws, &__s, l, &__st, loc); \
249 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
250 /* We use this code also for the extended locale handling where the
251 function gets as an additional argument the locale which has to be
252 used. To access the values we have to redefine the _NL_CURRENT
254 # define strftime __strftime_l
255 # define wcsftime __wcsftime_l
257 # define _NL_CURRENT(category, item) \
258 (current->values[_NL_ITEM_INDEX (item)].string)
259 # define LOCALE_ARG , loc
260 # define LOCALE_PARAM_PROTO , __locale_t loc
261 # define HELPER_LOCALE_ARG , current
263 # define LOCALE_PARAM_PROTO
266 # define HELPER_LOCALE_ARG , _NL_CURRENT_DATA (LC_TIME)
268 # define HELPER_LOCALE_ARG
273 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
274 # define TOUPPER(Ch, L) __towupper_l (Ch, L)
275 # define TOLOWER(Ch, L) __towlower_l (Ch, L)
277 # define TOUPPER(Ch, L) towupper (Ch)
278 # define TOLOWER(Ch, L) towlower (Ch)
282 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
283 # define TOUPPER(Ch, L) __toupper_l (Ch, L)
284 # define TOLOWER(Ch, L) __tolower_l (Ch, L)
286 # define TOUPPER(Ch, L) toupper (Ch)
287 # define TOLOWER(Ch, L) tolower (Ch)
290 # define TOUPPER(Ch, L) (islower (Ch) ? toupper (Ch) : (Ch))
291 # define TOLOWER(Ch, L) (isupper (Ch) ? tolower (Ch) : (Ch))
294 /* We don't use `isdigit' here since the locale dependent
295 interpretation is not what we want here. We only need to accept
296 the arabic digits in the ASCII range. One day there is perhaps a
297 more reliable way to accept other sets of digits. */
298 #define ISDIGIT(Ch) ((unsigned int) (Ch) - L_('0') <= 9)
302 fwrite_lowcase (FILE *fp, const CHAR_T *src, size_t len)
306 fputc (TOLOWER ((UCHAR_T) *src, loc), fp);
312 fwrite_uppcase (FILE *fp, const CHAR_T *src, size_t len)
316 fputc (TOUPPER ((UCHAR_T) *src, loc), fp);
322 memcpy_lowcase (CHAR_T *dest, const CHAR_T *src,
323 size_t len LOCALE_PARAM_PROTO)
326 dest[len] = TOLOWER ((UCHAR_T) src[len], loc);
331 memcpy_uppcase (CHAR_T *dest, const CHAR_T *src,
332 size_t len LOCALE_PARAM_PROTO)
335 dest[len] = TOUPPER ((UCHAR_T) src[len], loc);
342 /* Yield the difference between *A and *B,
343 measured in seconds, ignoring leap seconds. */
344 # define tm_diff ftime_tm_diff
346 tm_diff (const struct tm *a, const struct tm *b)
348 /* Compute intervening leap days correctly even if year is negative.
349 Take care to avoid int overflow in leap day calculations,
350 but it's OK to assume that A and B are close to each other. */
351 int a4 = SHR (a->tm_year, 2) + SHR (TM_YEAR_BASE, 2) - ! (a->tm_year & 3);
352 int b4 = SHR (b->tm_year, 2) + SHR (TM_YEAR_BASE, 2) - ! (b->tm_year & 3);
353 int a100 = a4 / 25 - (a4 % 25 < 0);
354 int b100 = b4 / 25 - (b4 % 25 < 0);
355 int a400 = SHR (a100, 2);
356 int b400 = SHR (b100, 2);
357 int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
358 int years = a->tm_year - b->tm_year;
359 int days = (365 * years + intervening_leap_days
360 + (a->tm_yday - b->tm_yday));
361 return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
362 + (a->tm_min - b->tm_min))
363 + (a->tm_sec - b->tm_sec));
365 #endif /* ! HAVE_TM_GMTOFF */
369 /* The number of days from the first day of the first ISO week of this
370 year to the year day YDAY with week day WDAY. ISO weeks start on
371 Monday; the first ISO week has the year's first Thursday. YDAY may
372 be as small as YDAY_MINIMUM. */
373 #define ISO_WEEK_START_WDAY 1 /* Monday */
374 #define ISO_WEEK1_WDAY 4 /* Thursday */
375 #define YDAY_MINIMUM (-366)
380 iso_week_days (int yday, int wday)
382 /* Add enough to the first operand of % to make it nonnegative. */
383 int big_enough_multiple_of_7 = (-YDAY_MINIMUM / 7 + 2) * 7;
385 - (yday - wday + ISO_WEEK1_WDAY + big_enough_multiple_of_7) % 7
386 + ISO_WEEK1_WDAY - ISO_WEEK_START_WDAY);
390 #if !(defined _NL_CURRENT || HAVE_STRFTIME)
391 static CHAR_T const weekday_name[][10] =
393 L_("Sunday"), L_("Monday"), L_("Tuesday"), L_("Wednesday"),
394 L_("Thursday"), L_("Friday"), L_("Saturday")
396 static CHAR_T const month_name[][10] =
398 L_("January"), L_("February"), L_("March"), L_("April"), L_("May"),
399 L_("June"), L_("July"), L_("August"), L_("September"), L_("October"),
400 L_("November"), L_("December")
405 /* When compiling this file, GNU applications can #define my_strftime
406 to a symbol (typically nstrftime) to get an extended strftime with
407 extra arguments UT and NS. Emacs is a special case for now, but
408 this Emacs-specific code can be removed once Emacs's config.h
409 defines my_strftime. */
410 #if defined emacs && !defined my_strftime
411 # define my_strftime nstrftime
416 # define my_strftime fprintftime
420 # define extra_args , ut, ns
421 # define extra_args_spec , int ut, int ns
423 # if defined COMPILE_WIDE
424 # define my_strftime wcsftime
425 # define nl_get_alt_digit _nl_get_walt_digit
427 # define my_strftime strftime
428 # define nl_get_alt_digit _nl_get_alt_digit
431 # define extra_args_spec
432 /* We don't have this information in general. */
438 /* Just like my_strftime, below, but with one more parameter, UPCASE,
439 to indicate that the result should be converted to upper case. */
441 strftime_case_ (bool upcase, STREAM_OR_CHAR_T *s,
442 STRFTIME_ARG (size_t maxsize)
443 const CHAR_T *format,
444 const struct tm *tp extra_args_spec LOCALE_PARAM_PROTO)
446 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
447 struct locale_data *const current = loc->__locales[LC_TIME];
450 size_t maxsize = (size_t) -1;
453 int hour12 = tp->tm_hour;
455 /* We cannot make the following values variables since we must delay
456 the evaluation of these values until really needed since some
457 expressions might not be valid in every situation. The `struct tm'
458 might be generated by a strptime() call that initialized
459 only a few elements. Dereference the pointers only if the format
460 requires this. Then it is ok to fail if the pointers are invalid. */
462 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABDAY_1) + tp->tm_wday))
464 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(DAY_1) + tp->tm_wday))
466 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABMON_1) + tp->tm_mon))
468 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(MON_1) + tp->tm_mon))
470 ((const CHAR_T *) _NL_CURRENT (LC_TIME, tp->tm_hour > 11 \
471 ? NLW(PM_STR) : NLW(AM_STR)))
473 # define aw_len STRLEN (a_wkday)
474 # define am_len STRLEN (a_month)
475 # define ap_len STRLEN (ampm)
478 # define f_wkday (weekday_name[tp->tm_wday])
479 # define f_month (month_name[tp->tm_mon])
480 # define a_wkday f_wkday
481 # define a_month f_month
482 # define ampm (L_("AMPM") + 2 * (tp->tm_hour > 11))
491 STREAM_OR_CHAR_T *p = s;
493 #if DO_MULTIBYTE && !defined COMPILE_WIDE
494 const char *format_end = NULL;
497 #if ! defined _LIBC && ! HAVE_RUN_TZSET_TEST
498 /* Solaris 2.5.x and 2.6 tzset sometimes modify the storage returned
499 by localtime. On such systems, we must either use the tzset and
500 localtime wrappers to work around the bug (which sets
501 HAVE_RUN_TZSET_TEST) or make a copy of the structure. */
502 struct tm copy = *tp;
508 /* The POSIX test suite assumes that setting
509 the environment variable TZ to a new value before calling strftime()
510 will influence the result (the %Z format) even if the information in
511 TP is computed with a totally different time zone.
512 This is bogus: though POSIX allows bad behavior like this,
513 POSIX does not require it. Do the right thing instead. */
514 zone = (const char *) tp->tm_zone;
519 if (! (zone && *zone))
524 /* POSIX.1 requires that local time zone information be used as
525 though strftime called tzset. */
538 for (f = format; *f != '\0'; ++f)
540 int pad = 0; /* Padding for number ('-', '_', or 0). */
541 int modifier; /* Field modifier ('E', 'O', or 0). */
542 int digits = 0; /* Max digits for numeric format. */
543 int number_value; /* Numeric value to be printed. */
544 unsigned int u_number_value; /* (unsigned int) number_value. */
545 bool negative_number; /* The number is negative. */
546 bool always_output_a_sign; /* +/- should always be output. */
547 int tz_colon_mask; /* Bitmask of where ':' should appear. */
548 const CHAR_T *subfmt;
552 + 2 /* for the two colons in a %::z or %:::z time zone */
553 + (sizeof (int) < sizeof (time_t)
554 ? INT_STRLEN_BOUND (time_t)
555 : INT_STRLEN_BOUND (int))];
557 bool to_lowcase = false;
558 bool to_uppcase = upcase;
560 bool change_case = false;
563 #if DO_MULTIBYTE && !defined COMPILE_WIDE
569 case L_('\b'): case L_('\t'): case L_('\n'):
570 case L_('\v'): case L_('\f'): case L_('\r'):
571 case L_(' '): case L_('!'): case L_('"'): case L_('#'): case L_('&'):
572 case L_('\''): case L_('('): case L_(')'): case L_('*'): case L_('+'):
573 case L_(','): case L_('-'): case L_('.'): case L_('/'): case L_('0'):
574 case L_('1'): case L_('2'): case L_('3'): case L_('4'): case L_('5'):
575 case L_('6'): case L_('7'): case L_('8'): case L_('9'): case L_(':'):
576 case L_(';'): case L_('<'): case L_('='): case L_('>'): case L_('?'):
577 case L_('A'): case L_('B'): case L_('C'): case L_('D'): case L_('E'):
578 case L_('F'): case L_('G'): case L_('H'): case L_('I'): case L_('J'):
579 case L_('K'): case L_('L'): case L_('M'): case L_('N'): case L_('O'):
580 case L_('P'): case L_('Q'): case L_('R'): case L_('S'): case L_('T'):
581 case L_('U'): case L_('V'): case L_('W'): case L_('X'): case L_('Y'):
582 case L_('Z'): case L_('['): case L_('\\'): case L_(']'): case L_('^'):
583 case L_('_'): case L_('a'): case L_('b'): case L_('c'): case L_('d'):
584 case L_('e'): case L_('f'): case L_('g'): case L_('h'): case L_('i'):
585 case L_('j'): case L_('k'): case L_('l'): case L_('m'): case L_('n'):
586 case L_('o'): case L_('p'): case L_('q'): case L_('r'): case L_('s'):
587 case L_('t'): case L_('u'): case L_('v'): case L_('w'): case L_('x'):
588 case L_('y'): case L_('z'): case L_('{'): case L_('|'): case L_('}'):
590 /* The C Standard requires these 98 characters (plus '%') to
591 be in the basic execution character set. None of these
592 characters can start a multibyte sequence, so they need
593 not be analyzed further. */
598 /* Copy this multibyte sequence until we reach its end, find
599 an error, or come back to the initial shift state. */
601 mbstate_t mbstate = mbstate_zero;
606 format_end = f + strlen (f) + 1;
607 fsize = format_end - f;
611 size_t bytes = mbrlen (f + len, fsize - len, &mbstate);
616 if (bytes == (size_t) -2)
618 len += strlen (f + len);
622 if (bytes == (size_t) -1)
630 while (! mbsinit (&mbstate));
638 #else /* ! DO_MULTIBYTE */
640 /* Either multibyte encodings are not supported, they are
641 safe for formats, so any non-'%' byte can be copied through,
642 or this is the wide character version. */
649 #endif /* ! DO_MULTIBYTE */
651 /* Check for flags that can modify a format. */
656 /* This influences the number formats. */
663 /* This changes textual output. */
677 /* As a GNU extension we allow to specify the field width. */
683 if (width > INT_MAX / 10
684 || (width == INT_MAX / 10 && *f - L_('0') > INT_MAX % 10))
685 /* Avoid overflow. */
690 width += *f - L_('0');
694 while (ISDIGIT (*f));
697 /* Check for modifiers. */
710 /* Now do the specified format. */
714 #define DO_NUMBER(d, v) \
716 number_value = v; goto do_number
717 #define DO_SIGNED_NUMBER(d, negative, v) \
719 negative_number = negative; \
720 u_number_value = v; goto do_signed_number
722 /* The mask is not what you might think.
723 When the ordinal i'th bit is set, insert a colon
724 before the i'th digit of the time zone representation. */
725 #define DO_TZ_OFFSET(d, negative, mask, v) \
727 negative_number = negative; \
728 tz_colon_mask = mask; \
729 u_number_value = v; goto do_tz_offset
730 #define DO_NUMBER_SPACEPAD(d, v) \
732 number_value = v; goto do_number_spacepad
748 #if defined _NL_CURRENT || !HAVE_STRFTIME
749 cpy (aw_len, a_wkday);
752 goto underlying_strftime;
763 #if defined _NL_CURRENT || !HAVE_STRFTIME
764 cpy (STRLEN (f_wkday), f_wkday);
767 goto underlying_strftime;
779 #if defined _NL_CURRENT || !HAVE_STRFTIME
780 cpy (am_len, a_month);
783 goto underlying_strftime;
794 #if defined _NL_CURRENT || !HAVE_STRFTIME
795 cpy (STRLEN (f_month), f_month);
798 goto underlying_strftime;
802 if (modifier == L_('O'))
805 if (! (modifier == 'E'
807 (const CHAR_T *) _NL_CURRENT (LC_TIME,
810 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_T_FMT));
813 goto underlying_strftime;
815 subfmt = L_("%a %b %e %H:%M:%S %Y");
821 size_t len = strftime_case_ (to_uppcase,
822 NULL, STRFTIME_ARG ((size_t) -1)
824 tp extra_args LOCALE_ARG);
825 add (len, strftime_case_ (to_uppcase, p,
826 STRFTIME_ARG (maxsize - i)
828 tp extra_args LOCALE_ARG));
832 #if HAVE_STRFTIME && ! (defined _NL_CURRENT && HAVE_STRUCT_ERA_ENTRY)
835 /* The relevant information is available only via the
836 underlying strftime implementation, so use that. */
839 char ubuf[1024]; /* enough for any single format in practice */
841 /* Make sure we're calling the actual underlying strftime.
842 In some cases, config.h contains something like
843 "#define strftime rpl_strftime". */
849 /* The space helps distinguish strftime failure from empty
857 len = strftime (ubuf, sizeof ubuf, ufmt, tp);
859 cpy (len - 1, ubuf + 1);
865 if (modifier == L_('O'))
867 if (modifier == L_('E'))
869 #if HAVE_STRUCT_ERA_ENTRY
870 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
874 size_t len = __wcslen (era->era_wname);
875 cpy (len, era->era_wname);
877 size_t len = strlen (era->era_name);
878 cpy (len, era->era_name);
884 goto underlying_strftime;
890 int century = tp->tm_year / 100 + TM_YEAR_BASE / 100;
891 century -= tp->tm_year % 100 < 0 && 0 < century;
892 DO_SIGNED_NUMBER (2, tp->tm_year < - TM_YEAR_BASE, century);
896 if (modifier == L_('O'))
899 if (! (modifier == L_('E')
901 (const CHAR_T *)_NL_CURRENT (LC_TIME, NLW(ERA_D_FMT)))
903 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_FMT));
907 goto underlying_strftime;
915 subfmt = L_("%m/%d/%y");
919 if (modifier == L_('E'))
922 DO_NUMBER (2, tp->tm_mday);
925 if (modifier == L_('E'))
928 DO_NUMBER_SPACEPAD (2, tp->tm_mday);
930 /* All numeric formats set DIGITS and NUMBER_VALUE (or U_NUMBER_VALUE)
931 and then jump to one of these labels. */
934 always_output_a_sign = true;
938 /* Force `_' flag unless overridden by `0' or `-' flag. */
939 if (pad != L_('0') && pad != L_('-'))
943 /* Format NUMBER_VALUE according to the MODIFIER flag. */
944 negative_number = number_value < 0;
945 u_number_value = number_value;
948 always_output_a_sign = false;
952 /* Format U_NUMBER_VALUE according to the MODIFIER flag.
953 NEGATIVE_NUMBER is nonzero if the original number was
954 negative; in this case it was converted directly to
955 unsigned int (i.e., modulo (UINT_MAX + 1)) without
957 if (modifier == L_('O') && !negative_number)
960 /* Get the locale specific alternate representation of
961 the number. If none exist NULL is returned. */
962 const CHAR_T *cp = nl_get_alt_digit (u_number_value
967 size_t digitlen = STRLEN (cp);
976 goto underlying_strftime;
981 bufp = buf + sizeof (buf) / sizeof (buf[0]);
984 u_number_value = - u_number_value;
988 if (tz_colon_mask & 1)
991 *--bufp = u_number_value % 10 + L_('0');
992 u_number_value /= 10;
994 while (u_number_value != 0 || tz_colon_mask != 0);
996 do_number_sign_and_padding:
1000 sign_char = (negative_number ? L_('-')
1001 : always_output_a_sign ? L_('+')
1011 int padding = digits - (buf + (sizeof (buf) / sizeof (buf[0]))
1012 - bufp) - !!sign_char;
1018 if ((size_t) padding >= maxsize - i)
1022 memset_space (p, padding);
1024 width = width > padding ? width - padding : 0;
1030 if ((size_t) digits >= maxsize - i)
1037 memset_zero (p, padding);
1049 cpy (buf + sizeof (buf) / sizeof (buf[0]) - bufp, bufp);
1055 subfmt = L_("%Y-%m-%d");
1059 if (modifier == L_('E'))
1062 DO_NUMBER (2, tp->tm_hour);
1065 if (modifier == L_('E'))
1068 DO_NUMBER (2, hour12);
1070 case L_('k'): /* GNU extension. */
1071 if (modifier == L_('E'))
1074 DO_NUMBER_SPACEPAD (2, tp->tm_hour);
1076 case L_('l'): /* GNU extension. */
1077 if (modifier == L_('E'))
1080 DO_NUMBER_SPACEPAD (2, hour12);
1083 if (modifier == L_('E'))
1086 DO_SIGNED_NUMBER (3, tp->tm_yday < -1, tp->tm_yday + 1U);
1089 if (modifier == L_('E'))
1092 DO_NUMBER (2, tp->tm_min);
1095 if (modifier == L_('E'))
1098 DO_SIGNED_NUMBER (2, tp->tm_mon < -1, tp->tm_mon + 1U);
1101 case L_('N'): /* GNU extension. */
1102 if (modifier == L_('E'))
1110 /* Take an explicit width less than 9 as a precision. */
1112 for (j = width; j < 9; j++)
1116 DO_NUMBER (width, number_value);
1125 #if !defined _NL_CURRENT && HAVE_STRFTIME
1126 format_char = L_('p');
1136 #if defined _NL_CURRENT || !HAVE_STRFTIME
1140 goto underlying_strftime;
1144 subfmt = L_("%H:%M");
1148 #if !defined _NL_CURRENT && HAVE_STRFTIME
1149 goto underlying_strftime;
1152 if (*(subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME,
1156 subfmt = L_("%I:%M:%S %p");
1161 if (modifier == L_('E'))
1164 DO_NUMBER (2, tp->tm_sec);
1166 case L_('s'): /* GNU extension. */
1174 /* Generate string value for T using time_t arithmetic;
1175 this works even if sizeof (long) < sizeof (time_t). */
1177 bufp = buf + sizeof (buf) / sizeof (buf[0]);
1178 negative_number = t < 0;
1184 *--bufp = (negative_number ? -d : d) + L_('0');
1189 always_output_a_sign = false;
1190 goto do_number_sign_and_padding;
1194 if (modifier == L_('O'))
1197 if (! (modifier == L_('E')
1199 (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ERA_T_FMT)))
1201 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(T_FMT));
1205 goto underlying_strftime;
1211 subfmt = L_("%H:%M:%S");
1219 DO_NUMBER (1, (tp->tm_wday - 1 + 7) % 7 + 1);
1222 if (modifier == L_('E'))
1225 DO_NUMBER (2, (tp->tm_yday - tp->tm_wday + 7) / 7);
1230 if (modifier == L_('E'))
1233 /* YEAR is a leap year if and only if (tp->tm_year + TM_YEAR_BASE)
1234 is a leap year, except that YEAR and YEAR - 1 both work
1235 correctly even when (tp->tm_year + TM_YEAR_BASE) would
1237 int year = (tp->tm_year
1239 ? TM_YEAR_BASE % 400
1240 : TM_YEAR_BASE % 400 - 400));
1241 int year_adjust = 0;
1242 int days = iso_week_days (tp->tm_yday, tp->tm_wday);
1246 /* This ISO week belongs to the previous year. */
1248 days = iso_week_days (tp->tm_yday + (365 + __isleap (year - 1)),
1253 int d = iso_week_days (tp->tm_yday - (365 + __isleap (year)),
1257 /* This ISO week belongs to the next year. */
1267 int yy = (tp->tm_year % 100 + year_adjust) % 100;
1268 DO_NUMBER (2, (0 <= yy
1270 : tp->tm_year < -TM_YEAR_BASE - year_adjust
1276 DO_SIGNED_NUMBER (4, tp->tm_year < -TM_YEAR_BASE - year_adjust,
1277 (tp->tm_year + (unsigned int) TM_YEAR_BASE
1281 DO_NUMBER (2, days / 7 + 1);
1286 if (modifier == L_('E'))
1289 DO_NUMBER (2, (tp->tm_yday - (tp->tm_wday - 1 + 7) % 7 + 7) / 7);
1292 if (modifier == L_('E'))
1295 DO_NUMBER (1, tp->tm_wday);
1298 if (modifier == 'E')
1300 #if HAVE_STRUCT_ERA_ENTRY
1301 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
1304 # ifdef COMPILE_WIDE
1305 subfmt = era->era_wformat;
1307 subfmt = era->era_format;
1313 goto underlying_strftime;
1317 if (modifier == L_('O'))
1320 DO_SIGNED_NUMBER (4, tp->tm_year < -TM_YEAR_BASE,
1321 tp->tm_year + (unsigned int) TM_YEAR_BASE);
1324 if (modifier == L_('E'))
1326 #if HAVE_STRUCT_ERA_ENTRY
1327 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
1330 int delta = tp->tm_year - era->start_date[0];
1331 DO_NUMBER (1, (era->offset
1332 + delta * era->absolute_direction));
1336 goto underlying_strftime;
1342 int yy = tp->tm_year % 100;
1344 yy = tp->tm_year < - TM_YEAR_BASE ? -yy : yy + 100;
1356 /* The tzset() call might have changed the value. */
1357 if (!(zone && *zone) && tp->tm_isdst >= 0)
1358 zone = tzname[tp->tm_isdst != 0];
1365 /* The zone string is always given in multibyte form. We have
1366 to transform it first. */
1369 widen (zone, wczone, len);
1373 cpy (strlen (zone), zone);
1378 /* :, ::, and ::: are valid only just before 'z'.
1379 :::: etc. are rejected later. */
1380 for (colons = 1; f[colons] == L_(':'); colons++)
1382 if (f[colons] != L_('z'))
1385 goto do_z_conversion;
1391 if (tp->tm_isdst < 0)
1400 diff = tp->tm_gmtoff;
1413 if (lt == (time_t) -1)
1415 /* mktime returns -1 for errors, but -1 is also a
1416 valid time_t value. Check whether an error really
1420 if (! __localtime_r (<, &tm)
1421 || ((ltm.tm_sec ^ tm.tm_sec)
1422 | (ltm.tm_min ^ tm.tm_min)
1423 | (ltm.tm_hour ^ tm.tm_hour)
1424 | (ltm.tm_mday ^ tm.tm_mday)
1425 | (ltm.tm_mon ^ tm.tm_mon)
1426 | (ltm.tm_year ^ tm.tm_year)))
1430 if (! __gmtime_r (<, >m))
1433 diff = tm_diff (<m, >m);
1437 hour_diff = diff / 60 / 60;
1438 min_diff = diff / 60 % 60;
1439 sec_diff = diff % 60;
1444 DO_TZ_OFFSET (5, diff < 0, 0, hour_diff * 100 + min_diff);
1446 case 1: tz_hh_mm: /* +hh:mm */
1447 DO_TZ_OFFSET (6, diff < 0, 04, hour_diff * 100 + min_diff);
1449 case 2: tz_hh_mm_ss: /* +hh:mm:ss */
1450 DO_TZ_OFFSET (9, diff < 0, 024,
1451 hour_diff * 10000 + min_diff * 100 + sec_diff);
1453 case 3: /* +hh if possible, else +hh:mm, else +hh:mm:ss */
1458 DO_TZ_OFFSET (3, diff < 0, 0, hour_diff);
1465 case L_('\0'): /* GNU extension: % at end of format. */
1469 /* Unknown format; output the format, including the '%',
1470 since this is most likely the right thing to do if a
1471 multibyte string has been misparsed. */
1475 for (flen = 1; f[1 - flen] != L_('%'); flen++)
1477 cpy (flen, &f[1 - flen]);
1484 if (p && maxsize != 0)
1491 /* Write information from TP into S according to the format
1492 string FORMAT, writing no more that MAXSIZE characters
1493 (including the terminating '\0') and returning number of
1494 characters written. If S is NULL, nothing will be written
1495 anywhere, so to determine how many characters would be
1496 written, use NULL for S and (size_t) -1 for MAXSIZE. */
1498 my_strftime (STREAM_OR_CHAR_T *s, STRFTIME_ARG (size_t maxsize)
1499 const CHAR_T *format,
1500 const struct tm *tp extra_args_spec LOCALE_PARAM_PROTO)
1502 return strftime_case_ (false, s, STRFTIME_ARG (maxsize)
1503 format, tp extra_args LOCALE_ARG);
1506 #if defined _LIBC && ! FPRINTFTIME
1507 libc_hidden_def (my_strftime)
1511 #if defined emacs && ! FPRINTFTIME
1512 /* For Emacs we have a separate interface which corresponds to the normal
1513 strftime function plus the ut argument, but without the ns argument. */
1515 emacs_strftimeu (char *s, size_t maxsize, const char *format,
1516 const struct tm *tp, int ut)
1518 return my_strftime (s, maxsize, format, tp, ut, 0);