Update.
[glibc.git] / time / strftime.c
blob306c9331d30022f0ae5c92a1774f993892ce30df
1 /* Copyright (C) 1991-1999, 2000, 2001 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public License as
6 published by the Free Software Foundation; either version 2 of the
7 License, or (at your option) any later version.
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Library General Public License for more details.
14 You should have received a copy of the GNU Library General Public
15 License along with the GNU C Library; see the file COPYING.LIB. If not,
16 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 Boston, MA 02111-1307, USA. */
19 #ifdef HAVE_CONFIG_H
20 # include <config.h>
21 #endif
23 #ifdef _LIBC
24 # define HAVE_LIMITS_H 1
25 # define HAVE_MBLEN 1
26 # define HAVE_MBRLEN 1
27 # define HAVE_STRUCT_ERA_ENTRY 1
28 # define HAVE_TM_GMTOFF 1
29 # define HAVE_TM_ZONE 1
30 # define HAVE_TZNAME 1
31 # define HAVE_TZSET 1
32 # define MULTIBYTE_IS_FORMAT_SAFE 1
33 # define STDC_HEADERS 1
34 # include "../locale/localeinfo.h"
35 #endif
37 #if defined emacs && !defined HAVE_BCOPY
38 # define HAVE_MEMCPY 1
39 #endif
41 #include <ctype.h>
42 #include <sys/types.h> /* Some systems define `time_t' here. */
44 #ifdef TIME_WITH_SYS_TIME
45 # include <sys/time.h>
46 # include <time.h>
47 #else
48 # ifdef HAVE_SYS_TIME_H
49 # include <sys/time.h>
50 # else
51 # include <time.h>
52 # endif
53 #endif
54 #if HAVE_TZNAME
55 extern char *tzname[];
56 #endif
58 /* Do multibyte processing if multibytes are supported, unless
59 multibyte sequences are safe in formats. Multibyte sequences are
60 safe if they cannot contain byte sequences that look like format
61 conversion specifications. The GNU C Library uses UTF8 multibyte
62 encoding, which is safe for formats, but strftime.c can be used
63 with other C libraries that use unsafe encodings. */
64 #define DO_MULTIBYTE (HAVE_MBLEN && ! MULTIBYTE_IS_FORMAT_SAFE)
66 #if DO_MULTIBYTE
67 # if HAVE_MBRLEN
68 # include <wchar.h>
69 # else
70 /* Simulate mbrlen with mblen as best we can. */
71 # define mbstate_t int
72 # define mbrlen(s, n, ps) mblen (s, n)
73 # define mbsinit(ps) (*(ps) == 0)
74 # endif
75 static const mbstate_t mbstate_zero;
76 #endif
78 #if HAVE_LIMITS_H
79 # include <limits.h>
80 #endif
82 #if STDC_HEADERS
83 # include <stddef.h>
84 # include <stdlib.h>
85 # include <string.h>
86 #else
87 # ifndef HAVE_MEMCPY
88 # define memcpy(d, s, n) bcopy ((s), (d), (n))
89 # endif
90 #endif
92 #ifdef COMPILE_WIDE
93 # include <endian.h>
94 # define CHAR_T wchar_t
95 # define UCHAR_T unsigned int
96 # define L_(Str) L##Str
97 # define NLW(Sym) _NL_W##Sym
99 # define MEMCPY(d, s, n) __wmemcpy (d, s, n)
100 # define STRLEN(s) __wcslen (s)
102 #else
103 # define CHAR_T char
104 # define UCHAR_T unsigned char
105 # define L_(Str) Str
106 # define NLW(Sym) Sym
108 # if !defined STDC_HEADERS && !defined HAVE_MEMCPY
109 # define MEMCPY(d, s, n) bcopy ((s), (d), (n))
110 # else
111 # define MEMCPY(d, s, n) memcpy ((d), (s), (n))
112 # endif
113 # define STRLEN(s) strlen (s)
115 # ifdef _LIBC
116 # define MEMPCPY(d, s, n) __mempcpy (d, s, n)
117 # else
118 # ifndef HAVE_MEMPCPY
119 # define MEMPCPY(d, s, n) ((void *) ((char *) memcpy (d, s, n) + (n)))
120 # endif
121 # endif
122 #endif
124 #ifndef __P
125 # if defined __GNUC__ || (defined __STDC__ && __STDC__)
126 # define __P(args) args
127 # else
128 # define __P(args) ()
129 # endif /* GCC. */
130 #endif /* Not __P. */
132 #ifndef PTR
133 # ifdef __STDC__
134 # define PTR void *
135 # else
136 # define PTR char *
137 # endif
138 #endif
140 #ifndef CHAR_BIT
141 # define CHAR_BIT 8
142 #endif
144 #ifndef NULL
145 # define NULL 0
146 #endif
148 #define TYPE_SIGNED(t) ((t) -1 < 0)
150 /* Bound on length of the string representing an integer value of type t.
151 Subtract one for the sign bit if t is signed;
152 302 / 1000 is log10 (2) rounded up;
153 add one for integer division truncation;
154 add one more for a minus sign if t is signed. */
155 #define INT_STRLEN_BOUND(t) \
156 ((sizeof (t) * CHAR_BIT - TYPE_SIGNED (t)) * 302 / 1000 + 1 + TYPE_SIGNED (t))
158 #define TM_YEAR_BASE 1900
160 #ifndef __isleap
161 /* Nonzero if YEAR is a leap year (every 4 years,
162 except every 100th isn't, and every 400th is). */
163 # define __isleap(year) \
164 ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
165 #endif
168 #ifdef _LIBC
169 # define my_strftime_gmtime_r __gmtime_r
170 # define my_strftime_localtime_r __localtime_r
171 # define tzname __tzname
172 # define tzset __tzset
173 #else
175 /* If we're a strftime substitute in a GNU program, then prefer gmtime
176 to gmtime_r, since many gmtime_r implementations are buggy.
177 Similarly for localtime_r. */
179 # if ! HAVE_TM_GMTOFF
180 static struct tm *my_strftime_gmtime_r __P ((const time_t *, struct tm *));
181 static struct tm *
182 my_strftime_gmtime_r (t, tp)
183 const time_t *t;
184 struct tm *tp;
186 struct tm *l = gmtime (t);
187 if (! l)
188 return 0;
189 *tp = *l;
190 return tp;
192 # endif /* ! HAVE_TM_GMTOFF */
194 static struct tm *my_strftime_localtime_r __P ((const time_t *, struct tm *));
195 static struct tm *
196 my_strftime_localtime_r (t, tp)
197 const time_t *t;
198 struct tm *tp;
200 struct tm *l = localtime (t);
201 if (! l)
202 return 0;
203 *tp = *l;
204 return tp;
206 #endif /* ! defined _LIBC */
209 #if !defined memset && !defined HAVE_MEMSET && !defined _LIBC
210 /* Some systems lack the `memset' function and we don't want to
211 introduce additional dependencies. */
212 /* The SGI compiler reportedly barfs on the trailing null
213 if we use a string constant as the initializer. 28 June 1997, rms. */
214 static const CHAR_T spaces[16] = /* " " */
216 L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),
217 L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' ')
219 static const CHAR_T zeroes[16] = /* "0000000000000000" */
221 L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),
222 L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0')
225 # define memset_space(P, Len) \
226 do { \
227 int _len = (Len); \
229 do \
231 int _this = _len > 16 ? 16 : _len; \
232 (P) = MEMPCPY ((P), spaces, _this * sizeof (CHAR_T)); \
233 _len -= _this; \
235 while (_len > 0); \
236 } while (0)
238 # define memset_zero(P, Len) \
239 do { \
240 int _len = (Len); \
242 do \
244 int _this = _len > 16 ? 16 : _len; \
245 (P) = MEMPCPY ((P), zeroes, _this * sizeof (CHAR_T)); \
246 _len -= _this; \
248 while (_len > 0); \
249 } while (0)
250 #else
251 # ifdef COMPILE_WIDE
252 # define memset_space(P, Len) (wmemset ((P), L' ', (Len)), (P) += (Len))
253 # define memset_zero(P, Len) (wmemset ((P), L'0', (Len)), (P) += (Len))
254 # else
255 # define memset_space(P, Len) (memset ((P), ' ', (Len)), (P) += (Len))
256 # define memset_zero(P, Len) (memset ((P), '0', (Len)), (P) += (Len))
257 # endif
258 #endif
260 #define add(n, f) \
261 do \
263 int _n = (n); \
264 int _delta = width - _n; \
265 int _incr = _n + (_delta > 0 ? _delta : 0); \
266 if (i + _incr >= maxsize) \
267 return 0; \
268 if (p) \
270 if (_delta > 0) \
272 if (pad == L_('0')) \
273 memset_zero (p, _delta); \
274 else \
275 memset_space (p, _delta); \
277 f; \
278 p += _n; \
280 i += _incr; \
281 } while (0)
283 #define cpy(n, s) \
284 add ((n), \
285 if (to_lowcase) \
286 memcpy_lowcase (p, (s), _n); \
287 else if (to_uppcase) \
288 memcpy_uppcase (p, (s), _n); \
289 else \
290 MEMCPY ((PTR) p, (const PTR) (s), _n))
292 #ifdef COMPILE_WIDE
293 # define widen(os, ws, l) \
295 mbstate_t __st; \
296 const char *__s = os; \
297 memset (&__st, '\0', sizeof (__st)); \
298 l = __mbsrtowcs (NULL, &__s, 0, &__st); \
299 ws = alloca ((l + 1) * sizeof (wchar_t)); \
300 (void) __mbsrtowcs (ws, &__s, l, &__st); \
302 #endif
305 #ifdef COMPILE_WIDE
306 # define TOUPPER(Ch) towupper (Ch)
307 # define TOLOWER(Ch) towlower (Ch)
308 #else
309 # ifdef _LIBC
310 # define TOUPPER(Ch) toupper (Ch)
311 # define TOLOWER(Ch) tolower (Ch)
312 # else
313 # define TOUPPER(Ch) (islower (Ch) ? toupper (Ch) : (Ch))
314 # define TOLOWER(Ch) (isupper (Ch) ? tolower (Ch) : (Ch))
315 # endif
316 #endif
317 /* We don't use `isdigit' here since the locale dependent
318 interpretation is not what we want here. We only need to accept
319 the arabic digits in the ASCII range. One day there is perhaps a
320 more reliable way to accept other sets of digits. */
321 #define ISDIGIT(Ch) ((unsigned int) (Ch) - L_('0') <= 9)
323 static CHAR_T *memcpy_lowcase __P ((CHAR_T *dest, const CHAR_T *src,
324 size_t len));
326 static CHAR_T *
327 memcpy_lowcase (dest, src, len)
328 CHAR_T *dest;
329 const CHAR_T *src;
330 size_t len;
332 while (len-- > 0)
333 dest[len] = TOLOWER ((UCHAR_T) src[len]);
334 return dest;
337 static CHAR_T *memcpy_uppcase __P ((CHAR_T *dest, const CHAR_T *src,
338 size_t len));
340 static CHAR_T *
341 memcpy_uppcase (dest, src, len)
342 CHAR_T *dest;
343 const CHAR_T *src;
344 size_t len;
346 while (len-- > 0)
347 dest[len] = TOUPPER ((UCHAR_T) src[len]);
348 return dest;
352 #if ! HAVE_TM_GMTOFF
353 /* Yield the difference between *A and *B,
354 measured in seconds, ignoring leap seconds. */
355 # define tm_diff ftime_tm_diff
356 static int tm_diff __P ((const struct tm *, const struct tm *));
357 static int
358 tm_diff (a, b)
359 const struct tm *a;
360 const struct tm *b;
362 /* Compute intervening leap days correctly even if year is negative.
363 Take care to avoid int overflow in leap day calculations,
364 but it's OK to assume that A and B are close to each other. */
365 int a4 = (a->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (a->tm_year & 3);
366 int b4 = (b->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (b->tm_year & 3);
367 int a100 = a4 / 25 - (a4 % 25 < 0);
368 int b100 = b4 / 25 - (b4 % 25 < 0);
369 int a400 = a100 >> 2;
370 int b400 = b100 >> 2;
371 int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
372 int years = a->tm_year - b->tm_year;
373 int days = (365 * years + intervening_leap_days
374 + (a->tm_yday - b->tm_yday));
375 return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
376 + (a->tm_min - b->tm_min))
377 + (a->tm_sec - b->tm_sec));
379 #endif /* ! HAVE_TM_GMTOFF */
383 /* The number of days from the first day of the first ISO week of this
384 year to the year day YDAY with week day WDAY. ISO weeks start on
385 Monday; the first ISO week has the year's first Thursday. YDAY may
386 be as small as YDAY_MINIMUM. */
387 #define ISO_WEEK_START_WDAY 1 /* Monday */
388 #define ISO_WEEK1_WDAY 4 /* Thursday */
389 #define YDAY_MINIMUM (-366)
390 static int iso_week_days __P ((int, int));
391 #ifdef __GNUC__
392 __inline__
393 #endif
394 static int
395 iso_week_days (yday, wday)
396 int yday;
397 int wday;
399 /* Add enough to the first operand of % to make it nonnegative. */
400 int big_enough_multiple_of_7 = (-YDAY_MINIMUM / 7 + 2) * 7;
401 return (yday
402 - (yday - wday + ISO_WEEK1_WDAY + big_enough_multiple_of_7) % 7
403 + ISO_WEEK1_WDAY - ISO_WEEK_START_WDAY);
407 #if !(defined _NL_CURRENT || HAVE_STRFTIME)
408 static CHAR_T const weekday_name[][10] =
410 L_("Sunday"), L_("Monday"), L_("Tuesday"), L_("Wednesday"),
411 L_("Thursday"), L_("Friday"), L_("Saturday")
413 static CHAR_T const month_name[][10] =
415 L_("January"), L_("February"), L_("March"), L_("April"), L_("May"),
416 L_("June"), L_("July"), L_("August"), L_("September"), L_("October"),
417 L_("November"), L_("December")
419 #endif
422 #ifdef emacs
423 # define my_strftime emacs_strftimeu
424 # define ut_argument , ut
425 # define ut_argument_spec int ut;
426 # define ut_argument_spec_iso , int ut
427 #else
428 # ifdef COMPILE_WIDE
429 # define my_strftime wcsftime
430 # else
431 # define my_strftime strftime
432 # endif
433 # define ut_argument
434 # define ut_argument_spec
435 # define ut_argument_spec_iso
436 /* We don't have this information in general. */
437 # define ut 0
438 #endif
440 #if !defined _LIBC && HAVE_TZNAME && HAVE_TZSET
441 /* Solaris 2.5 tzset sometimes modifies the storage returned by localtime.
442 Work around this bug by copying *tp before it might be munged. */
443 size_t _strftime_copytm __P ((char *, size_t, const char *,
444 const struct tm * ut_argument_spec_iso));
445 size_t
446 my_strftime (s, maxsize, format, tp ut_argument)
447 CHAR_T *s;
448 size_t maxsize;
449 const CHAR_T *format;
450 const struct tm *tp;
451 ut_argument_spec
453 struct tm tmcopy;
454 tmcopy = *tp;
455 return _strftime_copytm (s, maxsize, format, &tmcopy ut_argument);
457 # undef my_strftime
458 # define my_strftime _strftime_copytm
459 #endif
462 /* Write information from TP into S according to the format
463 string FORMAT, writing no more that MAXSIZE characters
464 (including the terminating '\0') and returning number of
465 characters written. If S is NULL, nothing will be written
466 anywhere, so to determine how many characters would be
467 written, use NULL for S and (size_t) UINT_MAX for MAXSIZE. */
468 size_t
469 my_strftime (s, maxsize, format, tp ut_argument)
470 CHAR_T *s;
471 size_t maxsize;
472 const CHAR_T *format;
473 const struct tm *tp;
474 ut_argument_spec
476 int hour12 = tp->tm_hour;
477 #ifdef _NL_CURRENT
478 /* We cannot make the following values variables since we must delay
479 the evaluation of these values until really needed since some
480 expressions might not be valid in every situation. The `struct tm'
481 might be generated by a strptime() call that initialized
482 only a few elements. Dereference the pointers only if the format
483 requires this. Then it is ok to fail if the pointers are invalid. */
484 # define a_wkday \
485 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABDAY_1) + tp->tm_wday))
486 # define f_wkday \
487 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(DAY_1) + tp->tm_wday))
488 # define a_month \
489 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABMON_1) + tp->tm_mon))
490 # define f_month \
491 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(MON_1) + tp->tm_mon))
492 # define ampm \
493 ((const CHAR_T *) _NL_CURRENT (LC_TIME, tp->tm_hour > 11 \
494 ? NLW(PM_STR) : NLW(AM_STR)))
496 # define aw_len STRLEN (a_wkday)
497 # define am_len STRLEN (a_month)
498 # define ap_len STRLEN (ampm)
499 #else
500 # if !HAVE_STRFTIME
501 # define f_wkday (weekday_name[tp->tm_wday])
502 # define f_month (month_name[tp->tm_mon])
503 # define a_wkday f_wkday
504 # define a_month f_month
505 # define ampm (L_("AMPM") + 2 * (tp->tm_hour > 11))
507 size_t aw_len = 3;
508 size_t am_len = 3;
509 size_t ap_len = 2;
510 # endif
511 #endif
512 const char *zone;
513 size_t i = 0;
514 CHAR_T *p = s;
515 const CHAR_T *f;
516 #if DO_MULTIBYTE && !defined COMPILE_WIDE
517 const char *format_end = NULL;
518 #endif
520 zone = NULL;
521 #if HAVE_TM_ZONE
522 /* The POSIX test suite assumes that setting
523 the environment variable TZ to a new value before calling strftime()
524 will influence the result (the %Z format) even if the information in
525 TP is computed with a totally different time zone.
526 This is bogus: though POSIX allows bad behavior like this,
527 POSIX does not require it. Do the right thing instead. */
528 zone = (const char *) tp->tm_zone;
529 #endif
530 #if HAVE_TZNAME
531 if (ut)
533 if (! (zone && *zone))
534 zone = "GMT";
536 else
538 /* POSIX.1 8.1.1 requires that whenever strftime() is called, the
539 time zone names contained in the external variable `tzname' shall
540 be set as if the tzset() function had been called. */
541 # if HAVE_TZSET
542 tzset ();
543 # endif
545 #endif
547 if (hour12 > 12)
548 hour12 -= 12;
549 else
550 if (hour12 == 0)
551 hour12 = 12;
553 for (f = format; *f != '\0'; ++f)
555 int pad = 0; /* Padding for number ('-', '_', or 0). */
556 int modifier; /* Field modifier ('E', 'O', or 0). */
557 int digits; /* Max digits for numeric format. */
558 int number_value; /* Numeric value to be printed. */
559 int negative_number; /* 1 if the number is negative. */
560 const CHAR_T *subfmt;
561 CHAR_T *bufp;
562 CHAR_T buf[1 + (sizeof (int) < sizeof (time_t)
563 ? INT_STRLEN_BOUND (time_t)
564 : INT_STRLEN_BOUND (int))];
565 int width = -1;
566 int to_lowcase = 0;
567 int to_uppcase = 0;
568 int change_case = 0;
569 int format_char;
571 #if DO_MULTIBYTE && !defined COMPILE_WIDE
572 switch (*f)
574 case L_('%'):
575 break;
577 case L_('\b'): case L_('\t'): case L_('\n'):
578 case L_('\v'): case L_('\f'): case L_('\r'):
579 case L_(' '): case L_('!'): case L_('"'): case L_('#'): case L_('&'):
580 case L_('\''): case L_('('): case L_(')'): case L_('*'): case L_('+'):
581 case L_(','): case L_('-'): case L_('.'): case L_('/'): case L_('0'):
582 case L_('1'): case L_('2'): case L_('3'): case L_('4'): case L_('5'):
583 case L_('6'): case L_('7'): case L_('8'): case L_('9'): case L_(':'):
584 case L_(';'): case L_('<'): case L_('='): case L_('>'): case L_('?'):
585 case L_('A'): case L_('B'): case L_('C'): case L_('D'): case L_('E'):
586 case L_('F'): case L_('G'): case L_('H'): case L_('I'): case L_('J'):
587 case L_('K'): case L_('L'): case L_('M'): case L_('N'): case L_('O'):
588 case L_('P'): case L_('Q'): case L_('R'): case L_('S'): case L_('T'):
589 case L_('U'): case L_('V'): case L_('W'): case L_('X'): case L_('Y'):
590 case L_('Z'): case L_('['): case L_('\\'): case L_(']'): case L_('^'):
591 case L_('_'): case L_('a'): case L_('b'): case L_('c'): case L_('d'):
592 case L_('e'): case L_('f'): case L_('g'): case L_('h'): case L_('i'):
593 case L_('j'): case L_('k'): case L_('l'): case L_('m'): case L_('n'):
594 case L_('o'): case L_('p'): case L_('q'): case L_('r'): case L_('s'):
595 case L_('t'): case L_('u'): case L_('v'): case L_('w'): case L_('x'):
596 case L_('y'): case L_('z'): case L_('{'): case L_('|'): case L_('}'):
597 case L_('~'):
598 /* The C Standard requires these 98 characters (plus '%') to
599 be in the basic execution character set. None of these
600 characters can start a multibyte sequence, so they need
601 not be analyzed further. */
602 add (1, *p = *f);
603 continue;
605 default:
606 /* Copy this multibyte sequence until we reach its end, find
607 an error, or come back to the initial shift state. */
609 mbstate_t mbstate = mbstate_zero;
610 size_t len = 0;
611 size_t fsize;
613 if (! format_end)
614 format_end = f + strlen (f) + 1;
615 fsize = format_end - f;
619 size_t bytes = mbrlen (f + len, fsize - len, &mbstate);
621 if (bytes == 0)
622 break;
624 if (bytes == (size_t) -2)
626 len += strlen (f + len);
627 break;
630 if (bytes == (size_t) -1)
632 len++;
633 break;
636 len += bytes;
638 while (! mbsinit (&mbstate));
640 cpy (len, f);
641 f += len - 1;
642 continue;
646 #else /* ! DO_MULTIBYTE */
648 /* Either multibyte encodings are not supported, they are
649 safe for formats, so any non-'%' byte can be copied through,
650 or this is the wide character version. */
651 if (*f != L_('%'))
653 add (1, *p = *f);
654 continue;
657 #endif /* ! DO_MULTIBYTE */
659 /* Check for flags that can modify a format. */
660 while (1)
662 switch (*++f)
664 /* This influences the number formats. */
665 case L_('_'):
666 case L_('-'):
667 case L_('0'):
668 pad = *f;
669 continue;
671 /* This changes textual output. */
672 case L_('^'):
673 to_uppcase = 1;
674 continue;
675 case L_('#'):
676 change_case = 1;
677 continue;
679 default:
680 break;
682 break;
685 /* As a GNU extension we allow to specify the field width. */
686 if (ISDIGIT (*f))
688 width = 0;
691 width *= 10;
692 width += *f - L_('0');
693 ++f;
695 while (ISDIGIT (*f));
698 /* Check for modifiers. */
699 switch (*f)
701 case L_('E'):
702 case L_('O'):
703 modifier = *f++;
704 break;
706 default:
707 modifier = 0;
708 break;
711 /* Now do the specified format. */
712 format_char = *f;
713 switch (format_char)
715 #define DO_NUMBER(d, v) \
716 digits = width == -1 ? d : width; \
717 number_value = v; goto do_number
718 #define DO_NUMBER_SPACEPAD(d, v) \
719 digits = width == -1 ? d : width; \
720 number_value = v; goto do_number_spacepad
722 case L_('%'):
723 if (modifier != 0)
724 goto bad_format;
725 add (1, *p = *f);
726 break;
728 case L_('a'):
729 if (modifier != 0)
730 goto bad_format;
731 if (change_case)
733 to_uppcase = 1;
734 to_lowcase = 0;
736 #if defined _NL_CURRENT || !HAVE_STRFTIME
737 cpy (aw_len, a_wkday);
738 break;
739 #else
740 goto underlying_strftime;
741 #endif
743 case 'A':
744 if (modifier != 0)
745 goto bad_format;
746 if (change_case)
748 to_uppcase = 1;
749 to_lowcase = 0;
751 #if defined _NL_CURRENT || !HAVE_STRFTIME
752 cpy (STRLEN (f_wkday), f_wkday);
753 break;
754 #else
755 goto underlying_strftime;
756 #endif
758 case L_('b'):
759 case L_('h'): /* POSIX.2 extension. */
760 if (change_case)
762 to_uppcase = 1;
763 to_lowcase = 0;
765 if (modifier != 0)
766 goto bad_format;
767 #if defined _NL_CURRENT || !HAVE_STRFTIME
768 cpy (am_len, a_month);
769 break;
770 #else
771 goto underlying_strftime;
772 #endif
774 case L_('B'):
775 if (modifier != 0)
776 goto bad_format;
777 if (change_case)
779 to_uppcase = 1;
780 to_lowcase = 0;
782 #if defined _NL_CURRENT || !HAVE_STRFTIME
783 cpy (STRLEN (f_month), f_month);
784 break;
785 #else
786 goto underlying_strftime;
787 #endif
789 case L_('c'):
790 if (modifier == L_('O'))
791 goto bad_format;
792 #ifdef _NL_CURRENT
793 if (! (modifier == 'E'
794 && (*(subfmt =
795 (const CHAR_T *) _NL_CURRENT (LC_TIME,
796 NLW(ERA_D_T_FMT)))
797 != '\0')))
798 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_T_FMT));
799 #else
800 # if HAVE_STRFTIME
801 goto underlying_strftime;
802 # else
803 subfmt = L_("%a %b %e %H:%M:%S %Y");
804 # endif
805 #endif
807 subformat:
809 CHAR_T *old_start = p;
810 size_t len = my_strftime (NULL, (size_t) -1, subfmt,
811 tp ut_argument);
812 add (len, my_strftime (p, maxsize - i, subfmt,
813 tp ut_argument));
815 if (to_uppcase)
816 while (old_start < p)
818 *old_start = TOUPPER ((UCHAR_T) *old_start);
819 ++old_start;
822 break;
824 #if HAVE_STRFTIME && ! (defined _NL_CURRENT && HAVE_STRUCT_ERA_ENTRY)
825 underlying_strftime:
827 /* The relevant information is available only via the
828 underlying strftime implementation, so use that. */
829 char ufmt[4];
830 char *u = ufmt;
831 char ubuf[1024]; /* enough for any single format in practice */
832 size_t len;
833 /* Make sure we're calling the actual underlying strftime.
834 In some cases, config.h contains something like
835 "#define strftime rpl_strftime". */
836 # ifdef strftime
837 # undef strftime
838 size_t strftime ();
839 # endif
841 *u++ = '%';
842 if (modifier != 0)
843 *u++ = modifier;
844 *u++ = format_char;
845 *u = '\0';
846 len = strftime (ubuf, sizeof ubuf, ufmt, tp);
847 if (len == 0 && ubuf[0] != '\0')
848 return 0;
849 cpy (len, ubuf);
851 break;
852 #endif
854 case L_('C'): /* POSIX.2 extension. */
855 if (modifier == L_('O'))
856 goto bad_format;
857 if (modifier == L_('E'))
859 #if HAVE_STRUCT_ERA_ENTRY
860 struct era_entry *era = _nl_get_era_entry (tp);
861 if (era)
863 # ifdef COMPILE_WIDE
864 size_t len = __wcslen (era->era_wname);
865 cpy (len, era->era_wname);
866 # else
867 size_t len = strlen (era->era_name);
868 cpy (len, era->era_name);
869 # endif
870 break;
872 #else
873 # if HAVE_STRFTIME
874 goto underlying_strftime;
875 # endif
876 #endif
880 int year = tp->tm_year + TM_YEAR_BASE;
881 DO_NUMBER (1, year / 100 - (year % 100 < 0));
884 case L_('x'):
885 if (modifier == L_('O'))
886 goto bad_format;
887 #ifdef _NL_CURRENT
888 if (! (modifier == L_('E')
889 && (*(subfmt =
890 (const CHAR_T *)_NL_CURRENT (LC_TIME, NLW(ERA_D_FMT)))
891 != L_('\0'))))
892 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_FMT));
893 goto subformat;
894 #else
895 # if HAVE_STRFTIME
896 goto underlying_strftime;
897 # else
898 /* Fall through. */
899 # endif
900 #endif
901 case L_('D'): /* POSIX.2 extension. */
902 if (modifier != 0)
903 goto bad_format;
904 subfmt = L_("%m/%d/%y");
905 goto subformat;
907 case L_('d'):
908 if (modifier == L_('E'))
909 goto bad_format;
911 DO_NUMBER (2, tp->tm_mday);
913 case L_('e'): /* POSIX.2 extension. */
914 if (modifier == L_('E'))
915 goto bad_format;
917 DO_NUMBER_SPACEPAD (2, tp->tm_mday);
919 /* All numeric formats set DIGITS and NUMBER_VALUE and then
920 jump to one of these two labels. */
922 do_number_spacepad:
923 /* Force `_' flag unless overwritten by `0' flag. */
924 if (pad != L_('0'))
925 pad = L_('_');
927 do_number:
928 /* Format the number according to the MODIFIER flag. */
930 if (modifier == L_('O') && 0 <= number_value)
932 #ifdef _NL_CURRENT
933 /* Get the locale specific alternate representation of
934 the number NUMBER_VALUE. If none exist NULL is returned. */
935 # ifdef COMPILE_WIDE
936 const wchar_t *cp = _nl_get_walt_digit (number_value);
937 # else
938 const char *cp = _nl_get_alt_digit (number_value);
939 # endif
941 if (cp != NULL)
943 size_t digitlen = STRLEN (cp);
944 if (digitlen != 0)
946 cpy (digitlen, cp);
947 break;
950 #else
951 # if HAVE_STRFTIME
952 goto underlying_strftime;
953 # endif
954 #endif
957 unsigned int u = number_value;
959 bufp = buf + sizeof (buf) / sizeof (buf[0]);
960 negative_number = number_value < 0;
962 if (negative_number)
963 u = -u;
966 *--bufp = u % 10 + L_('0');
967 while ((u /= 10) != 0);
970 do_number_sign_and_padding:
971 if (negative_number)
972 *--bufp = L_('-');
974 if (pad != L_('-'))
976 int padding = digits - (buf + (sizeof (buf) / sizeof (buf[0]))
977 - bufp);
979 if (pad == L_('_'))
981 while (0 < padding--)
982 *--bufp = L_(' ');
984 else
986 bufp += negative_number;
987 while (0 < padding--)
988 *--bufp = L_('0');
989 if (negative_number)
990 *--bufp = L_('-');
994 cpy (buf + sizeof (buf) / sizeof (buf[0]) - bufp, bufp);
995 break;
997 case L_('F'):
998 if (modifier != 0)
999 goto bad_format;
1000 subfmt = L_("%Y-%m-%d");
1001 goto subformat;
1003 case L_('H'):
1004 if (modifier == L_('E'))
1005 goto bad_format;
1007 DO_NUMBER (2, tp->tm_hour);
1009 case L_('I'):
1010 if (modifier == L_('E'))
1011 goto bad_format;
1013 DO_NUMBER (2, hour12);
1015 case L_('k'): /* GNU extension. */
1016 if (modifier == L_('E'))
1017 goto bad_format;
1019 DO_NUMBER_SPACEPAD (2, tp->tm_hour);
1021 case L_('l'): /* GNU extension. */
1022 if (modifier == L_('E'))
1023 goto bad_format;
1025 DO_NUMBER_SPACEPAD (2, hour12);
1027 case L_('j'):
1028 if (modifier == L_('E'))
1029 goto bad_format;
1031 DO_NUMBER (3, 1 + tp->tm_yday);
1033 case L_('M'):
1034 if (modifier == L_('E'))
1035 goto bad_format;
1037 DO_NUMBER (2, tp->tm_min);
1039 case L_('m'):
1040 if (modifier == L_('E'))
1041 goto bad_format;
1043 DO_NUMBER (2, tp->tm_mon + 1);
1045 case L_('n'): /* POSIX.2 extension. */
1046 add (1, *p = L_('\n'));
1047 break;
1049 case L_('P'):
1050 to_lowcase = 1;
1051 #if !defined _NL_CURRENT && HAVE_STRFTIME
1052 format_char = L_('p');
1053 #endif
1054 /* FALLTHROUGH */
1056 case L_('p'):
1057 if (change_case)
1059 to_uppcase = 0;
1060 to_lowcase = 1;
1062 #if defined _NL_CURRENT || !HAVE_STRFTIME
1063 cpy (ap_len, ampm);
1064 break;
1065 #else
1066 goto underlying_strftime;
1067 #endif
1069 case L_('R'): /* ISO C99 extension. */
1070 subfmt = L_("%H:%M");
1071 goto subformat;
1073 case L_('r'): /* POSIX.2 extension. */
1074 #ifdef _NL_CURRENT
1075 if (*(subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME,
1076 NLW(T_FMT_AMPM)))
1077 == L_('\0'))
1078 #endif
1079 subfmt = L_("%I:%M:%S %p");
1080 goto subformat;
1082 case L_('S'):
1083 if (modifier == L_('E'))
1084 goto bad_format;
1086 DO_NUMBER (2, tp->tm_sec);
1088 case L_('s'): /* GNU extension. */
1090 struct tm ltm;
1091 time_t t;
1093 ltm = *tp;
1094 t = mktime (&ltm);
1096 /* Generate string value for T using time_t arithmetic;
1097 this works even if sizeof (long) < sizeof (time_t). */
1099 bufp = buf + sizeof (buf) / sizeof (buf[0]);
1100 negative_number = t < 0;
1104 int d = t % 10;
1105 t /= 10;
1107 if (negative_number)
1109 d = -d;
1111 /* Adjust if division truncates to minus infinity. */
1112 if (0 < -1 % 10 && d < 0)
1114 t++;
1115 d += 10;
1119 *--bufp = d + L_('0');
1121 while (t != 0);
1123 digits = 1;
1124 goto do_number_sign_and_padding;
1127 case L_('X'):
1128 if (modifier == L_('O'))
1129 goto bad_format;
1130 #ifdef _NL_CURRENT
1131 if (! (modifier == L_('E')
1132 && (*(subfmt =
1133 (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ERA_T_FMT)))
1134 != L_('\0'))))
1135 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(T_FMT));
1136 goto subformat;
1137 #else
1138 # if HAVE_STRFTIME
1139 goto underlying_strftime;
1140 # else
1141 /* Fall through. */
1142 # endif
1143 #endif
1144 case L_('T'): /* POSIX.2 extension. */
1145 subfmt = L_("%H:%M:%S");
1146 goto subformat;
1148 case L_('t'): /* POSIX.2 extension. */
1149 add (1, *p = L_('\t'));
1150 break;
1152 case L_('u'): /* POSIX.2 extension. */
1153 DO_NUMBER (1, (tp->tm_wday - 1 + 7) % 7 + 1);
1155 case L_('U'):
1156 if (modifier == L_('E'))
1157 goto bad_format;
1159 DO_NUMBER (2, (tp->tm_yday - tp->tm_wday + 7) / 7);
1161 case L_('V'):
1162 case L_('g'): /* ISO C99 extension. */
1163 case L_('G'): /* ISO C99 extension. */
1164 if (modifier == L_('E'))
1165 goto bad_format;
1167 int year = tp->tm_year + TM_YEAR_BASE;
1168 int days = iso_week_days (tp->tm_yday, tp->tm_wday);
1170 if (days < 0)
1172 /* This ISO week belongs to the previous year. */
1173 year--;
1174 days = iso_week_days (tp->tm_yday + (365 + __isleap (year)),
1175 tp->tm_wday);
1177 else
1179 int d = iso_week_days (tp->tm_yday - (365 + __isleap (year)),
1180 tp->tm_wday);
1181 if (0 <= d)
1183 /* This ISO week belongs to the next year. */
1184 year++;
1185 days = d;
1189 switch (*f)
1191 case L_('g'):
1192 DO_NUMBER (2, (year % 100 + 100) % 100);
1194 case L_('G'):
1195 DO_NUMBER (1, year);
1197 default:
1198 DO_NUMBER (2, days / 7 + 1);
1202 case L_('W'):
1203 if (modifier == L_('E'))
1204 goto bad_format;
1206 DO_NUMBER (2, (tp->tm_yday - (tp->tm_wday - 1 + 7) % 7 + 7) / 7);
1208 case L_('w'):
1209 if (modifier == L_('E'))
1210 goto bad_format;
1212 DO_NUMBER (1, tp->tm_wday);
1214 case L_('Y'):
1215 if (modifier == 'E')
1217 #if HAVE_STRUCT_ERA_ENTRY
1218 struct era_entry *era = _nl_get_era_entry (tp);
1219 if (era)
1221 # ifdef COMPILE_WIDE
1222 subfmt = era->era_wformat;
1223 # else
1224 subfmt = era->era_format;
1225 # endif
1226 goto subformat;
1228 #else
1229 # if HAVE_STRFTIME
1230 goto underlying_strftime;
1231 # endif
1232 #endif
1234 if (modifier == L_('O'))
1235 goto bad_format;
1236 else
1237 DO_NUMBER (1, tp->tm_year + TM_YEAR_BASE);
1239 case L_('y'):
1240 if (modifier == L_('E'))
1242 #if HAVE_STRUCT_ERA_ENTRY
1243 struct era_entry *era = _nl_get_era_entry (tp);
1244 if (era)
1246 int delta = tp->tm_year - era->start_date[0];
1247 DO_NUMBER (1, (era->offset
1248 + delta * era->absolute_direction));
1250 #else
1251 # if HAVE_STRFTIME
1252 goto underlying_strftime;
1253 # endif
1254 #endif
1256 DO_NUMBER (2, (tp->tm_year % 100 + 100) % 100);
1258 case L_('Z'):
1259 if (change_case)
1261 to_uppcase = 0;
1262 to_lowcase = 1;
1265 #if HAVE_TZNAME
1266 /* The tzset() call might have changed the value. */
1267 if (!(zone && *zone) && tp->tm_isdst >= 0)
1268 zone = tzname[tp->tm_isdst];
1269 #endif
1270 if (! zone)
1271 zone = ""; /* POSIX.2 requires the empty string here. */
1273 #ifdef COMPILE_WIDE
1275 /* The zone string is always given in multibyte form. We have
1276 to transform it first. */
1277 wchar_t *wczone;
1278 size_t len;
1279 widen (zone, wczone, len);
1280 cpy (len, wczone);
1282 #else
1283 cpy (strlen (zone), zone);
1284 #endif
1285 break;
1287 case L_('z'): /* ISO C99 extension. */
1288 if (tp->tm_isdst < 0)
1289 break;
1292 int diff;
1293 #if HAVE_TM_GMTOFF
1294 diff = tp->tm_gmtoff;
1295 #else
1296 if (ut)
1297 diff = 0;
1298 else
1300 struct tm gtm;
1301 struct tm ltm;
1302 time_t lt;
1304 ltm = *tp;
1305 lt = mktime (&ltm);
1307 if (lt == (time_t) -1)
1309 /* mktime returns -1 for errors, but -1 is also a
1310 valid time_t value. Check whether an error really
1311 occurred. */
1312 struct tm tm;
1314 if (! my_strftime_localtime_r (&lt, &tm)
1315 || ((ltm.tm_sec ^ tm.tm_sec)
1316 | (ltm.tm_min ^ tm.tm_min)
1317 | (ltm.tm_hour ^ tm.tm_hour)
1318 | (ltm.tm_mday ^ tm.tm_mday)
1319 | (ltm.tm_mon ^ tm.tm_mon)
1320 | (ltm.tm_year ^ tm.tm_year)))
1321 break;
1324 if (! my_strftime_gmtime_r (&lt, &gtm))
1325 break;
1327 diff = tm_diff (&ltm, &gtm);
1329 #endif
1331 if (diff < 0)
1333 add (1, *p = L_('-'));
1334 diff = -diff;
1336 else
1337 add (1, *p = L_('+'));
1339 diff /= 60;
1340 DO_NUMBER (4, (diff / 60) * 100 + diff % 60);
1343 case L_('\0'): /* GNU extension: % at end of format. */
1344 --f;
1345 /* Fall through. */
1346 default:
1347 /* Unknown format; output the format, including the '%',
1348 since this is most likely the right thing to do if a
1349 multibyte string has been misparsed. */
1350 bad_format:
1352 int flen;
1353 for (flen = 1; f[1 - flen] != L_('%'); flen++)
1354 continue;
1355 cpy (flen, &f[1 - flen]);
1357 break;
1361 if (p && maxsize != 0)
1362 *p = L_('\0');
1363 return i;
1367 #ifdef emacs
1368 /* For Emacs we have a separate interface which corresponds to the normal
1369 strftime function and does not have the extra information whether the
1370 TP arguments comes from a `gmtime' call or not. */
1371 size_t
1372 emacs_strftime (s, maxsize, format, tp)
1373 char *s;
1374 size_t maxsize;
1375 const char *format;
1376 const struct tm *tp;
1378 return my_strftime (s, maxsize, format, tp, 0);
1380 #endif