1 /* Copyright (C) 1991-1999, 2000, 2001, 2002, 2003
2 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, write to the Free
17 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
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 my_strftime_gmtime_r __gmtime_r
171 # define my_strftime_localtime_r __localtime_r
172 # define tzname __tzname
173 # define tzset __tzset
176 /* If we're a strftime substitute in a GNU program, then prefer gmtime
177 to gmtime_r, since many gmtime_r implementations are buggy.
178 Similarly for localtime_r. */
180 # if ! HAVE_TM_GMTOFF
181 static struct tm *my_strftime_gmtime_r __P ((const time_t *, struct tm *));
183 my_strftime_gmtime_r (t, tp)
187 struct tm *l = gmtime (t);
193 # endif /* ! HAVE_TM_GMTOFF */
195 static struct tm *my_strftime_localtime_r __P ((const time_t *, struct tm *));
197 my_strftime_localtime_r (t, tp)
201 struct tm *l = localtime (t);
207 #endif /* ! defined _LIBC */
210 #if !defined memset && !defined HAVE_MEMSET && !defined _LIBC
211 /* Some systems lack the `memset' function and we don't want to
212 introduce additional dependencies. */
213 /* The SGI compiler reportedly barfs on the trailing null
214 if we use a string constant as the initializer. 28 June 1997, rms. */
215 static const CHAR_T spaces[16] = /* " " */
217 L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),
218 L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' ')
220 static const CHAR_T zeroes[16] = /* "0000000000000000" */
222 L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),
223 L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0')
226 # define memset_space(P, Len) \
232 int _this = _len > 16 ? 16 : _len; \
233 (P) = MEMPCPY ((P), spaces, _this * sizeof (CHAR_T)); \
239 # define memset_zero(P, Len) \
245 int _this = _len > 16 ? 16 : _len; \
246 (P) = MEMPCPY ((P), zeroes, _this * sizeof (CHAR_T)); \
253 # define memset_space(P, Len) (wmemset ((P), L' ', (Len)), (P) += (Len))
254 # define memset_zero(P, Len) (wmemset ((P), L'0', (Len)), (P) += (Len))
256 # define memset_space(P, Len) (memset ((P), ' ', (Len)), (P) += (Len))
257 # define memset_zero(P, Len) (memset ((P), '0', (Len)), (P) += (Len))
265 int _delta = width - _n; \
266 int _incr = _n + (_delta > 0 ? _delta : 0); \
267 if ((size_t) _incr >= maxsize - i) \
273 if (pad == L_('0')) \
274 memset_zero (p, _delta); \
276 memset_space (p, _delta); \
287 memcpy_lowcase (p, (s), _n LOCALE_ARG); \
288 else if (to_uppcase) \
289 memcpy_uppcase (p, (s), _n LOCALE_ARG); \
291 MEMCPY ((PTR) p, (const PTR) (s), _n))
294 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
295 # define widen(os, ws, l) \
298 const char *__s = os; \
299 memset (&__st, '\0', sizeof (__st)); \
300 l = __mbsrtowcs_l (NULL, &__s, 0, &__st, loc); \
301 ws = alloca ((l + 1) * sizeof (wchar_t)); \
302 (void) __mbsrtowcs_l (ws, &__s, l, &__st, loc); \
305 # define widen(os, ws, l) \
308 const char *__s = os; \
309 memset (&__st, '\0', sizeof (__st)); \
310 l = __mbsrtowcs (NULL, &__s, 0, &__st); \
311 ws = alloca ((l + 1) * sizeof (wchar_t)); \
312 (void) __mbsrtowcs (ws, &__s, l, &__st); \
318 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
319 /* We use this code also for the extended locale handling where the
320 function gets as an additional argument the locale which has to be
321 used. To access the values we have to redefine the _NL_CURRENT
323 # define strftime __strftime_l
324 # define wcsftime __wcsftime_l
326 # define _NL_CURRENT(category, item) \
327 (current->values[_NL_ITEM_INDEX (item)].string)
328 # define LOCALE_PARAM , loc
329 # define LOCALE_ARG , loc
330 # define LOCALE_PARAM_DECL __locale_t loc;
331 # define LOCALE_PARAM_PROTO , __locale_t loc
332 # define HELPER_LOCALE_ARG , current
334 # define LOCALE_PARAM
335 # define LOCALE_PARAM_PROTO
337 # define LOCALE_PARAM_DECL
339 # define HELPER_LOCALE_ARG , _NL_CURRENT_DATA (LC_TIME)
341 # define HELPER_LOCALE_ARG
346 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
347 # define TOUPPER(Ch, L) __towupper_l (Ch, L)
348 # define TOLOWER(Ch, L) __towlower_l (Ch, L)
350 # define TOUPPER(Ch, L) towupper (Ch)
351 # define TOLOWER(Ch, L) towlower (Ch)
355 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
356 # define TOUPPER(Ch, L) __toupper_l (Ch, L)
357 # define TOLOWER(Ch, L) __tolower_l (Ch, L)
359 # define TOUPPER(Ch, L) toupper (Ch)
360 # define TOLOWER(Ch, L) tolower (Ch)
363 # define TOUPPER(Ch, L) (islower (Ch) ? toupper (Ch) : (Ch))
364 # define TOLOWER(Ch, L) (isupper (Ch) ? tolower (Ch) : (Ch))
367 /* We don't use `isdigit' here since the locale dependent
368 interpretation is not what we want here. We only need to accept
369 the arabic digits in the ASCII range. One day there is perhaps a
370 more reliable way to accept other sets of digits. */
371 #define ISDIGIT(Ch) ((unsigned int) (Ch) - L_('0') <= 9)
373 static CHAR_T *memcpy_lowcase __P ((CHAR_T *dest, const CHAR_T *src,
374 size_t len LOCALE_PARAM_PROTO));
377 memcpy_lowcase (dest, src, len LOCALE_PARAM)
384 dest[len] = TOLOWER ((UCHAR_T) src[len], loc);
388 static CHAR_T *memcpy_uppcase __P ((CHAR_T *dest, const CHAR_T *src,
389 size_t len LOCALE_PARAM_PROTO));
392 memcpy_uppcase (dest, src, len LOCALE_PARAM)
399 dest[len] = TOUPPER ((UCHAR_T) src[len], loc);
405 /* Yield the difference between *A and *B,
406 measured in seconds, ignoring leap seconds. */
407 # define tm_diff ftime_tm_diff
408 static int tm_diff __P ((const struct tm *, const struct tm *));
414 /* Compute intervening leap days correctly even if year is negative.
415 Take care to avoid int overflow in leap day calculations,
416 but it's OK to assume that A and B are close to each other. */
417 int a4 = (a->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (a->tm_year & 3);
418 int b4 = (b->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (b->tm_year & 3);
419 int a100 = a4 / 25 - (a4 % 25 < 0);
420 int b100 = b4 / 25 - (b4 % 25 < 0);
421 int a400 = a100 >> 2;
422 int b400 = b100 >> 2;
423 int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
424 int years = a->tm_year - b->tm_year;
425 int days = (365 * years + intervening_leap_days
426 + (a->tm_yday - b->tm_yday));
427 return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
428 + (a->tm_min - b->tm_min))
429 + (a->tm_sec - b->tm_sec));
431 #endif /* ! HAVE_TM_GMTOFF */
435 /* The number of days from the first day of the first ISO week of this
436 year to the year day YDAY with week day WDAY. ISO weeks start on
437 Monday; the first ISO week has the year's first Thursday. YDAY may
438 be as small as YDAY_MINIMUM. */
439 #define ISO_WEEK_START_WDAY 1 /* Monday */
440 #define ISO_WEEK1_WDAY 4 /* Thursday */
441 #define YDAY_MINIMUM (-366)
442 static int iso_week_days __P ((int, int));
447 iso_week_days (yday, wday)
451 /* Add enough to the first operand of % to make it nonnegative. */
452 int big_enough_multiple_of_7 = (-YDAY_MINIMUM / 7 + 2) * 7;
454 - (yday - wday + ISO_WEEK1_WDAY + big_enough_multiple_of_7) % 7
455 + ISO_WEEK1_WDAY - ISO_WEEK_START_WDAY);
459 #if !(defined _NL_CURRENT || HAVE_STRFTIME)
460 static CHAR_T const weekday_name[][10] =
462 L_("Sunday"), L_("Monday"), L_("Tuesday"), L_("Wednesday"),
463 L_("Thursday"), L_("Friday"), L_("Saturday")
465 static CHAR_T const month_name[][10] =
467 L_("January"), L_("February"), L_("March"), L_("April"), L_("May"),
468 L_("June"), L_("July"), L_("August"), L_("September"), L_("October"),
469 L_("November"), L_("December")
475 # define my_strftime emacs_strftimeu
476 # define ut_argument , ut
477 # define ut_argument_spec int ut;
478 # define ut_argument_spec_iso , int ut
481 # define my_strftime wcsftime
483 # define my_strftime strftime
486 # define ut_argument_spec
487 # define ut_argument_spec_iso
488 /* We don't have this information in general. */
492 #if !defined _LIBC && HAVE_TZNAME && HAVE_TZSET
493 /* Solaris 2.5 tzset sometimes modifies the storage returned by localtime.
494 Work around this bug by copying *tp before it might be munged. */
495 size_t _strftime_copytm __P ((char *, size_t, const char *,
496 const struct tm * ut_argument_spec_iso));
498 my_strftime (s, maxsize, format, tp ut_argument)
501 const CHAR_T *format;
507 return _strftime_copytm (s, maxsize, format, &tmcopy ut_argument);
510 # define my_strftime _strftime_copytm
514 /* Write information from TP into S according to the format
515 string FORMAT, writing no more that MAXSIZE characters
516 (including the terminating '\0') and returning number of
517 characters written. If S is NULL, nothing will be written
518 anywhere, so to determine how many characters would be
519 written, use NULL for S and (size_t) UINT_MAX for MAXSIZE. */
521 my_strftime (s, maxsize, format, tp ut_argument LOCALE_PARAM)
524 const CHAR_T *format;
529 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
530 struct locale_data *const current = loc->__locales[LC_TIME];
533 int hour12 = tp->tm_hour;
535 /* We cannot make the following values variables since we must delay
536 the evaluation of these values until really needed since some
537 expressions might not be valid in every situation. The `struct tm'
538 might be generated by a strptime() call that initialized
539 only a few elements. Dereference the pointers only if the format
540 requires this. Then it is ok to fail if the pointers are invalid. */
542 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABDAY_1) + tp->tm_wday))
544 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(DAY_1) + tp->tm_wday))
546 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABMON_1) + tp->tm_mon))
548 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(MON_1) + tp->tm_mon))
550 ((const CHAR_T *) _NL_CURRENT (LC_TIME, tp->tm_hour > 11 \
551 ? NLW(PM_STR) : NLW(AM_STR)))
553 # define aw_len STRLEN (a_wkday)
554 # define am_len STRLEN (a_month)
555 # define ap_len STRLEN (ampm)
558 # define f_wkday (weekday_name[tp->tm_wday])
559 # define f_month (month_name[tp->tm_mon])
560 # define a_wkday f_wkday
561 # define a_month f_month
562 # define ampm (L_("AMPM") + 2 * (tp->tm_hour > 11))
573 #if DO_MULTIBYTE && !defined COMPILE_WIDE
574 const char *format_end = NULL;
579 /* The POSIX test suite assumes that setting
580 the environment variable TZ to a new value before calling strftime()
581 will influence the result (the %Z format) even if the information in
582 TP is computed with a totally different time zone.
583 This is bogus: though POSIX allows bad behavior like this,
584 POSIX does not require it. Do the right thing instead. */
585 zone = (const char *) tp->tm_zone;
590 if (! (zone && *zone))
595 /* POSIX.1 requires that local time zone information is used as
596 though strftime called tzset. */
609 for (f = format; *f != '\0'; ++f)
611 int pad = 0; /* Padding for number ('-', '_', or 0). */
612 int modifier; /* Field modifier ('E', 'O', or 0). */
613 int digits; /* Max digits for numeric format. */
614 int number_value; /* Numeric value to be printed. */
615 int negative_number; /* 1 if the number is negative. */
616 const CHAR_T *subfmt;
618 CHAR_T buf[1 + (sizeof (int) < sizeof (time_t)
619 ? INT_STRLEN_BOUND (time_t)
620 : INT_STRLEN_BOUND (int))];
627 #if DO_MULTIBYTE && !defined COMPILE_WIDE
633 case L_('\b'): case L_('\t'): case L_('\n'):
634 case L_('\v'): case L_('\f'): case L_('\r'):
635 case L_(' '): case L_('!'): case L_('"'): case L_('#'): case L_('&'):
636 case L_('\''): case L_('('): case L_(')'): case L_('*'): case L_('+'):
637 case L_(','): case L_('-'): case L_('.'): case L_('/'): case L_('0'):
638 case L_('1'): case L_('2'): case L_('3'): case L_('4'): case L_('5'):
639 case L_('6'): case L_('7'): case L_('8'): case L_('9'): case L_(':'):
640 case L_(';'): case L_('<'): case L_('='): case L_('>'): case L_('?'):
641 case L_('A'): case L_('B'): case L_('C'): case L_('D'): case L_('E'):
642 case L_('F'): case L_('G'): case L_('H'): case L_('I'): case L_('J'):
643 case L_('K'): case L_('L'): case L_('M'): case L_('N'): case L_('O'):
644 case L_('P'): case L_('Q'): case L_('R'): case L_('S'): case L_('T'):
645 case L_('U'): case L_('V'): case L_('W'): case L_('X'): case L_('Y'):
646 case L_('Z'): case L_('['): case L_('\\'): case L_(']'): case L_('^'):
647 case L_('_'): case L_('a'): case L_('b'): case L_('c'): case L_('d'):
648 case L_('e'): case L_('f'): case L_('g'): case L_('h'): case L_('i'):
649 case L_('j'): case L_('k'): case L_('l'): case L_('m'): case L_('n'):
650 case L_('o'): case L_('p'): case L_('q'): case L_('r'): case L_('s'):
651 case L_('t'): case L_('u'): case L_('v'): case L_('w'): case L_('x'):
652 case L_('y'): case L_('z'): case L_('{'): case L_('|'): case L_('}'):
654 /* The C Standard requires these 98 characters (plus '%') to
655 be in the basic execution character set. None of these
656 characters can start a multibyte sequence, so they need
657 not be analyzed further. */
662 /* Copy this multibyte sequence until we reach its end, find
663 an error, or come back to the initial shift state. */
665 mbstate_t mbstate = mbstate_zero;
670 format_end = f + strlen (f) + 1;
671 fsize = format_end - f;
675 size_t bytes = mbrlen (f + len, fsize - len, &mbstate);
680 if (bytes == (size_t) -2)
682 len += strlen (f + len);
686 if (bytes == (size_t) -1)
694 while (! mbsinit (&mbstate));
702 #else /* ! DO_MULTIBYTE */
704 /* Either multibyte encodings are not supported, they are
705 safe for formats, so any non-'%' byte can be copied through,
706 or this is the wide character version. */
713 #endif /* ! DO_MULTIBYTE */
715 /* Check for flags that can modify a format. */
720 /* This influences the number formats. */
727 /* This changes textual output. */
741 /* As a GNU extension we allow to specify the field width. */
747 if (width > INT_MAX / 10
748 || (width == INT_MAX / 10 && *f - L_('0') > INT_MAX % 10))
749 /* Avoid overflow. */
754 width += *f - L_('0');
758 while (ISDIGIT (*f));
761 /* Check for modifiers. */
774 /* Now do the specified format. */
778 #define DO_NUMBER(d, v) \
779 digits = d > width ? d : width; \
780 number_value = v; goto do_number
781 #define DO_NUMBER_SPACEPAD(d, v) \
782 digits = d > width ? d : width; \
783 number_value = v; goto do_number_spacepad
799 #if defined _NL_CURRENT || !HAVE_STRFTIME
800 cpy (aw_len, a_wkday);
803 goto underlying_strftime;
814 #if defined _NL_CURRENT || !HAVE_STRFTIME
815 cpy (STRLEN (f_wkday), f_wkday);
818 goto underlying_strftime;
830 #if defined _NL_CURRENT || !HAVE_STRFTIME
831 cpy (am_len, a_month);
834 goto underlying_strftime;
845 #if defined _NL_CURRENT || !HAVE_STRFTIME
846 cpy (STRLEN (f_month), f_month);
849 goto underlying_strftime;
853 if (modifier == L_('O'))
856 if (! (modifier == 'E'
858 (const CHAR_T *) _NL_CURRENT (LC_TIME,
861 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_T_FMT));
864 goto underlying_strftime;
866 subfmt = L_("%a %b %e %H:%M:%S %Y");
872 CHAR_T *old_start = p;
873 size_t len = my_strftime (NULL, (size_t) -1, subfmt,
874 tp ut_argument LOCALE_ARG);
875 add (len, my_strftime (p, maxsize - i, subfmt,
876 tp ut_argument LOCALE_ARG));
879 while (old_start < p)
881 *old_start = TOUPPER ((UCHAR_T) *old_start, loc);
887 #if HAVE_STRFTIME && ! (defined _NL_CURRENT && HAVE_STRUCT_ERA_ENTRY)
890 /* The relevant information is available only via the
891 underlying strftime implementation, so use that. */
894 char ubuf[1024]; /* enough for any single format in practice */
896 /* Make sure we're calling the actual underlying strftime.
897 In some cases, config.h contains something like
898 "#define strftime rpl_strftime". */
909 len = strftime (ubuf, sizeof ubuf, ufmt, tp);
910 if (len == 0 && ubuf[0] != '\0')
918 if (modifier == L_('O'))
920 if (modifier == L_('E'))
922 #if HAVE_STRUCT_ERA_ENTRY
923 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
927 size_t len = __wcslen (era->era_wname);
928 cpy (len, era->era_wname);
930 size_t len = strlen (era->era_name);
931 cpy (len, era->era_name);
937 goto underlying_strftime;
943 int year = tp->tm_year + TM_YEAR_BASE;
944 DO_NUMBER (1, year / 100 - (year % 100 < 0));
948 if (modifier == L_('O'))
951 if (! (modifier == L_('E')
953 (const CHAR_T *)_NL_CURRENT (LC_TIME, NLW(ERA_D_FMT)))
955 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_FMT));
959 goto underlying_strftime;
967 subfmt = L_("%m/%d/%y");
971 if (modifier == L_('E'))
974 DO_NUMBER (2, tp->tm_mday);
977 if (modifier == L_('E'))
980 DO_NUMBER_SPACEPAD (2, tp->tm_mday);
982 /* All numeric formats set DIGITS and NUMBER_VALUE and then
983 jump to one of these two labels. */
986 /* Force `_' flag unless overwritten by `0' flag. */
991 /* Format the number according to the MODIFIER flag. */
993 if (modifier == L_('O') && 0 <= number_value)
996 /* Get the locale specific alternate representation of
997 the number NUMBER_VALUE. If none exist NULL is returned. */
999 const wchar_t *cp = _nl_get_walt_digit (number_value
1002 const char *cp = _nl_get_alt_digit (number_value
1008 size_t digitlen = STRLEN (cp);
1017 goto underlying_strftime;
1022 unsigned int u = number_value;
1024 bufp = buf + sizeof (buf) / sizeof (buf[0]);
1025 negative_number = number_value < 0;
1027 if (negative_number)
1031 *--bufp = u % 10 + L_('0');
1032 while ((u /= 10) != 0);
1035 do_number_sign_and_padding:
1036 if (negative_number)
1041 int padding = digits - (buf + (sizeof (buf) / sizeof (buf[0]))
1048 if ((size_t) padding >= maxsize - i)
1052 memset_space (p, padding);
1054 width = width > padding ? width - padding : 0;
1058 if ((size_t) digits >= maxsize - i)
1061 if (negative_number)
1071 memset_zero (p, padding);
1078 cpy (buf + sizeof (buf) / sizeof (buf[0]) - bufp, bufp);
1084 subfmt = L_("%Y-%m-%d");
1088 if (modifier == L_('E'))
1091 DO_NUMBER (2, tp->tm_hour);
1094 if (modifier == L_('E'))
1097 DO_NUMBER (2, hour12);
1099 case L_('k'): /* GNU extension. */
1100 if (modifier == L_('E'))
1103 DO_NUMBER_SPACEPAD (2, tp->tm_hour);
1105 case L_('l'): /* GNU extension. */
1106 if (modifier == L_('E'))
1109 DO_NUMBER_SPACEPAD (2, hour12);
1112 if (modifier == L_('E'))
1115 DO_NUMBER (3, 1 + tp->tm_yday);
1118 if (modifier == L_('E'))
1121 DO_NUMBER (2, tp->tm_min);
1124 if (modifier == L_('E'))
1127 DO_NUMBER (2, tp->tm_mon + 1);
1130 add (1, *p = L_('\n'));
1135 #if !defined _NL_CURRENT && HAVE_STRFTIME
1136 format_char = L_('p');
1146 #if defined _NL_CURRENT || !HAVE_STRFTIME
1150 goto underlying_strftime;
1154 subfmt = L_("%H:%M");
1159 if (*(subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME,
1163 subfmt = L_("%I:%M:%S %p");
1167 if (modifier == L_('E'))
1170 DO_NUMBER (2, tp->tm_sec);
1172 case L_('s'): /* GNU extension. */
1180 /* Generate string value for T using time_t arithmetic;
1181 this works even if sizeof (long) < sizeof (time_t). */
1183 bufp = buf + sizeof (buf) / sizeof (buf[0]);
1184 negative_number = t < 0;
1191 if (negative_number)
1195 /* Adjust if division truncates to minus infinity. */
1196 if (0 < -1 % 10 && d < 0)
1203 *--bufp = d + L_('0');
1208 goto do_number_sign_and_padding;
1212 if (modifier == L_('O'))
1215 if (! (modifier == L_('E')
1217 (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ERA_T_FMT)))
1219 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(T_FMT));
1223 goto underlying_strftime;
1229 subfmt = L_("%H:%M:%S");
1233 add (1, *p = L_('\t'));
1237 DO_NUMBER (1, (tp->tm_wday - 1 + 7) % 7 + 1);
1240 if (modifier == L_('E'))
1243 DO_NUMBER (2, (tp->tm_yday - tp->tm_wday + 7) / 7);
1248 if (modifier == L_('E'))
1251 int year = tp->tm_year + TM_YEAR_BASE;
1252 int days = iso_week_days (tp->tm_yday, tp->tm_wday);
1256 /* This ISO week belongs to the previous year. */
1258 days = iso_week_days (tp->tm_yday + (365 + __isleap (year)),
1263 int d = iso_week_days (tp->tm_yday - (365 + __isleap (year)),
1267 /* This ISO week belongs to the next year. */
1276 DO_NUMBER (2, (year % 100 + 100) % 100);
1279 DO_NUMBER (1, year);
1282 DO_NUMBER (2, days / 7 + 1);
1287 if (modifier == L_('E'))
1290 DO_NUMBER (2, (tp->tm_yday - (tp->tm_wday - 1 + 7) % 7 + 7) / 7);
1293 if (modifier == L_('E'))
1296 DO_NUMBER (1, tp->tm_wday);
1299 if (modifier == 'E')
1301 #if HAVE_STRUCT_ERA_ENTRY
1302 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
1305 # ifdef COMPILE_WIDE
1306 subfmt = era->era_wformat;
1308 subfmt = era->era_format;
1314 goto underlying_strftime;
1318 if (modifier == L_('O'))
1321 DO_NUMBER (1, tp->tm_year + 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;
1340 DO_NUMBER (2, (tp->tm_year % 100 + 100) % 100);
1350 /* The tzset() call might have changed the value. */
1351 if (!(zone && *zone) && tp->tm_isdst >= 0)
1352 zone = tzname[tp->tm_isdst];
1359 /* The zone string is always given in multibyte form. We have
1360 to transform it first. */
1363 widen (zone, wczone, len);
1367 cpy (strlen (zone), zone);
1372 if (tp->tm_isdst < 0)
1378 diff = tp->tm_gmtoff;
1391 if (lt == (time_t) -1)
1393 /* mktime returns -1 for errors, but -1 is also a
1394 valid time_t value. Check whether an error really
1398 if (! my_strftime_localtime_r (<, &tm)
1399 || ((ltm.tm_sec ^ tm.tm_sec)
1400 | (ltm.tm_min ^ tm.tm_min)
1401 | (ltm.tm_hour ^ tm.tm_hour)
1402 | (ltm.tm_mday ^ tm.tm_mday)
1403 | (ltm.tm_mon ^ tm.tm_mon)
1404 | (ltm.tm_year ^ tm.tm_year)))
1408 if (! my_strftime_gmtime_r (<, >m))
1411 diff = tm_diff (<m, >m);
1417 add (1, *p = L_('-'));
1421 add (1, *p = L_('+'));
1424 DO_NUMBER (4, (diff / 60) * 100 + diff % 60);
1427 case L_('\0'): /* GNU extension: % at end of format. */
1431 /* Unknown format; output the format, including the '%',
1432 since this is most likely the right thing to do if a
1433 multibyte string has been misparsed. */
1437 for (flen = 1; f[1 - flen] != L_('%'); flen++)
1439 cpy (flen, &f[1 - flen]);
1445 if (p && maxsize != 0)
1450 libc_hidden_def (my_strftime)
1455 /* For Emacs we have a separate interface which corresponds to the normal
1456 strftime function and does not have the extra information whether the
1457 TP arguments comes from a `gmtime' call or not. */
1459 emacs_strftime (s, maxsize, format, tp)
1463 const struct tm *tp;
1465 return my_strftime (s, maxsize, format, tp, 0);