1 /* Copyright (C) 1991-1999, 2000, 2001, 2003, 2004 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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;
81 # define CHAR_T wchar_t
82 # define UCHAR_T unsigned int
83 # define L_(Str) L##Str
84 # define NLW(Sym) _NL_W##Sym
86 # define MEMCPY(d, s, n) __wmemcpy (d, s, n)
87 # define STRLEN(s) __wcslen (s)
91 # define UCHAR_T unsigned char
95 # define MEMCPY(d, s, n) memcpy (d, s, n)
96 # define STRLEN(s) strlen (s)
99 # define MEMPCPY(d, s, n) __mempcpy (d, s, n)
101 # ifndef HAVE_MEMPCPY
102 # define MEMPCPY(d, s, n) ((void *) ((char *) memcpy (d, s, n) + (n)))
107 /* Shift A right by B bits portably, by dividing A by 2**B and
108 truncating towards minus infinity. A and B should be free of side
109 effects, and B should be in the range 0 <= B <= INT_BITS - 2, where
110 INT_BITS is the number of useful bits in an int. GNU code can
111 assume that INT_BITS is at least 32.
113 ISO C99 says that A >> B is implementation-defined if A < 0. Some
114 implementations (e.g., UNICOS 9.0 on a Cray Y-MP EL) don't shift
115 right in the usual way when A < 0, so SHR falls back on division if
116 ordinary A >> B doesn't seem to be the usual signed shift. */
120 : (a) / (1 << (b)) - ((a) % (1 << (b)) < 0))
122 #define TYPE_SIGNED(t) ((t) -1 < 0)
124 /* Bound on length of the string representing an integer value of type t.
125 Subtract one for the sign bit if t is signed;
126 302 / 1000 is log10 (2) rounded up;
127 add one for integer division truncation;
128 add one more for a minus sign if t is signed. */
129 #define INT_STRLEN_BOUND(t) \
130 ((sizeof (t) * CHAR_BIT - TYPE_SIGNED (t)) * 302 / 1000 + 1 + TYPE_SIGNED (t))
132 #define TM_YEAR_BASE 1900
135 /* Nonzero if YEAR is a leap year (every 4 years,
136 except every 100th isn't, and every 400th is). */
137 # define __isleap(year) \
138 ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
143 # define tzname __tzname
144 # define tzset __tzset
148 /* Portable standalone applications should supply a "time_r.h" that
149 declares a POSIX-compliant localtime_r, for the benefit of older
150 implementations that lack localtime_r or have a nonstandard one.
151 See the gnulib time_r module for one way to implement this. */
154 # undef __localtime_r
155 # define __gmtime_r gmtime_r
156 # define __localtime_r localtime_r
161 # define memset_space(P, Len) (wmemset (P, L' ', Len), (P) += (Len))
162 # define memset_zero(P, Len) (wmemset (P, L'0', Len), (P) += (Len))
164 # define memset_space(P, Len) (memset (P, ' ', Len), (P) += (Len))
165 # define memset_zero(P, Len) (memset (P, '0', Len), (P) += (Len))
172 int _delta = width - _n; \
173 int _incr = _n + (_delta > 0 ? _delta : 0); \
174 if ((size_t) _incr >= maxsize - i) \
180 if (pad == L_('0')) \
181 memset_zero (p, _delta); \
183 memset_space (p, _delta); \
194 memcpy_lowcase (p, (s), _n LOCALE_ARG); \
195 else if (to_uppcase) \
196 memcpy_uppcase (p, (s), _n LOCALE_ARG); \
198 MEMCPY ((void *) p, (void const *) (s), _n))
201 # ifndef USE_IN_EXTENDED_LOCALE_MODEL
202 # undef __mbsrtowcs_l
203 # define __mbsrtowcs_l(d, s, l, st, loc) __mbsrtowcs (d, s, l, st)
205 # define widen(os, ws, l) \
208 const char *__s = os; \
209 memset (&__st, '\0', sizeof (__st)); \
210 l = __mbsrtowcs_l (NULL, &__s, 0, &__st, loc); \
211 ws = (wchar_t *) alloca ((l + 1) * sizeof (wchar_t)); \
212 (void) __mbsrtowcs_l (ws, &__s, l, &__st, loc); \
217 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
218 /* We use this code also for the extended locale handling where the
219 function gets as an additional argument the locale which has to be
220 used. To access the values we have to redefine the _NL_CURRENT
222 # define strftime __strftime_l
223 # define wcsftime __wcsftime_l
225 # define _NL_CURRENT(category, item) \
226 (current->values[_NL_ITEM_INDEX (item)].string)
227 # define LOCALE_ARG , loc
228 # define LOCALE_PARAM_PROTO , __locale_t loc
229 # define HELPER_LOCALE_ARG , current
231 # define LOCALE_PARAM_PROTO
234 # define HELPER_LOCALE_ARG , _NL_CURRENT_DATA (LC_TIME)
236 # define HELPER_LOCALE_ARG
241 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
242 # define TOUPPER(Ch, L) __towupper_l (Ch, L)
243 # define TOLOWER(Ch, L) __towlower_l (Ch, L)
245 # define TOUPPER(Ch, L) towupper (Ch)
246 # define TOLOWER(Ch, L) towlower (Ch)
250 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
251 # define TOUPPER(Ch, L) __toupper_l (Ch, L)
252 # define TOLOWER(Ch, L) __tolower_l (Ch, L)
254 # define TOUPPER(Ch, L) toupper (Ch)
255 # define TOLOWER(Ch, L) tolower (Ch)
258 # define TOUPPER(Ch, L) (islower (Ch) ? toupper (Ch) : (Ch))
259 # define TOLOWER(Ch, L) (isupper (Ch) ? tolower (Ch) : (Ch))
262 /* We don't use `isdigit' here since the locale dependent
263 interpretation is not what we want here. We only need to accept
264 the arabic digits in the ASCII range. One day there is perhaps a
265 more reliable way to accept other sets of digits. */
266 #define ISDIGIT(Ch) ((unsigned int) (Ch) - L_('0') <= 9)
269 memcpy_lowcase (CHAR_T *dest, const CHAR_T *src,
270 size_t len LOCALE_PARAM_PROTO)
273 dest[len] = TOLOWER ((UCHAR_T) src[len], loc);
278 memcpy_uppcase (CHAR_T *dest, const CHAR_T *src,
279 size_t len LOCALE_PARAM_PROTO)
282 dest[len] = TOUPPER ((UCHAR_T) src[len], loc);
288 /* Yield the difference between *A and *B,
289 measured in seconds, ignoring leap seconds. */
290 # define tm_diff ftime_tm_diff
292 tm_diff (const struct tm *a, const struct tm *b)
294 /* Compute intervening leap days correctly even if year is negative.
295 Take care to avoid int overflow in leap day calculations,
296 but it's OK to assume that A and B are close to each other. */
297 int a4 = SHR (a->tm_year, 2) + SHR (TM_YEAR_BASE, 2) - ! (a->tm_year & 3);
298 int b4 = SHR (b->tm_year, 2) + SHR (TM_YEAR_BASE, 2) - ! (b->tm_year & 3);
299 int a100 = a4 / 25 - (a4 % 25 < 0);
300 int b100 = b4 / 25 - (b4 % 25 < 0);
301 int a400 = SHR (a100, 2);
302 int b400 = SHR (b100, 2);
303 int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
304 int years = a->tm_year - b->tm_year;
305 int days = (365 * years + intervening_leap_days
306 + (a->tm_yday - b->tm_yday));
307 return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
308 + (a->tm_min - b->tm_min))
309 + (a->tm_sec - b->tm_sec));
311 #endif /* ! HAVE_TM_GMTOFF */
315 /* The number of days from the first day of the first ISO week of this
316 year to the year day YDAY with week day WDAY. ISO weeks start on
317 Monday; the first ISO week has the year's first Thursday. YDAY may
318 be as small as YDAY_MINIMUM. */
319 #define ISO_WEEK_START_WDAY 1 /* Monday */
320 #define ISO_WEEK1_WDAY 4 /* Thursday */
321 #define YDAY_MINIMUM (-366)
326 iso_week_days (int yday, int wday)
328 /* Add enough to the first operand of % to make it nonnegative. */
329 int big_enough_multiple_of_7 = (-YDAY_MINIMUM / 7 + 2) * 7;
331 - (yday - wday + ISO_WEEK1_WDAY + big_enough_multiple_of_7) % 7
332 + ISO_WEEK1_WDAY - ISO_WEEK_START_WDAY);
336 #if !(defined _NL_CURRENT || HAVE_STRFTIME)
337 static CHAR_T const weekday_name[][10] =
339 L_("Sunday"), L_("Monday"), L_("Tuesday"), L_("Wednesday"),
340 L_("Thursday"), L_("Friday"), L_("Saturday")
342 static CHAR_T const month_name[][10] =
344 L_("January"), L_("February"), L_("March"), L_("April"), L_("May"),
345 L_("June"), L_("July"), L_("August"), L_("September"), L_("October"),
346 L_("November"), L_("December")
351 /* When compiling this file, GNU applications can #define my_strftime
352 to a symbol (typically nstrftime) to get an extended strftime with
353 extra arguments UT and NS. Emacs is a special case for now, but
354 this Emacs-specific code can be removed once Emacs's config.h
355 defines my_strftime. */
356 #if defined emacs && !defined my_strftime
357 # define my_strftime nstrftime
361 # define extra_args , ut, ns
362 # define extra_args_spec , int ut, int ns
365 # define my_strftime wcsftime
366 # define nl_get_alt_digit _nl_get_walt_digit
368 # define my_strftime strftime
369 # define nl_get_alt_digit _nl_get_alt_digit
372 # define extra_args_spec
373 /* We don't have this information in general. */
378 #if ! defined _LIBC && ! HAVE_RUN_TZSET_TEST
379 /* Solaris 2.5.x and 2.6 tzset sometimes modify the storage returned
380 by localtime. On such systems, we must use the tzset and localtime
381 wrappers to work around the bug. */
382 "you must run the autoconf test for a working tzset function"
386 /* Write information from TP into S according to the format
387 string FORMAT, writing no more that MAXSIZE characters
388 (including the terminating '\0') and returning number of
389 characters written. If S is NULL, nothing will be written
390 anywhere, so to determine how many characters would be
391 written, use NULL for S and (size_t) UINT_MAX for MAXSIZE. */
393 my_strftime (CHAR_T *s, size_t maxsize, const CHAR_T *format,
394 const struct tm *tp extra_args_spec LOCALE_PARAM_PROTO)
396 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
397 struct locale_data *const current = loc->__locales[LC_TIME];
400 int hour12 = tp->tm_hour;
402 /* We cannot make the following values variables since we must delay
403 the evaluation of these values until really needed since some
404 expressions might not be valid in every situation. The `struct tm'
405 might be generated by a strptime() call that initialized
406 only a few elements. Dereference the pointers only if the format
407 requires this. Then it is ok to fail if the pointers are invalid. */
409 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABDAY_1) + tp->tm_wday))
411 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(DAY_1) + tp->tm_wday))
413 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABMON_1) + tp->tm_mon))
415 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(MON_1) + tp->tm_mon))
417 ((const CHAR_T *) _NL_CURRENT (LC_TIME, tp->tm_hour > 11 \
418 ? NLW(PM_STR) : NLW(AM_STR)))
420 # define aw_len STRLEN (a_wkday)
421 # define am_len STRLEN (a_month)
422 # define ap_len STRLEN (ampm)
425 # define f_wkday (weekday_name[tp->tm_wday])
426 # define f_month (month_name[tp->tm_mon])
427 # define a_wkday f_wkday
428 # define a_month f_month
429 # define ampm (L_("AMPM") + 2 * (tp->tm_hour > 11))
440 #if DO_MULTIBYTE && !defined COMPILE_WIDE
441 const char *format_end = NULL;
446 /* The POSIX test suite assumes that setting
447 the environment variable TZ to a new value before calling strftime()
448 will influence the result (the %Z format) even if the information in
449 TP is computed with a totally different time zone.
450 This is bogus: though POSIX allows bad behavior like this,
451 POSIX does not require it. Do the right thing instead. */
452 zone = (const char *) tp->tm_zone;
457 if (! (zone && *zone))
462 /* POSIX.1 requires that local time zone information be used as
463 though strftime called tzset. */
476 for (f = format; *f != '\0'; ++f)
478 int pad = 0; /* Padding for number ('-', '_', or 0). */
479 int modifier; /* Field modifier ('E', 'O', or 0). */
480 int digits; /* Max digits for numeric format. */
481 int number_value; /* Numeric value to be printed. */
482 int negative_number; /* 1 if the number is negative. */
483 const CHAR_T *subfmt;
485 CHAR_T buf[1 + (sizeof (int) < sizeof (time_t)
486 ? INT_STRLEN_BOUND (time_t)
487 : INT_STRLEN_BOUND (int))];
494 #if DO_MULTIBYTE && !defined COMPILE_WIDE
500 case L_('\b'): case L_('\t'): case L_('\n'):
501 case L_('\v'): case L_('\f'): case L_('\r'):
502 case L_(' '): case L_('!'): case L_('"'): case L_('#'): case L_('&'):
503 case L_('\''): case L_('('): case L_(')'): case L_('*'): case L_('+'):
504 case L_(','): case L_('-'): case L_('.'): case L_('/'): case L_('0'):
505 case L_('1'): case L_('2'): case L_('3'): case L_('4'): case L_('5'):
506 case L_('6'): case L_('7'): case L_('8'): case L_('9'): case L_(':'):
507 case L_(';'): case L_('<'): case L_('='): case L_('>'): case L_('?'):
508 case L_('A'): case L_('B'): case L_('C'): case L_('D'): case L_('E'):
509 case L_('F'): case L_('G'): case L_('H'): case L_('I'): case L_('J'):
510 case L_('K'): case L_('L'): case L_('M'): case L_('N'): case L_('O'):
511 case L_('P'): case L_('Q'): case L_('R'): case L_('S'): case L_('T'):
512 case L_('U'): case L_('V'): case L_('W'): case L_('X'): case L_('Y'):
513 case L_('Z'): case L_('['): case L_('\\'): case L_(']'): case L_('^'):
514 case L_('_'): case L_('a'): case L_('b'): case L_('c'): case L_('d'):
515 case L_('e'): case L_('f'): case L_('g'): case L_('h'): case L_('i'):
516 case L_('j'): case L_('k'): case L_('l'): case L_('m'): case L_('n'):
517 case L_('o'): case L_('p'): case L_('q'): case L_('r'): case L_('s'):
518 case L_('t'): case L_('u'): case L_('v'): case L_('w'): case L_('x'):
519 case L_('y'): case L_('z'): case L_('{'): case L_('|'): case L_('}'):
521 /* The C Standard requires these 98 characters (plus '%') to
522 be in the basic execution character set. None of these
523 characters can start a multibyte sequence, so they need
524 not be analyzed further. */
529 /* Copy this multibyte sequence until we reach its end, find
530 an error, or come back to the initial shift state. */
532 mbstate_t mbstate = mbstate_zero;
537 format_end = f + strlen (f) + 1;
538 fsize = format_end - f;
542 size_t bytes = mbrlen (f + len, fsize - len, &mbstate);
547 if (bytes == (size_t) -2)
549 len += strlen (f + len);
553 if (bytes == (size_t) -1)
561 while (! mbsinit (&mbstate));
569 #else /* ! DO_MULTIBYTE */
571 /* Either multibyte encodings are not supported, they are
572 safe for formats, so any non-'%' byte can be copied through,
573 or this is the wide character version. */
580 #endif /* ! DO_MULTIBYTE */
582 /* Check for flags that can modify a format. */
587 /* This influences the number formats. */
594 /* This changes textual output. */
608 /* As a GNU extension we allow to specify the field width. */
614 if (width > INT_MAX / 10
615 || (width == INT_MAX / 10 && *f - L_('0') > INT_MAX % 10))
616 /* Avoid overflow. */
621 width += *f - L_('0');
625 while (ISDIGIT (*f));
628 /* Check for modifiers. */
641 /* Now do the specified format. */
645 #define DO_NUMBER(d, v) \
646 digits = d > width ? d : width; \
647 number_value = v; goto do_number
648 #define DO_NUMBER_SPACEPAD(d, v) \
649 digits = d > width ? d : width; \
650 number_value = v; goto do_number_spacepad
666 #if defined _NL_CURRENT || !HAVE_STRFTIME
667 cpy (aw_len, a_wkday);
670 goto underlying_strftime;
681 #if defined _NL_CURRENT || !HAVE_STRFTIME
682 cpy (STRLEN (f_wkday), f_wkday);
685 goto underlying_strftime;
697 #if defined _NL_CURRENT || !HAVE_STRFTIME
698 cpy (am_len, a_month);
701 goto underlying_strftime;
712 #if defined _NL_CURRENT || !HAVE_STRFTIME
713 cpy (STRLEN (f_month), f_month);
716 goto underlying_strftime;
720 if (modifier == L_('O'))
723 if (! (modifier == 'E'
725 (const CHAR_T *) _NL_CURRENT (LC_TIME,
728 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_T_FMT));
731 goto underlying_strftime;
733 subfmt = L_("%a %b %e %H:%M:%S %Y");
739 CHAR_T *old_start = p;
740 size_t len = my_strftime (NULL, (size_t) -1, subfmt,
741 tp extra_args LOCALE_ARG);
742 add (len, my_strftime (p, maxsize - i, subfmt,
743 tp extra_args LOCALE_ARG));
746 while (old_start < p)
748 *old_start = TOUPPER ((UCHAR_T) *old_start, loc);
754 #if HAVE_STRFTIME && ! (defined _NL_CURRENT && HAVE_STRUCT_ERA_ENTRY)
757 /* The relevant information is available only via the
758 underlying strftime implementation, so use that. */
761 char ubuf[1024]; /* enough for any single format in practice */
763 /* Make sure we're calling the actual underlying strftime.
764 In some cases, config.h contains something like
765 "#define strftime rpl_strftime". */
776 len = strftime (ubuf, sizeof ubuf, ufmt, tp);
777 if (len == 0 && ubuf[0] != '\0')
785 if (modifier == L_('O'))
787 if (modifier == L_('E'))
789 #if HAVE_STRUCT_ERA_ENTRY
790 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
794 size_t len = __wcslen (era->era_wname);
795 cpy (len, era->era_wname);
797 size_t len = strlen (era->era_name);
798 cpy (len, era->era_name);
804 goto underlying_strftime;
810 int year = tp->tm_year + TM_YEAR_BASE;
811 DO_NUMBER (1, year / 100 - (year % 100 < 0));
815 if (modifier == L_('O'))
818 if (! (modifier == L_('E')
820 (const CHAR_T *)_NL_CURRENT (LC_TIME, NLW(ERA_D_FMT)))
822 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_FMT));
826 goto underlying_strftime;
834 subfmt = L_("%m/%d/%y");
838 if (modifier == L_('E'))
841 DO_NUMBER (2, tp->tm_mday);
844 if (modifier == L_('E'))
847 DO_NUMBER_SPACEPAD (2, tp->tm_mday);
849 /* All numeric formats set DIGITS and NUMBER_VALUE and then
850 jump to one of these two labels. */
853 /* Force `_' flag unless overridden by `0' or `-' flag. */
854 if (pad != L_('0') && pad != L_('-'))
858 /* Format the number according to the MODIFIER flag. */
860 if (modifier == L_('O') && 0 <= number_value)
863 /* Get the locale specific alternate representation of
864 the number NUMBER_VALUE. If none exist NULL is returned. */
865 const CHAR_T *cp = nl_get_alt_digit (number_value
870 size_t digitlen = STRLEN (cp);
879 goto underlying_strftime;
884 unsigned int u = number_value;
886 bufp = buf + sizeof (buf) / sizeof (buf[0]);
887 negative_number = number_value < 0;
893 *--bufp = u % 10 + L_('0');
894 while ((u /= 10) != 0);
897 do_number_sign_and_padding:
903 int padding = digits - (buf + (sizeof (buf) / sizeof (buf[0]))
910 if ((size_t) padding >= maxsize - i)
914 memset_space (p, padding);
916 width = width > padding ? width - padding : 0;
920 if ((size_t) digits >= maxsize - i)
933 memset_zero (p, padding);
940 cpy (buf + sizeof (buf) / sizeof (buf[0]) - bufp, bufp);
946 subfmt = L_("%Y-%m-%d");
950 if (modifier == L_('E'))
953 DO_NUMBER (2, tp->tm_hour);
956 if (modifier == L_('E'))
959 DO_NUMBER (2, hour12);
961 case L_('k'): /* GNU extension. */
962 if (modifier == L_('E'))
965 DO_NUMBER_SPACEPAD (2, tp->tm_hour);
967 case L_('l'): /* GNU extension. */
968 if (modifier == L_('E'))
971 DO_NUMBER_SPACEPAD (2, hour12);
974 if (modifier == L_('E'))
977 DO_NUMBER (3, 1 + tp->tm_yday);
980 if (modifier == L_('E'))
983 DO_NUMBER (2, tp->tm_min);
986 if (modifier == L_('E'))
989 DO_NUMBER (2, tp->tm_mon + 1);
992 case L_('N'): /* GNU extension. */
993 if (modifier == L_('E'))
999 /* Take an explicit width less than 9 as a precision. */
1001 for (j = width; j < 9; j++)
1005 DO_NUMBER (9, number_value);
1009 add (1, *p = L_('\n'));
1014 #if !defined _NL_CURRENT && HAVE_STRFTIME
1015 format_char = L_('p');
1025 #if defined _NL_CURRENT || !HAVE_STRFTIME
1029 goto underlying_strftime;
1033 subfmt = L_("%H:%M");
1037 #if !defined _NL_CURRENT && HAVE_STRFTIME
1038 goto underlying_strftime;
1041 if (*(subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME,
1045 subfmt = L_("%I:%M:%S %p");
1050 if (modifier == L_('E'))
1053 DO_NUMBER (2, tp->tm_sec);
1055 case L_('s'): /* GNU extension. */
1063 /* Generate string value for T using time_t arithmetic;
1064 this works even if sizeof (long) < sizeof (time_t). */
1066 bufp = buf + sizeof (buf) / sizeof (buf[0]);
1067 negative_number = t < 0;
1074 if (negative_number)
1078 /* Adjust if division truncates to minus infinity. */
1079 if (0 < -1 % 10 && d < 0)
1086 *--bufp = d + L_('0');
1091 goto do_number_sign_and_padding;
1095 if (modifier == L_('O'))
1098 if (! (modifier == L_('E')
1100 (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ERA_T_FMT)))
1102 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(T_FMT));
1106 goto underlying_strftime;
1112 subfmt = L_("%H:%M:%S");
1116 add (1, *p = L_('\t'));
1120 DO_NUMBER (1, (tp->tm_wday - 1 + 7) % 7 + 1);
1123 if (modifier == L_('E'))
1126 DO_NUMBER (2, (tp->tm_yday - tp->tm_wday + 7) / 7);
1131 if (modifier == L_('E'))
1134 int year = tp->tm_year + TM_YEAR_BASE;
1135 int days = iso_week_days (tp->tm_yday, tp->tm_wday);
1139 /* This ISO week belongs to the previous year. */
1141 days = iso_week_days (tp->tm_yday + (365 + __isleap (year)),
1146 int d = iso_week_days (tp->tm_yday - (365 + __isleap (year)),
1150 /* This ISO week belongs to the next year. */
1159 DO_NUMBER (2, (year % 100 + 100) % 100);
1162 DO_NUMBER (1, year);
1165 DO_NUMBER (2, days / 7 + 1);
1170 if (modifier == L_('E'))
1173 DO_NUMBER (2, (tp->tm_yday - (tp->tm_wday - 1 + 7) % 7 + 7) / 7);
1176 if (modifier == L_('E'))
1179 DO_NUMBER (1, tp->tm_wday);
1182 if (modifier == 'E')
1184 #if HAVE_STRUCT_ERA_ENTRY
1185 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
1188 # ifdef COMPILE_WIDE
1189 subfmt = era->era_wformat;
1191 subfmt = era->era_format;
1197 goto underlying_strftime;
1201 if (modifier == L_('O'))
1204 DO_NUMBER (1, tp->tm_year + TM_YEAR_BASE);
1207 if (modifier == L_('E'))
1209 #if HAVE_STRUCT_ERA_ENTRY
1210 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
1213 int delta = tp->tm_year - era->start_date[0];
1214 DO_NUMBER (1, (era->offset
1215 + delta * era->absolute_direction));
1219 goto underlying_strftime;
1223 DO_NUMBER (2, (tp->tm_year % 100 + 100) % 100);
1233 /* The tzset() call might have changed the value. */
1234 if (!(zone && *zone) && tp->tm_isdst >= 0)
1235 zone = tzname[tp->tm_isdst];
1242 /* The zone string is always given in multibyte form. We have
1243 to transform it first. */
1246 widen (zone, wczone, len);
1250 cpy (strlen (zone), zone);
1255 if (tp->tm_isdst < 0)
1261 diff = tp->tm_gmtoff;
1274 if (lt == (time_t) -1)
1276 /* mktime returns -1 for errors, but -1 is also a
1277 valid time_t value. Check whether an error really
1281 if (! __localtime_r (<, &tm)
1282 || ((ltm.tm_sec ^ tm.tm_sec)
1283 | (ltm.tm_min ^ tm.tm_min)
1284 | (ltm.tm_hour ^ tm.tm_hour)
1285 | (ltm.tm_mday ^ tm.tm_mday)
1286 | (ltm.tm_mon ^ tm.tm_mon)
1287 | (ltm.tm_year ^ tm.tm_year)))
1291 if (! __gmtime_r (<, >m))
1294 diff = tm_diff (<m, >m);
1300 add (1, *p = L_('-'));
1304 add (1, *p = L_('+'));
1307 DO_NUMBER (4, (diff / 60) * 100 + diff % 60);
1310 case L_('\0'): /* GNU extension: % at end of format. */
1314 /* Unknown format; output the format, including the '%',
1315 since this is most likely the right thing to do if a
1316 multibyte string has been misparsed. */
1320 for (flen = 1; f[1 - flen] != L_('%'); flen++)
1322 cpy (flen, &f[1 - flen]);
1328 if (p && maxsize != 0)
1333 libc_hidden_def (my_strftime)
1338 /* For Emacs we have a separate interface which corresponds to the normal
1339 strftime function plus the ut argument, but without the ns argument. */
1341 emacs_strftimeu (char *s, size_t maxsize, const char *format,
1342 const struct tm *tp, int ut)
1344 return my_strftime (s, maxsize, format, tp, ut, 0);