1 /* Copyright (C) 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
2 2001, 2002, 2003, 2004, 2005, 2006, 2007
3 Free Software Foundation, Inc.
5 NOTE: The canonical source of this file is maintained with gnulib.
6 Bugs can be reported to bug-gnulib@gnu.org.
8 This file is part of the GNU Emacs.
10 This program is free software; you can redistribute it and/or
11 modify it under the terms of the GNU General Public License
12 as published by the Free Software Foundation; either version 2, or
13 (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 General Public License for more details.
20 You should have received a copy of the GNU General Public
21 License along with the GNU C Library; see the file COPYING. If not,
22 write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
23 Boston, MA 02110-1301, USA. */
30 # define HAVE_LIMITS_H 1
32 # define HAVE_MBRLEN 1
33 # define HAVE_STRUCT_ERA_ENTRY 1
34 # define HAVE_TM_GMTOFF 1
35 # define HAVE_TM_ZONE 1
36 # define HAVE_TZNAME 1
38 # define MULTIBYTE_IS_FORMAT_SAFE 1
39 # define STDC_HEADERS 1
40 # include "../locale/localeinfo.h"
44 #include <sys/types.h> /* Some systems define `time_t' here. */
46 #ifdef TIME_WITH_SYS_TIME
47 # include <sys/time.h>
50 # ifdef HAVE_SYS_TIME_H
51 # include <sys/time.h>
58 extern char *tzname
[];
62 /* Do multibyte processing if multibytes are supported, unless
63 multibyte sequences are safe in formats. Multibyte sequences are
64 safe if they cannot contain byte sequences that look like format
65 conversion specifications. The GNU C Library uses UTF8 multibyte
66 encoding, which is safe for formats, but strftime.c can be used
67 with other C libraries that use unsafe encodings. */
68 #define DO_MULTIBYTE (HAVE_MBLEN && ! MULTIBYTE_IS_FORMAT_SAFE)
73 # ifdef HAVE_SYS__MBSTATE_T_H /* previously tested __hpux */
74 # include <sys/_mbstate_t.h>
76 # if !defined (mbsinit) && !defined (HAVE_MBSINIT)
77 # define mbsinit(ps) 1
78 # endif /* !defined (mbsinit) && !defined (HAVE_MBSINIT) */
80 /* Simulate mbrlen with mblen as best we can. */
81 # define mbstate_t int
82 # define mbrlen(s, n, ps) mblen (s, n)
83 # define mbsinit(ps) (*(ps) == 0)
85 static const mbstate_t mbstate_zero
;
98 # define memcpy(d, s, n) bcopy ((s), (d), (n))
104 # define CHAR_T wchar_t
105 # define UCHAR_T unsigned int
106 # define L_(Str) L##Str
107 # define NLW(Sym) _NL_W##Sym
109 # define MEMCPY(d, s, n) __wmemcpy (d, s, n)
110 # define STRLEN(s) __wcslen (s)
114 # define UCHAR_T unsigned char
116 # define NLW(Sym) Sym
118 # if !defined STDC_HEADERS && !defined HAVE_MEMCPY
119 # define MEMCPY(d, s, n) bcopy ((s), (d), (n))
121 # define MEMCPY(d, s, n) memcpy ((d), (s), (n))
123 # define STRLEN(s) strlen (s)
126 # define MEMPCPY(d, s, n) __mempcpy (d, s, n)
128 # ifndef HAVE_MEMPCPY
129 # define MEMPCPY(d, s, n) ((void *) ((char *) memcpy (d, s, n) + (n)))
150 #define TYPE_SIGNED(t) ((t) -1 < 0)
152 /* Bound on length of the string representing an integer value of type t.
153 Subtract one for the sign bit if t is signed;
154 302 / 1000 is log10 (2) rounded up;
155 add one for integer division truncation;
156 add one more for a minus sign if t is signed. */
157 #define INT_STRLEN_BOUND(t) \
158 ((sizeof (t) * CHAR_BIT - TYPE_SIGNED (t)) * 302 / 1000 + 1 + TYPE_SIGNED (t))
160 #define TM_YEAR_BASE 1900
163 /* Nonzero if YEAR is a leap year (every 4 years,
164 except every 100th isn't, and every 400th is). */
165 # define __isleap(year) \
166 ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
171 # define my_strftime_gmtime_r __gmtime_r
172 # define my_strftime_localtime_r __localtime_r
173 # define tzname __tzname
174 # define tzset __tzset
177 /* If we're a strftime substitute in a GNU program, then prefer gmtime
178 to gmtime_r, since many gmtime_r implementations are buggy.
179 Similarly for localtime_r. */
181 # if ! HAVE_TM_GMTOFF
182 static struct tm
*my_strftime_gmtime_r (const time_t *, struct tm
*);
184 my_strftime_gmtime_r (t
, tp
)
188 struct tm
*l
= gmtime (t
);
195 static struct tm
*my_strftime_localtime_r (const time_t *, struct tm
*);
197 my_strftime_localtime_r (t
, tp
)
201 struct tm
*l
= localtime (t
);
207 # endif /* ! HAVE_TM_GMTOFF */
208 #endif /* ! defined _LIBC */
211 #if !defined memset && !defined HAVE_MEMSET && !defined _LIBC
212 /* Some systems lack the `memset' function and we don't want to
213 introduce additional dependencies. */
214 /* The SGI compiler reportedly barfs on the trailing null
215 if we use a string constant as the initializer. 28 June 1997, rms. */
216 static const CHAR_T spaces
[16] = /* " " */
218 L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),
219 L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' ')
221 static const CHAR_T zeroes
[16] = /* "0000000000000000" */
223 L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),
224 L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0')
227 # define memset_space(P, Len) \
233 int _this = _len > 16 ? 16 : _len; \
234 (P) = MEMPCPY ((P), spaces, _this * sizeof (CHAR_T)); \
240 # define memset_zero(P, Len) \
246 int _this = _len > 16 ? 16 : _len; \
247 (P) = MEMPCPY ((P), zeroes, _this * sizeof (CHAR_T)); \
254 # define memset_space(P, Len) (wmemset ((P), L' ', (Len)), (P) += (Len))
255 # define memset_zero(P, Len) (wmemset ((P), L'0', (Len)), (P) += (Len))
257 # define memset_space(P, Len) (memset ((P), ' ', (Len)), (P) += (Len))
258 # define memset_zero(P, Len) (memset ((P), '0', (Len)), (P) += (Len))
266 int _delta = width - _n; \
267 int _incr = _n + (_delta > 0 ? _delta : 0); \
268 if ((size_t) _incr >= maxsize - i) \
274 if (pad == L_('0')) \
275 memset_zero (p, _delta); \
277 memset_space (p, _delta); \
288 memcpy_lowcase (p, (s), _n LOCALE_ARG); \
289 else if (to_uppcase) \
290 memcpy_uppcase (p, (s), _n LOCALE_ARG); \
292 MEMCPY ((PTR) p, (const PTR) (s), _n))
295 # ifndef USE_IN_EXTENDED_LOCALE_MODEL
296 # undef __mbsrtowcs_l
297 # define __mbsrtowcs_l(d, s, l, st, loc) __mbsrtowcs (d, s, l, st)
299 # define widen(os, ws, l) \
302 const char *__s = os; \
303 memset (&__st, '\0', sizeof (__st)); \
304 l = __mbsrtowcs_l (NULL, &__s, 0, &__st, loc); \
305 ws = (wchar_t *) alloca ((l + 1) * sizeof (wchar_t)); \
306 (void) __mbsrtowcs_l (ws, &__s, l, &__st, loc); \
311 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
312 /* We use this code also for the extended locale handling where the
313 function gets as an additional argument the locale which has to be
314 used. To access the values we have to redefine the _NL_CURRENT
316 # define strftime __strftime_l
317 # define wcsftime __wcsftime_l
319 # define _NL_CURRENT(category, item) \
320 (current->values[_NL_ITEM_INDEX (item)].string)
321 # define LOCALE_PARAM , loc
322 # define LOCALE_ARG , loc
323 # define LOCALE_PARAM_DECL __locale_t loc;
324 # define LOCALE_PARAM_PROTO , __locale_t loc
325 # define HELPER_LOCALE_ARG , current
327 # define LOCALE_PARAM
328 # define LOCALE_PARAM_PROTO
330 # define LOCALE_PARAM_DECL
332 # define HELPER_LOCALE_ARG , _NL_CURRENT_DATA (LC_TIME)
334 # define HELPER_LOCALE_ARG
339 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
340 # define TOUPPER(Ch, L) __towupper_l (Ch, L)
341 # define TOLOWER(Ch, L) __towlower_l (Ch, L)
343 # define TOUPPER(Ch, L) towupper (Ch)
344 # define TOLOWER(Ch, L) towlower (Ch)
348 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
349 # define TOUPPER(Ch, L) __toupper_l (Ch, L)
350 # define TOLOWER(Ch, L) __tolower_l (Ch, L)
352 # define TOUPPER(Ch, L) toupper (Ch)
353 # define TOLOWER(Ch, L) tolower (Ch)
356 # define TOUPPER(Ch, L) (islower (Ch) ? toupper (Ch) : (Ch))
357 # define TOLOWER(Ch, L) (isupper (Ch) ? tolower (Ch) : (Ch))
360 /* We don't use `isdigit' here since the locale dependent
361 interpretation is not what we want here. We only need to accept
362 the arabic digits in the ASCII range. One day there is perhaps a
363 more reliable way to accept other sets of digits. */
364 #define ISDIGIT(Ch) ((unsigned int) (Ch) - L_('0') <= 9)
366 static CHAR_T
*memcpy_lowcase (CHAR_T
*dest
, const CHAR_T
*src
,
367 size_t len LOCALE_PARAM_PROTO
);
370 memcpy_lowcase (dest
, src
, len LOCALE_PARAM
)
377 dest
[len
] = TOLOWER ((UCHAR_T
) src
[len
], loc
);
381 static CHAR_T
*memcpy_uppcase (CHAR_T
*dest
, const CHAR_T
*src
,
382 size_t len LOCALE_PARAM_PROTO
);
385 memcpy_uppcase (dest
, src
, len LOCALE_PARAM
)
392 dest
[len
] = TOUPPER ((UCHAR_T
) src
[len
], loc
);
398 /* Yield the difference between *A and *B,
399 measured in seconds, ignoring leap seconds. */
400 # define tm_diff ftime_tm_diff
401 static int tm_diff (const struct tm
*, const struct tm
*);
407 /* Compute intervening leap days correctly even if year is negative.
408 Take care to avoid int overflow in leap day calculations,
409 but it's OK to assume that A and B are close to each other. */
410 int a4
= (a
->tm_year
>> 2) + (TM_YEAR_BASE
>> 2) - ! (a
->tm_year
& 3);
411 int b4
= (b
->tm_year
>> 2) + (TM_YEAR_BASE
>> 2) - ! (b
->tm_year
& 3);
412 int a100
= a4
/ 25 - (a4
% 25 < 0);
413 int b100
= b4
/ 25 - (b4
% 25 < 0);
414 int a400
= a100
>> 2;
415 int b400
= b100
>> 2;
416 int intervening_leap_days
= (a4
- b4
) - (a100
- b100
) + (a400
- b400
);
417 int years
= a
->tm_year
- b
->tm_year
;
418 int days
= (365 * years
+ intervening_leap_days
419 + (a
->tm_yday
- b
->tm_yday
));
420 return (60 * (60 * (24 * days
+ (a
->tm_hour
- b
->tm_hour
))
421 + (a
->tm_min
- b
->tm_min
))
422 + (a
->tm_sec
- b
->tm_sec
));
424 #endif /* ! HAVE_TM_GMTOFF */
428 /* The number of days from the first day of the first ISO week of this
429 year to the year day YDAY with week day WDAY. ISO weeks start on
430 Monday; the first ISO week has the year's first Thursday. YDAY may
431 be as small as YDAY_MINIMUM. */
432 #define ISO_WEEK_START_WDAY 1 /* Monday */
433 #define ISO_WEEK1_WDAY 4 /* Thursday */
434 #define YDAY_MINIMUM (-366)
435 static int iso_week_days (int, int);
440 iso_week_days (yday
, wday
)
444 /* Add enough to the first operand of % to make it nonnegative. */
445 int big_enough_multiple_of_7
= (-YDAY_MINIMUM
/ 7 + 2) * 7;
447 - (yday
- wday
+ ISO_WEEK1_WDAY
+ big_enough_multiple_of_7
) % 7
448 + ISO_WEEK1_WDAY
- ISO_WEEK_START_WDAY
);
452 #if !(defined _NL_CURRENT || HAVE_STRFTIME)
453 static CHAR_T
const weekday_name
[][10] =
455 L_("Sunday"), L_("Monday"), L_("Tuesday"), L_("Wednesday"),
456 L_("Thursday"), L_("Friday"), L_("Saturday")
458 static CHAR_T
const month_name
[][10] =
460 L_("January"), L_("February"), L_("March"), L_("April"), L_("May"),
461 L_("June"), L_("July"), L_("August"), L_("September"), L_("October"),
462 L_("November"), L_("December")
467 /* When compiling this file, GNU applications can #define my_strftime
468 to a symbol (typically nstrftime) to get an extended strftime with
469 extra arguments UT and NS. */
472 # define extra_args , ut, ns
473 # define extra_args_spec int ut; int ns;
474 # define extra_args_spec_iso , int ut, int ns
477 # define my_strftime wcsftime
478 # define nl_get_alt_digit _nl_get_walt_digit
480 # define my_strftime strftime
481 # define nl_get_alt_digit _nl_get_alt_digit
484 # define extra_args_spec
485 # define extra_args_spec_iso
486 /* We don't have this information in general. */
491 #if !defined _LIBC && !defined(WINDOWSNT) && HAVE_TZNAME && HAVE_TZSET
492 /* Solaris 2.5 tzset sometimes modifies the storage returned by localtime.
493 Work around this bug by copying *tp before it might be munged. */
494 size_t _strftime_copytm (char *, size_t, const char *,
495 const struct tm
* extra_args_spec_iso
);
497 my_strftime (s
, maxsize
, format
, tp extra_args
)
500 const CHAR_T
*format
;
506 return _strftime_copytm (s
, maxsize
, format
, &tmcopy extra_args
);
509 # define my_strftime _strftime_copytm
513 /* Write information from TP into S according to the format
514 string FORMAT, writing no more that MAXSIZE characters
515 (including the terminating '\0') and returning number of
516 characters written. If S is NULL, nothing will be written
517 anywhere, so to determine how many characters would be
518 written, use NULL for S and (size_t) UINT_MAX for MAXSIZE. */
520 my_strftime (s
, maxsize
, format
, tp extra_args LOCALE_PARAM
)
523 const CHAR_T
*format
;
528 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
529 struct locale_data
*const current
= loc
->__locales
[LC_TIME
];
532 int hour12
= tp
->tm_hour
;
534 /* We cannot make the following values variables since we must delay
535 the evaluation of these values until really needed since some
536 expressions might not be valid in every situation. The `struct tm'
537 might be generated by a strptime() call that initialized
538 only a few elements. Dereference the pointers only if the format
539 requires this. Then it is ok to fail if the pointers are invalid. */
541 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABDAY_1) + tp->tm_wday))
543 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(DAY_1) + tp->tm_wday))
545 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABMON_1) + tp->tm_mon))
547 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(MON_1) + tp->tm_mon))
549 ((const CHAR_T *) _NL_CURRENT (LC_TIME, tp->tm_hour > 11 \
550 ? NLW(PM_STR) : NLW(AM_STR)))
552 # define aw_len STRLEN (a_wkday)
553 # define am_len STRLEN (a_month)
554 # define ap_len STRLEN (ampm)
557 # define f_wkday (weekday_name[tp->tm_wday])
558 # define f_month (month_name[tp->tm_mon])
559 # define a_wkday f_wkday
560 # define a_month f_month
561 # define ampm (L_("AMPM") + 2 * (tp->tm_hour > 11))
572 #if DO_MULTIBYTE && !defined COMPILE_WIDE
573 const char *format_end
= NULL
;
578 /* The POSIX test suite assumes that setting
579 the environment variable TZ to a new value before calling strftime()
580 will influence the result (the %Z format) even if the information in
581 TP is computed with a totally different time zone.
582 This is bogus: though POSIX allows bad behavior like this,
583 POSIX does not require it. Do the right thing instead. */
584 zone
= (const char *) tp
->tm_zone
;
589 if (! (zone
&& *zone
))
594 /* POSIX.1 requires that local time zone information be used as
595 though strftime called tzset. */
608 for (f
= format
; *f
!= '\0'; ++f
)
610 int pad
= 0; /* Padding for number ('-', '_', or 0). */
611 int modifier
; /* Field modifier ('E', 'O', or 0). */
612 int digits
; /* Max digits for numeric format. */
613 int number_value
; /* Numeric value to be printed. */
614 int negative_number
; /* 1 if the number is negative. */
615 const CHAR_T
*subfmt
;
617 CHAR_T buf
[1 + (sizeof (int) < sizeof (time_t)
618 ? INT_STRLEN_BOUND (time_t)
619 : INT_STRLEN_BOUND (int))];
626 #if DO_MULTIBYTE && !defined COMPILE_WIDE
632 case L_('\b'): case L_('\t'): case L_('\n'):
633 case L_('\v'): case L_('\f'): case L_('\r'):
634 case L_(' '): case L_('!'): case L_('"'): case L_('#'): case L_('&'):
635 case L_('\''): case L_('('): case L_(')'): case L_('*'): case L_('+'):
636 case L_(','): case L_('-'): case L_('.'): case L_('/'): case L_('0'):
637 case L_('1'): case L_('2'): case L_('3'): case L_('4'): case L_('5'):
638 case L_('6'): case L_('7'): case L_('8'): case L_('9'): case L_(':'):
639 case L_(';'): case L_('<'): case L_('='): case L_('>'): case L_('?'):
640 case L_('A'): case L_('B'): case L_('C'): case L_('D'): case L_('E'):
641 case L_('F'): case L_('G'): case L_('H'): case L_('I'): case L_('J'):
642 case L_('K'): case L_('L'): case L_('M'): case L_('N'): case L_('O'):
643 case L_('P'): case L_('Q'): case L_('R'): case L_('S'): case L_('T'):
644 case L_('U'): case L_('V'): case L_('W'): case L_('X'): case L_('Y'):
645 case L_('Z'): case L_('['): case L_('\\'): case L_(']'): case L_('^'):
646 case L_('_'): case L_('a'): case L_('b'): case L_('c'): case L_('d'):
647 case L_('e'): case L_('f'): case L_('g'): case L_('h'): case L_('i'):
648 case L_('j'): case L_('k'): case L_('l'): case L_('m'): case L_('n'):
649 case L_('o'): case L_('p'): case L_('q'): case L_('r'): case L_('s'):
650 case L_('t'): case L_('u'): case L_('v'): case L_('w'): case L_('x'):
651 case L_('y'): case L_('z'): case L_('{'): case L_('|'): case L_('}'):
653 /* The C Standard requires these 98 characters (plus '%') to
654 be in the basic execution character set. None of these
655 characters can start a multibyte sequence, so they need
656 not be analyzed further. */
661 /* Copy this multibyte sequence until we reach its end, find
662 an error, or come back to the initial shift state. */
664 mbstate_t mbstate
= mbstate_zero
;
669 format_end
= f
+ strlen (f
) + 1;
670 fsize
= format_end
- f
;
674 size_t bytes
= mbrlen (f
+ len
, fsize
- len
, &mbstate
);
679 if (bytes
== (size_t) -2)
681 len
+= strlen (f
+ len
);
685 if (bytes
== (size_t) -1)
693 while (! mbsinit (&mbstate
));
701 #else /* ! DO_MULTIBYTE */
703 /* Either multibyte encodings are not supported, they are
704 safe for formats, so any non-'%' byte can be copied through,
705 or this is the wide character version. */
712 #endif /* ! DO_MULTIBYTE */
714 /* Check for flags that can modify a format. */
719 /* This influences the number formats. */
726 /* This changes textual output. */
740 /* As a GNU extension we allow to specify the field width. */
746 if (width
> INT_MAX
/ 10
747 || (width
== INT_MAX
/ 10 && *f
- L_('0') > INT_MAX
% 10))
748 /* Avoid overflow. */
753 width
+= *f
- L_('0');
757 while (ISDIGIT (*f
));
760 /* Check for modifiers. */
773 /* Now do the specified format. */
777 #define DO_NUMBER(d, v) \
778 digits = d > width ? d : width; \
779 number_value = v; goto do_number
780 #define DO_NUMBER_SPACEPAD(d, v) \
781 digits = d > width ? d : width; \
782 number_value = v; goto do_number_spacepad
798 #if defined _NL_CURRENT || !HAVE_STRFTIME
799 cpy (aw_len
, a_wkday
);
802 goto underlying_strftime
;
813 #if defined _NL_CURRENT || !HAVE_STRFTIME
814 cpy (STRLEN (f_wkday
), f_wkday
);
817 goto underlying_strftime
;
829 #if defined _NL_CURRENT || !HAVE_STRFTIME
830 cpy (am_len
, a_month
);
833 goto underlying_strftime
;
844 #if defined _NL_CURRENT || !HAVE_STRFTIME
845 cpy (STRLEN (f_month
), f_month
);
848 goto underlying_strftime
;
852 if (modifier
== L_('O'))
855 if (! (modifier
== 'E'
857 (const CHAR_T
*) _NL_CURRENT (LC_TIME
,
860 subfmt
= (const CHAR_T
*) _NL_CURRENT (LC_TIME
, NLW(D_T_FMT
));
863 goto underlying_strftime
;
865 subfmt
= L_("%a %b %e %H:%M:%S %Y");
871 CHAR_T
*old_start
= p
;
872 size_t len
= my_strftime (NULL
, (size_t) -1, subfmt
,
873 tp extra_args LOCALE_ARG
);
874 add (len
, my_strftime (p
, maxsize
- i
, subfmt
,
875 tp extra_args LOCALE_ARG
));
878 while (old_start
< p
)
880 *old_start
= TOUPPER ((UCHAR_T
) *old_start
, loc
);
886 #if HAVE_STRFTIME && ! (defined _NL_CURRENT && HAVE_STRUCT_ERA_ENTRY)
889 /* The relevant information is available only via the
890 underlying strftime implementation, so use that. */
893 char ubuf
[1024]; /* enough for any single format in practice */
895 /* Make sure we're calling the actual underlying strftime.
896 In some cases, config.h contains something like
897 "#define strftime rpl_strftime". */
903 #ifdef STRFTIME_NO_POSIX2
904 /* Some system libraries do not support the POSIX.2 extensions.
905 In those cases, convert %h to %b, and strip modifiers. */
907 if (format_char
== 'h')
915 len
= strftime (ubuf
, sizeof ubuf
, ufmt
, tp
);
916 if (len
== 0 && ubuf
[0] != '\0')
924 if (modifier
== L_('O'))
926 if (modifier
== L_('E'))
928 #if HAVE_STRUCT_ERA_ENTRY
929 struct era_entry
*era
= _nl_get_era_entry (tp HELPER_LOCALE_ARG
);
933 size_t len
= __wcslen (era
->era_wname
);
934 cpy (len
, era
->era_wname
);
936 size_t len
= strlen (era
->era_name
);
937 cpy (len
, era
->era_name
);
943 goto underlying_strftime
;
949 int year
= tp
->tm_year
+ TM_YEAR_BASE
;
950 DO_NUMBER (1, year
/ 100 - (year
% 100 < 0));
954 if (modifier
== L_('O'))
957 if (! (modifier
== L_('E')
959 (const CHAR_T
*)_NL_CURRENT (LC_TIME
, NLW(ERA_D_FMT
)))
961 subfmt
= (const CHAR_T
*) _NL_CURRENT (LC_TIME
, NLW(D_FMT
));
965 goto underlying_strftime
;
973 subfmt
= L_("%m/%d/%y");
977 if (modifier
== L_('E'))
980 DO_NUMBER (2, tp
->tm_mday
);
983 if (modifier
== L_('E'))
986 DO_NUMBER_SPACEPAD (2, tp
->tm_mday
);
988 /* All numeric formats set DIGITS and NUMBER_VALUE and then
989 jump to one of these two labels. */
992 /* Force `_' flag unless overridden by `0' or `-' flag. */
993 if (pad
!= L_('0') && pad
!= L_('-'))
997 /* Format the number according to the MODIFIER flag. */
999 if (modifier
== L_('O') && 0 <= number_value
)
1002 /* Get the locale specific alternate representation of
1003 the number NUMBER_VALUE. If none exist NULL is returned. */
1004 const CHAR_T
*cp
= nl_get_alt_digit (number_value
1009 size_t digitlen
= STRLEN (cp
);
1018 goto underlying_strftime
;
1023 unsigned int u
= number_value
;
1025 bufp
= buf
+ sizeof (buf
) / sizeof (buf
[0]);
1026 negative_number
= number_value
< 0;
1028 if (negative_number
)
1032 *--bufp
= u
% 10 + L_('0');
1033 while ((u
/= 10) != 0);
1036 do_number_sign_and_padding
:
1037 if (negative_number
)
1042 int padding
= digits
- (buf
+ (sizeof (buf
) / sizeof (buf
[0]))
1049 if ((size_t) padding
>= maxsize
- i
)
1053 memset_space (p
, padding
);
1055 width
= width
> padding
? width
- padding
: 0;
1059 if ((size_t) digits
>= maxsize
- i
)
1062 if (negative_number
)
1072 memset_zero (p
, padding
);
1079 cpy (buf
+ sizeof (buf
) / sizeof (buf
[0]) - bufp
, bufp
);
1085 subfmt
= L_("%Y-%m-%d");
1089 if (modifier
== L_('E'))
1092 DO_NUMBER (2, tp
->tm_hour
);
1095 if (modifier
== L_('E'))
1098 DO_NUMBER (2, hour12
);
1100 case L_('k'): /* GNU extension. */
1101 if (modifier
== L_('E'))
1104 DO_NUMBER_SPACEPAD (2, tp
->tm_hour
);
1106 case L_('l'): /* GNU extension. */
1107 if (modifier
== L_('E'))
1110 DO_NUMBER_SPACEPAD (2, hour12
);
1113 if (modifier
== L_('E'))
1116 DO_NUMBER (3, 1 + tp
->tm_yday
);
1119 if (modifier
== L_('E'))
1122 DO_NUMBER (2, tp
->tm_min
);
1125 if (modifier
== L_('E'))
1128 DO_NUMBER (2, tp
->tm_mon
+ 1);
1131 case L_('N'): /* GNU extension. */
1132 if (modifier
== L_('E'))
1138 /* Take an explicit width less than 9 as a precision. */
1140 for (j
= width
; j
< 9; j
++)
1144 DO_NUMBER (9, number_value
);
1148 add (1, *p
= L_('\n'));
1153 #if !defined _NL_CURRENT && HAVE_STRFTIME
1154 format_char
= L_('p');
1164 #if defined _NL_CURRENT || !HAVE_STRFTIME
1168 goto underlying_strftime
;
1172 subfmt
= L_("%H:%M");
1177 if (*(subfmt
= (const CHAR_T
*) _NL_CURRENT (LC_TIME
,
1181 subfmt
= L_("%I:%M:%S %p");
1185 if (modifier
== L_('E'))
1188 DO_NUMBER (2, tp
->tm_sec
);
1190 case L_('s'): /* GNU extension. */
1198 /* Generate string value for T using time_t arithmetic;
1199 this works even if sizeof (long) < sizeof (time_t). */
1201 bufp
= buf
+ sizeof (buf
) / sizeof (buf
[0]);
1202 negative_number
= t
< 0;
1209 if (negative_number
)
1213 /* Adjust if division truncates to minus infinity. */
1214 if (0 < -1 % 10 && d
< 0)
1221 *--bufp
= d
+ L_('0');
1226 goto do_number_sign_and_padding
;
1230 if (modifier
== L_('O'))
1233 if (! (modifier
== L_('E')
1235 (const CHAR_T
*) _NL_CURRENT (LC_TIME
, NLW(ERA_T_FMT
)))
1237 subfmt
= (const CHAR_T
*) _NL_CURRENT (LC_TIME
, NLW(T_FMT
));
1241 goto underlying_strftime
;
1247 subfmt
= L_("%H:%M:%S");
1251 add (1, *p
= L_('\t'));
1255 DO_NUMBER (1, (tp
->tm_wday
- 1 + 7) % 7 + 1);
1258 if (modifier
== L_('E'))
1261 DO_NUMBER (2, (tp
->tm_yday
- tp
->tm_wday
+ 7) / 7);
1266 if (modifier
== L_('E'))
1269 int year
= tp
->tm_year
+ TM_YEAR_BASE
;
1270 int days
= iso_week_days (tp
->tm_yday
, tp
->tm_wday
);
1274 /* This ISO week belongs to the previous year. */
1276 days
= iso_week_days (tp
->tm_yday
+ (365 + __isleap (year
)),
1281 int d
= iso_week_days (tp
->tm_yday
- (365 + __isleap (year
)),
1285 /* This ISO week belongs to the next year. */
1294 DO_NUMBER (2, (year
% 100 + 100) % 100);
1297 DO_NUMBER (1, year
);
1300 DO_NUMBER (2, days
/ 7 + 1);
1305 if (modifier
== L_('E'))
1308 DO_NUMBER (2, (tp
->tm_yday
- (tp
->tm_wday
- 1 + 7) % 7 + 7) / 7);
1311 if (modifier
== L_('E'))
1314 DO_NUMBER (1, tp
->tm_wday
);
1317 if (modifier
== 'E')
1319 #if HAVE_STRUCT_ERA_ENTRY
1320 struct era_entry
*era
= _nl_get_era_entry (tp HELPER_LOCALE_ARG
);
1323 # ifdef COMPILE_WIDE
1324 subfmt
= era
->era_wformat
;
1326 subfmt
= era
->era_format
;
1332 goto underlying_strftime
;
1336 if (modifier
== L_('O'))
1339 DO_NUMBER (1, tp
->tm_year
+ TM_YEAR_BASE
);
1342 if (modifier
== L_('E'))
1344 #if HAVE_STRUCT_ERA_ENTRY
1345 struct era_entry
*era
= _nl_get_era_entry (tp HELPER_LOCALE_ARG
);
1348 int delta
= tp
->tm_year
- era
->start_date
[0];
1349 DO_NUMBER (1, (era
->offset
1350 + delta
* era
->absolute_direction
));
1354 goto underlying_strftime
;
1358 DO_NUMBER (2, (tp
->tm_year
% 100 + 100) % 100);
1368 /* The tzset() call might have changed the value. */
1369 if (!(zone
&& *zone
) && tp
->tm_isdst
>= 0)
1370 zone
= tzname
[tp
->tm_isdst
];
1377 /* The zone string is always given in multibyte form. We have
1378 to transform it first. */
1381 widen (zone
, wczone
, len
);
1385 cpy (strlen (zone
), zone
);
1390 if (tp
->tm_isdst
< 0)
1396 diff
= tp
->tm_gmtoff
;
1409 if (lt
== (time_t) -1)
1411 /* mktime returns -1 for errors, but -1 is also a
1412 valid time_t value. Check whether an error really
1416 if (! my_strftime_localtime_r (<
, &tm
)
1417 || ((ltm
.tm_sec
^ tm
.tm_sec
)
1418 | (ltm
.tm_min
^ tm
.tm_min
)
1419 | (ltm
.tm_hour
^ tm
.tm_hour
)
1420 | (ltm
.tm_mday
^ tm
.tm_mday
)
1421 | (ltm
.tm_mon
^ tm
.tm_mon
)
1422 | (ltm
.tm_year
^ tm
.tm_year
)))
1426 if (! my_strftime_gmtime_r (<
, >m
))
1429 diff
= tm_diff (<m
, >m
);
1435 add (1, *p
= L_('-'));
1439 add (1, *p
= L_('+'));
1442 DO_NUMBER (4, (diff
/ 60) * 100 + diff
% 60);
1445 case L_('\0'): /* GNU extension: % at end of format. */
1449 /* Unknown format; output the format, including the '%',
1450 since this is most likely the right thing to do if a
1451 multibyte string has been misparsed. */
1455 for (flen
= 1; f
[1 - flen
] != L_('%'); flen
++)
1457 cpy (flen
, &f
[1 - flen
]);
1463 if (p
&& maxsize
!= 0)
1468 libc_hidden_def (my_strftime
)
1474 /* For Emacs we have a separate interface which corresponds to the normal
1475 strftime function plus the ut argument, but without the ns argument. */
1477 emacs_strftimeu (s
, maxsize
, format
, tp
, ut
)
1481 const struct tm
*tp
;
1484 return my_strftime (s
, maxsize
, format
, tp
, ut
, 0);
1488 /* arch-tag: 662bc9c4-f8e2-41b6-bf96-b8346d0ce0d8
1489 (do not change this comment) */