1 /* Copyright (C) 1991-1999, 2000, 2001, 2003 Free Software Foundation, Inc.
3 NOTE: The canonical source of this file is maintained with the GNU C Library.
4 Bugs can be reported to bug-glibc@prep.ai.mit.edu.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License along
17 with this program; if not, write to the Free Software Foundation,
18 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 # define HAVE_LIMITS_H 1
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 # define STDC_HEADERS 1
35 # include "../locale/localeinfo.h"
38 #if defined emacs && !defined HAVE_BCOPY
39 # define HAVE_MEMCPY 1
43 #include <sys/types.h> /* Some systems define `time_t' here. */
45 #ifdef TIME_WITH_SYS_TIME
46 # include <sys/time.h>
49 # ifdef HAVE_SYS_TIME_H
50 # include <sys/time.h>
56 extern char *tzname[];
59 /* Do multibyte processing if multibytes are supported, unless
60 multibyte sequences are safe in formats. Multibyte sequences are
61 safe if they cannot contain byte sequences that look like format
62 conversion specifications. The GNU C Library uses UTF8 multibyte
63 encoding, which is safe for formats, but strftime.c can be used
64 with other C libraries that use unsafe encodings. */
65 #define DO_MULTIBYTE (HAVE_MBLEN && ! MULTIBYTE_IS_FORMAT_SAFE)
71 /* Simulate mbrlen with mblen as best we can. */
72 # define mbstate_t int
73 # define mbrlen(s, n, ps) mblen (s, n)
74 # define mbsinit(ps) (*(ps) == 0)
76 static const mbstate_t mbstate_zero;
89 # define memcpy(d, s, n) bcopy ((s), (d), (n))
95 # define CHAR_T wchar_t
96 # define UCHAR_T unsigned int
97 # define L_(Str) L##Str
98 # define NLW(Sym) _NL_W##Sym
100 # define MEMCPY(d, s, n) __wmemcpy (d, s, n)
101 # define STRLEN(s) __wcslen (s)
105 # define UCHAR_T unsigned char
107 # define NLW(Sym) Sym
109 # if !defined STDC_HEADERS && !defined HAVE_MEMCPY
110 # define MEMCPY(d, s, n) bcopy ((s), (d), (n))
112 # define MEMCPY(d, s, n) memcpy ((d), (s), (n))
114 # define STRLEN(s) strlen (s)
117 # define MEMPCPY(d, s, n) __mempcpy (d, s, n)
119 # ifndef HAVE_MEMPCPY
120 # define MEMPCPY(d, s, n) ((void *) ((char *) memcpy (d, s, n) + (n)))
126 # if defined __GNUC__ || (defined __STDC__ && __STDC__)
127 # define __P(args) args
129 # define __P(args) ()
131 #endif /* Not __P. */
149 #define TYPE_SIGNED(t) ((t) -1 < 0)
151 /* Bound on length of the string representing an integer value of type t.
152 Subtract one for the sign bit if t is signed;
153 302 / 1000 is log10 (2) rounded up;
154 add one for integer division truncation;
155 add one more for a minus sign if t is signed. */
156 #define INT_STRLEN_BOUND(t) \
157 ((sizeof (t) * CHAR_BIT - TYPE_SIGNED (t)) * 302 / 1000 + 1 + TYPE_SIGNED (t))
159 #define TM_YEAR_BASE 1900
162 /* Nonzero if YEAR is a leap year (every 4 years,
163 except every 100th isn't, and every 400th is). */
164 # define __isleap(year) \
165 ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
170 # define tzname __tzname
171 # define tzset __tzset
175 /* Portable standalone applications should supply a "time_r.h" that
176 declares a POSIX-compliant localtime_r, for the benefit of older
177 implementations that lack localtime_r or have a nonstandard one.
178 See the gnulib time_r module for one way to implement this. */
181 # undef __localtime_r
182 # define __gmtime_r gmtime_r
183 # define __localtime_r localtime_r
187 #if !defined memset && !defined HAVE_MEMSET && !defined _LIBC
188 /* Some systems lack the `memset' function and we don't want to
189 introduce additional dependencies. */
190 /* The SGI compiler reportedly barfs on the trailing null
191 if we use a string constant as the initializer. 28 June 1997, rms. */
192 static const CHAR_T spaces[16] = /* " " */
194 L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),
195 L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' ')
197 static const CHAR_T zeroes[16] = /* "0000000000000000" */
199 L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),
200 L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0')
203 # define memset_space(P, Len) \
209 int _this = _len > 16 ? 16 : _len; \
210 (P) = MEMPCPY ((P), spaces, _this * sizeof (CHAR_T)); \
216 # define memset_zero(P, Len) \
222 int _this = _len > 16 ? 16 : _len; \
223 (P) = MEMPCPY ((P), zeroes, _this * sizeof (CHAR_T)); \
230 # define memset_space(P, Len) (wmemset ((P), L' ', (Len)), (P) += (Len))
231 # define memset_zero(P, Len) (wmemset ((P), L'0', (Len)), (P) += (Len))
233 # define memset_space(P, Len) (memset ((P), ' ', (Len)), (P) += (Len))
234 # define memset_zero(P, Len) (memset ((P), '0', (Len)), (P) += (Len))
242 int _delta = width - _n; \
243 int _incr = _n + (_delta > 0 ? _delta : 0); \
244 if ((size_t) _incr >= maxsize - i) \
250 if (pad == L_('0')) \
251 memset_zero (p, _delta); \
253 memset_space (p, _delta); \
264 memcpy_lowcase (p, (s), _n LOCALE_ARG); \
265 else if (to_uppcase) \
266 memcpy_uppcase (p, (s), _n LOCALE_ARG); \
268 MEMCPY ((PTR) p, (const PTR) (s), _n))
271 # ifndef USE_IN_EXTENDED_LOCALE_MODEL
272 # undef __mbsrtowcs_l
273 # define __mbsrtowcs_l(d, s, l, st, loc) __mbsrtowcs (d, s, l, st)
275 # define widen(os, ws, l) \
278 const char *__s = os; \
279 memset (&__st, '\0', sizeof (__st)); \
280 l = __mbsrtowcs_l (NULL, &__s, 0, &__st, loc); \
281 ws = (wchar_t *) alloca ((l + 1) * sizeof (wchar_t)); \
282 (void) __mbsrtowcs_l (ws, &__s, l, &__st, loc); \
287 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
288 /* We use this code also for the extended locale handling where the
289 function gets as an additional argument the locale which has to be
290 used. To access the values we have to redefine the _NL_CURRENT
292 # define strftime __strftime_l
293 # define wcsftime __wcsftime_l
295 # define _NL_CURRENT(category, item) \
296 (current->values[_NL_ITEM_INDEX (item)].string)
297 # define LOCALE_PARAM , loc
298 # define LOCALE_ARG , loc
299 # define LOCALE_PARAM_DECL __locale_t loc;
300 # define LOCALE_PARAM_PROTO , __locale_t loc
301 # define HELPER_LOCALE_ARG , current
303 # define LOCALE_PARAM
304 # define LOCALE_PARAM_PROTO
306 # define LOCALE_PARAM_DECL
308 # define HELPER_LOCALE_ARG , _NL_CURRENT_DATA (LC_TIME)
310 # define HELPER_LOCALE_ARG
315 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
316 # define TOUPPER(Ch, L) __towupper_l (Ch, L)
317 # define TOLOWER(Ch, L) __towlower_l (Ch, L)
319 # define TOUPPER(Ch, L) towupper (Ch)
320 # define TOLOWER(Ch, L) towlower (Ch)
324 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
325 # define TOUPPER(Ch, L) __toupper_l (Ch, L)
326 # define TOLOWER(Ch, L) __tolower_l (Ch, L)
328 # define TOUPPER(Ch, L) toupper (Ch)
329 # define TOLOWER(Ch, L) tolower (Ch)
332 # define TOUPPER(Ch, L) (islower (Ch) ? toupper (Ch) : (Ch))
333 # define TOLOWER(Ch, L) (isupper (Ch) ? tolower (Ch) : (Ch))
336 /* We don't use `isdigit' here since the locale dependent
337 interpretation is not what we want here. We only need to accept
338 the arabic digits in the ASCII range. One day there is perhaps a
339 more reliable way to accept other sets of digits. */
340 #define ISDIGIT(Ch) ((unsigned int) (Ch) - L_('0') <= 9)
342 static CHAR_T *memcpy_lowcase __P ((CHAR_T *dest, const CHAR_T *src,
343 size_t len LOCALE_PARAM_PROTO));
346 memcpy_lowcase (dest, src, len LOCALE_PARAM)
353 dest[len] = TOLOWER ((UCHAR_T) src[len], loc);
357 static CHAR_T *memcpy_uppcase __P ((CHAR_T *dest, const CHAR_T *src,
358 size_t len LOCALE_PARAM_PROTO));
361 memcpy_uppcase (dest, src, len LOCALE_PARAM)
368 dest[len] = TOUPPER ((UCHAR_T) src[len], loc);
374 /* Yield the difference between *A and *B,
375 measured in seconds, ignoring leap seconds. */
376 # define tm_diff ftime_tm_diff
377 static int tm_diff __P ((const struct tm *, const struct tm *));
383 /* Compute intervening leap days correctly even if year is negative.
384 Take care to avoid int overflow in leap day calculations,
385 but it's OK to assume that A and B are close to each other. */
386 int a4 = (a->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (a->tm_year & 3);
387 int b4 = (b->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (b->tm_year & 3);
388 int a100 = a4 / 25 - (a4 % 25 < 0);
389 int b100 = b4 / 25 - (b4 % 25 < 0);
390 int a400 = a100 >> 2;
391 int b400 = b100 >> 2;
392 int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
393 int years = a->tm_year - b->tm_year;
394 int days = (365 * years + intervening_leap_days
395 + (a->tm_yday - b->tm_yday));
396 return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
397 + (a->tm_min - b->tm_min))
398 + (a->tm_sec - b->tm_sec));
400 #endif /* ! HAVE_TM_GMTOFF */
404 /* The number of days from the first day of the first ISO week of this
405 year to the year day YDAY with week day WDAY. ISO weeks start on
406 Monday; the first ISO week has the year's first Thursday. YDAY may
407 be as small as YDAY_MINIMUM. */
408 #define ISO_WEEK_START_WDAY 1 /* Monday */
409 #define ISO_WEEK1_WDAY 4 /* Thursday */
410 #define YDAY_MINIMUM (-366)
411 static int iso_week_days __P ((int, int));
416 iso_week_days (yday, wday)
420 /* Add enough to the first operand of % to make it nonnegative. */
421 int big_enough_multiple_of_7 = (-YDAY_MINIMUM / 7 + 2) * 7;
423 - (yday - wday + ISO_WEEK1_WDAY + big_enough_multiple_of_7) % 7
424 + ISO_WEEK1_WDAY - ISO_WEEK_START_WDAY);
428 #if !(defined _NL_CURRENT || HAVE_STRFTIME)
429 static CHAR_T const weekday_name[][10] =
431 L_("Sunday"), L_("Monday"), L_("Tuesday"), L_("Wednesday"),
432 L_("Thursday"), L_("Friday"), L_("Saturday")
434 static CHAR_T const month_name[][10] =
436 L_("January"), L_("February"), L_("March"), L_("April"), L_("May"),
437 L_("June"), L_("July"), L_("August"), L_("September"), L_("October"),
438 L_("November"), L_("December")
443 /* When compiling this file, GNU applications can #define my_strftime
444 to a symbol (typically nstrftime) to get an extended strftime with
445 extra arguments UT and NS. Emacs is a special case for now, but
446 this Emacs-specific code can be removed once Emacs's config.h
447 defines my_strftime. */
448 #if defined emacs && !defined my_strftime
449 # define my_strftime nstrftime
453 # define extra_args , ut, ns
454 # define extra_args_spec int ut; int ns;
455 # define extra_args_spec_iso , int ut, int ns
458 # define my_strftime wcsftime
459 # define nl_get_alt_digit _nl_get_walt_digit
461 # define my_strftime strftime
462 # define nl_get_alt_digit _nl_get_alt_digit
465 # define extra_args_spec
466 # define extra_args_spec_iso
467 /* We don't have this information in general. */
472 #if ! defined _LIBC && ! HAVE_RUN_TZSET_TEST
473 /* Solaris 2.5.x and 2.6 tzset sometimes modify the storage returned
474 by localtime. On such systems, we must use the tzset and localtime
475 wrappers to work around the bug. */
476 "you must run the autoconf test for a working tzset function"
480 /* Write information from TP into S according to the format
481 string FORMAT, writing no more that MAXSIZE characters
482 (including the terminating '\0') and returning number of
483 characters written. If S is NULL, nothing will be written
484 anywhere, so to determine how many characters would be
485 written, use NULL for S and (size_t) UINT_MAX for MAXSIZE. */
487 my_strftime (s, maxsize, format, tp extra_args LOCALE_PARAM)
490 const CHAR_T *format;
495 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
496 struct locale_data *const current = loc->__locales[LC_TIME];
499 int hour12 = tp->tm_hour;
501 /* We cannot make the following values variables since we must delay
502 the evaluation of these values until really needed since some
503 expressions might not be valid in every situation. The `struct tm'
504 might be generated by a strptime() call that initialized
505 only a few elements. Dereference the pointers only if the format
506 requires this. Then it is ok to fail if the pointers are invalid. */
508 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABDAY_1) + tp->tm_wday))
510 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(DAY_1) + tp->tm_wday))
512 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABMON_1) + tp->tm_mon))
514 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(MON_1) + tp->tm_mon))
516 ((const CHAR_T *) _NL_CURRENT (LC_TIME, tp->tm_hour > 11 \
517 ? NLW(PM_STR) : NLW(AM_STR)))
519 # define aw_len STRLEN (a_wkday)
520 # define am_len STRLEN (a_month)
521 # define ap_len STRLEN (ampm)
524 # define f_wkday (weekday_name[tp->tm_wday])
525 # define f_month (month_name[tp->tm_mon])
526 # define a_wkday f_wkday
527 # define a_month f_month
528 # define ampm (L_("AMPM") + 2 * (tp->tm_hour > 11))
539 #if DO_MULTIBYTE && !defined COMPILE_WIDE
540 const char *format_end = NULL;
545 /* The POSIX test suite assumes that setting
546 the environment variable TZ to a new value before calling strftime()
547 will influence the result (the %Z format) even if the information in
548 TP is computed with a totally different time zone.
549 This is bogus: though POSIX allows bad behavior like this,
550 POSIX does not require it. Do the right thing instead. */
551 zone = (const char *) tp->tm_zone;
556 if (! (zone && *zone))
561 /* POSIX.1 requires that local time zone information be used as
562 though strftime called tzset. */
575 for (f = format; *f != '\0'; ++f)
577 int pad = 0; /* Padding for number ('-', '_', or 0). */
578 int modifier; /* Field modifier ('E', 'O', or 0). */
579 int digits; /* Max digits for numeric format. */
580 int number_value; /* Numeric value to be printed. */
581 int negative_number; /* 1 if the number is negative. */
582 const CHAR_T *subfmt;
584 CHAR_T buf[1 + (sizeof (int) < sizeof (time_t)
585 ? INT_STRLEN_BOUND (time_t)
586 : INT_STRLEN_BOUND (int))];
593 #if DO_MULTIBYTE && !defined COMPILE_WIDE
599 case L_('\b'): case L_('\t'): case L_('\n'):
600 case L_('\v'): case L_('\f'): case L_('\r'):
601 case L_(' '): case L_('!'): case L_('"'): case L_('#'): case L_('&'):
602 case L_('\''): case L_('('): case L_(')'): case L_('*'): case L_('+'):
603 case L_(','): case L_('-'): case L_('.'): case L_('/'): case L_('0'):
604 case L_('1'): case L_('2'): case L_('3'): case L_('4'): case L_('5'):
605 case L_('6'): case L_('7'): case L_('8'): case L_('9'): case L_(':'):
606 case L_(';'): case L_('<'): case L_('='): case L_('>'): case L_('?'):
607 case L_('A'): case L_('B'): case L_('C'): case L_('D'): case L_('E'):
608 case L_('F'): case L_('G'): case L_('H'): case L_('I'): case L_('J'):
609 case L_('K'): case L_('L'): case L_('M'): case L_('N'): case L_('O'):
610 case L_('P'): case L_('Q'): case L_('R'): case L_('S'): case L_('T'):
611 case L_('U'): case L_('V'): case L_('W'): case L_('X'): case L_('Y'):
612 case L_('Z'): case L_('['): case L_('\\'): case L_(']'): case L_('^'):
613 case L_('_'): case L_('a'): case L_('b'): case L_('c'): case L_('d'):
614 case L_('e'): case L_('f'): case L_('g'): case L_('h'): case L_('i'):
615 case L_('j'): case L_('k'): case L_('l'): case L_('m'): case L_('n'):
616 case L_('o'): case L_('p'): case L_('q'): case L_('r'): case L_('s'):
617 case L_('t'): case L_('u'): case L_('v'): case L_('w'): case L_('x'):
618 case L_('y'): case L_('z'): case L_('{'): case L_('|'): case L_('}'):
620 /* The C Standard requires these 98 characters (plus '%') to
621 be in the basic execution character set. None of these
622 characters can start a multibyte sequence, so they need
623 not be analyzed further. */
628 /* Copy this multibyte sequence until we reach its end, find
629 an error, or come back to the initial shift state. */
631 mbstate_t mbstate = mbstate_zero;
636 format_end = f + strlen (f) + 1;
637 fsize = format_end - f;
641 size_t bytes = mbrlen (f + len, fsize - len, &mbstate);
646 if (bytes == (size_t) -2)
648 len += strlen (f + len);
652 if (bytes == (size_t) -1)
660 while (! mbsinit (&mbstate));
668 #else /* ! DO_MULTIBYTE */
670 /* Either multibyte encodings are not supported, they are
671 safe for formats, so any non-'%' byte can be copied through,
672 or this is the wide character version. */
679 #endif /* ! DO_MULTIBYTE */
681 /* Check for flags that can modify a format. */
686 /* This influences the number formats. */
693 /* This changes textual output. */
707 /* As a GNU extension we allow to specify the field width. */
713 if (width > INT_MAX / 10
714 || (width == INT_MAX / 10 && *f - L_('0') > INT_MAX % 10))
715 /* Avoid overflow. */
720 width += *f - L_('0');
724 while (ISDIGIT (*f));
727 /* Check for modifiers. */
740 /* Now do the specified format. */
744 #define DO_NUMBER(d, v) \
745 digits = d > width ? d : width; \
746 number_value = v; goto do_number
747 #define DO_NUMBER_SPACEPAD(d, v) \
748 digits = d > width ? d : width; \
749 number_value = v; goto do_number_spacepad
765 #if defined _NL_CURRENT || !HAVE_STRFTIME
766 cpy (aw_len, a_wkday);
769 goto underlying_strftime;
780 #if defined _NL_CURRENT || !HAVE_STRFTIME
781 cpy (STRLEN (f_wkday), f_wkday);
784 goto underlying_strftime;
796 #if defined _NL_CURRENT || !HAVE_STRFTIME
797 cpy (am_len, a_month);
800 goto underlying_strftime;
811 #if defined _NL_CURRENT || !HAVE_STRFTIME
812 cpy (STRLEN (f_month), f_month);
815 goto underlying_strftime;
819 if (modifier == L_('O'))
822 if (! (modifier == 'E'
824 (const CHAR_T *) _NL_CURRENT (LC_TIME,
827 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_T_FMT));
830 goto underlying_strftime;
832 subfmt = L_("%a %b %e %H:%M:%S %Y");
838 CHAR_T *old_start = p;
839 size_t len = my_strftime (NULL, (size_t) -1, subfmt,
840 tp extra_args LOCALE_ARG);
841 add (len, my_strftime (p, maxsize - i, subfmt,
842 tp extra_args LOCALE_ARG));
845 while (old_start < p)
847 *old_start = TOUPPER ((UCHAR_T) *old_start, loc);
853 #if HAVE_STRFTIME && ! (defined _NL_CURRENT && HAVE_STRUCT_ERA_ENTRY)
856 /* The relevant information is available only via the
857 underlying strftime implementation, so use that. */
860 char ubuf[1024]; /* enough for any single format in practice */
862 /* Make sure we're calling the actual underlying strftime.
863 In some cases, config.h contains something like
864 "#define strftime rpl_strftime". */
875 len = strftime (ubuf, sizeof ubuf, ufmt, tp);
876 if (len == 0 && ubuf[0] != '\0')
884 if (modifier == L_('O'))
886 if (modifier == L_('E'))
888 #if HAVE_STRUCT_ERA_ENTRY
889 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
893 size_t len = __wcslen (era->era_wname);
894 cpy (len, era->era_wname);
896 size_t len = strlen (era->era_name);
897 cpy (len, era->era_name);
903 goto underlying_strftime;
909 int year = tp->tm_year + TM_YEAR_BASE;
910 DO_NUMBER (1, year / 100 - (year % 100 < 0));
914 if (modifier == L_('O'))
917 if (! (modifier == L_('E')
919 (const CHAR_T *)_NL_CURRENT (LC_TIME, NLW(ERA_D_FMT)))
921 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_FMT));
925 goto underlying_strftime;
933 subfmt = L_("%m/%d/%y");
937 if (modifier == L_('E'))
940 DO_NUMBER (2, tp->tm_mday);
943 if (modifier == L_('E'))
946 DO_NUMBER_SPACEPAD (2, tp->tm_mday);
948 /* All numeric formats set DIGITS and NUMBER_VALUE and then
949 jump to one of these two labels. */
952 /* Force `_' flag unless overridden by `0' or `-' flag. */
953 if (pad != L_('0') && pad != L_('-'))
957 /* Format the number according to the MODIFIER flag. */
959 if (modifier == L_('O') && 0 <= number_value)
962 /* Get the locale specific alternate representation of
963 the number NUMBER_VALUE. If none exist NULL is returned. */
964 const CHAR_T *cp = nl_get_alt_digit (number_value
969 size_t digitlen = STRLEN (cp);
978 goto underlying_strftime;
983 unsigned int u = number_value;
985 bufp = buf + sizeof (buf) / sizeof (buf[0]);
986 negative_number = number_value < 0;
992 *--bufp = u % 10 + L_('0');
993 while ((u /= 10) != 0);
996 do_number_sign_and_padding:
1002 int padding = digits - (buf + (sizeof (buf) / sizeof (buf[0]))
1009 if ((size_t) padding >= maxsize - i)
1013 memset_space (p, padding);
1015 width = width > padding ? width - padding : 0;
1019 if ((size_t) digits >= maxsize - i)
1022 if (negative_number)
1032 memset_zero (p, padding);
1039 cpy (buf + sizeof (buf) / sizeof (buf[0]) - bufp, bufp);
1045 subfmt = L_("%Y-%m-%d");
1049 if (modifier == L_('E'))
1052 DO_NUMBER (2, tp->tm_hour);
1055 if (modifier == L_('E'))
1058 DO_NUMBER (2, hour12);
1060 case L_('k'): /* GNU extension. */
1061 if (modifier == L_('E'))
1064 DO_NUMBER_SPACEPAD (2, tp->tm_hour);
1066 case L_('l'): /* GNU extension. */
1067 if (modifier == L_('E'))
1070 DO_NUMBER_SPACEPAD (2, hour12);
1073 if (modifier == L_('E'))
1076 DO_NUMBER (3, 1 + tp->tm_yday);
1079 if (modifier == L_('E'))
1082 DO_NUMBER (2, tp->tm_min);
1085 if (modifier == L_('E'))
1088 DO_NUMBER (2, tp->tm_mon + 1);
1091 case L_('N'): /* GNU extension. */
1092 if (modifier == L_('E'))
1098 /* Take an explicit width less than 9 as a precision. */
1100 for (j = width; j < 9; j++)
1104 DO_NUMBER (9, number_value);
1108 add (1, *p = L_('\n'));
1113 #if !defined _NL_CURRENT && HAVE_STRFTIME
1114 format_char = L_('p');
1124 #if defined _NL_CURRENT || !HAVE_STRFTIME
1128 goto underlying_strftime;
1132 subfmt = L_("%H:%M");
1136 #if !defined _NL_CURRENT && HAVE_STRFTIME
1137 goto underlying_strftime;
1140 if (*(subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME,
1144 subfmt = L_("%I:%M:%S %p");
1149 if (modifier == L_('E'))
1152 DO_NUMBER (2, tp->tm_sec);
1154 case L_('s'): /* GNU extension. */
1162 /* Generate string value for T using time_t arithmetic;
1163 this works even if sizeof (long) < sizeof (time_t). */
1165 bufp = buf + sizeof (buf) / sizeof (buf[0]);
1166 negative_number = t < 0;
1173 if (negative_number)
1177 /* Adjust if division truncates to minus infinity. */
1178 if (0 < -1 % 10 && d < 0)
1185 *--bufp = d + L_('0');
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");
1215 add (1, *p = L_('\t'));
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 int year = tp->tm_year + TM_YEAR_BASE;
1234 int days = iso_week_days (tp->tm_yday, tp->tm_wday);
1238 /* This ISO week belongs to the previous year. */
1240 days = iso_week_days (tp->tm_yday + (365 + __isleap (year)),
1245 int d = iso_week_days (tp->tm_yday - (365 + __isleap (year)),
1249 /* This ISO week belongs to the next year. */
1258 DO_NUMBER (2, (year % 100 + 100) % 100);
1261 DO_NUMBER (1, year);
1264 DO_NUMBER (2, days / 7 + 1);
1269 if (modifier == L_('E'))
1272 DO_NUMBER (2, (tp->tm_yday - (tp->tm_wday - 1 + 7) % 7 + 7) / 7);
1275 if (modifier == L_('E'))
1278 DO_NUMBER (1, tp->tm_wday);
1281 if (modifier == 'E')
1283 #if HAVE_STRUCT_ERA_ENTRY
1284 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
1287 # ifdef COMPILE_WIDE
1288 subfmt = era->era_wformat;
1290 subfmt = era->era_format;
1296 goto underlying_strftime;
1300 if (modifier == L_('O'))
1303 DO_NUMBER (1, tp->tm_year + TM_YEAR_BASE);
1306 if (modifier == L_('E'))
1308 #if HAVE_STRUCT_ERA_ENTRY
1309 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
1312 int delta = tp->tm_year - era->start_date[0];
1313 DO_NUMBER (1, (era->offset
1314 + delta * era->absolute_direction));
1318 goto underlying_strftime;
1322 DO_NUMBER (2, (tp->tm_year % 100 + 100) % 100);
1332 /* The tzset() call might have changed the value. */
1333 if (!(zone && *zone) && tp->tm_isdst >= 0)
1334 zone = tzname[tp->tm_isdst];
1341 /* The zone string is always given in multibyte form. We have
1342 to transform it first. */
1345 widen (zone, wczone, len);
1349 cpy (strlen (zone), zone);
1354 if (tp->tm_isdst < 0)
1360 diff = tp->tm_gmtoff;
1373 if (lt == (time_t) -1)
1375 /* mktime returns -1 for errors, but -1 is also a
1376 valid time_t value. Check whether an error really
1380 if (! __localtime_r (<, &tm)
1381 || ((ltm.tm_sec ^ tm.tm_sec)
1382 | (ltm.tm_min ^ tm.tm_min)
1383 | (ltm.tm_hour ^ tm.tm_hour)
1384 | (ltm.tm_mday ^ tm.tm_mday)
1385 | (ltm.tm_mon ^ tm.tm_mon)
1386 | (ltm.tm_year ^ tm.tm_year)))
1390 if (! __gmtime_r (<, >m))
1393 diff = tm_diff (<m, >m);
1399 add (1, *p = L_('-'));
1403 add (1, *p = L_('+'));
1406 DO_NUMBER (4, (diff / 60) * 100 + diff % 60);
1409 case L_('\0'): /* GNU extension: % at end of format. */
1413 /* Unknown format; output the format, including the '%',
1414 since this is most likely the right thing to do if a
1415 multibyte string has been misparsed. */
1419 for (flen = 1; f[1 - flen] != L_('%'); flen++)
1421 cpy (flen, &f[1 - flen]);
1427 if (p && maxsize != 0)
1432 libc_hidden_def (my_strftime)
1437 /* For Emacs we have a separate interface which corresponds to the normal
1438 strftime function plus the ut argument, but without the ns argument. */
1440 emacs_strftimeu (s, maxsize, format, tp, ut)
1444 const struct tm *tp;
1447 return my_strftime (s, maxsize, format, tp, ut, 0);