*** empty log message ***
[coreutils.git] / lib / strftime.c
blobcc3a2d56867d216faac5a111468a3f3672e84fea
1 /* Copyright (C) 1991-1999, 2000, 2001 Free Software Foundation, Inc.
3 NOTE: The canonical source of this file is maintained with the GNU C Library.
4 Bugs can be reported to bug-glibc@prep.ai.mit.edu.
6 This program is free software; you can redistribute it and/or modify it
7 under the terms of the GNU General Public License as published by the
8 Free Software Foundation; either version 2, or (at your option) any
9 later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Library General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
19 USA. */
21 #ifdef HAVE_CONFIG_H
22 # include <config.h>
23 #endif
25 #ifdef _LIBC
26 # define HAVE_LIMITS_H 1
27 # define HAVE_MBLEN 1
28 # define HAVE_MBRLEN 1
29 # define HAVE_STRUCT_ERA_ENTRY 1
30 # define HAVE_TM_GMTOFF 1
31 # define HAVE_TM_ZONE 1
32 # define HAVE_TZNAME 1
33 # define HAVE_TZSET 1
34 # define MULTIBYTE_IS_FORMAT_SAFE 1
35 # define STDC_HEADERS 1
36 # include "../locale/localeinfo.h"
37 #endif
39 #if defined emacs && !defined HAVE_BCOPY
40 # define HAVE_MEMCPY 1
41 #endif
43 #include <ctype.h>
44 #include <sys/types.h> /* Some systems define `time_t' here. */
46 #ifdef TIME_WITH_SYS_TIME
47 # include <sys/time.h>
48 # include <time.h>
49 #else
50 # ifdef HAVE_SYS_TIME_H
51 # include <sys/time.h>
52 # else
53 # include <time.h>
54 # endif
55 #endif
56 #if HAVE_TZNAME
57 extern char *tzname[];
58 #endif
60 /* Do multibyte processing if multibytes are supported, unless
61 multibyte sequences are safe in formats. Multibyte sequences are
62 safe if they cannot contain byte sequences that look like format
63 conversion specifications. The GNU C Library uses UTF8 multibyte
64 encoding, which is safe for formats, but strftime.c can be used
65 with other C libraries that use unsafe encodings. */
66 #define DO_MULTIBYTE (HAVE_MBLEN && ! MULTIBYTE_IS_FORMAT_SAFE)
68 #if DO_MULTIBYTE
69 # if HAVE_MBRLEN
70 # include <wchar.h>
71 # else
72 /* Simulate mbrlen with mblen as best we can. */
73 # define mbstate_t int
74 # define mbrlen(s, n, ps) mblen (s, n)
75 # define mbsinit(ps) (*(ps) == 0)
76 # endif
77 static const mbstate_t mbstate_zero;
78 #endif
80 #if HAVE_LIMITS_H
81 # include <limits.h>
82 #endif
84 #if STDC_HEADERS
85 # include <stddef.h>
86 # include <stdlib.h>
87 # include <string.h>
88 #else
89 # ifndef HAVE_MEMCPY
90 # define memcpy(d, s, n) bcopy ((s), (d), (n))
91 # endif
92 #endif
94 #ifdef COMPILE_WIDE
95 # include <endian.h>
96 # define CHAR_T wchar_t
97 # define UCHAR_T unsigned int
98 # define L_(Str) L##Str
99 # define NLW(Sym) _NL_W##Sym
101 # define MEMCPY(d, s, n) __wmemcpy (d, s, n)
102 # define STRLEN(s) __wcslen (s)
104 #else
105 # define CHAR_T char
106 # define UCHAR_T unsigned char
107 # define L_(Str) Str
108 # define NLW(Sym) Sym
110 # if !defined STDC_HEADERS && !defined HAVE_MEMCPY
111 # define MEMCPY(d, s, n) bcopy ((s), (d), (n))
112 # else
113 # define MEMCPY(d, s, n) memcpy ((d), (s), (n))
114 # endif
115 # define STRLEN(s) strlen (s)
117 # ifdef _LIBC
118 # define MEMPCPY(d, s, n) __mempcpy (d, s, n)
119 # else
120 # ifndef HAVE_MEMPCPY
121 # define MEMPCPY(d, s, n) ((void *) ((char *) memcpy (d, s, n) + (n)))
122 # endif
123 # endif
124 #endif
126 #ifndef __P
127 # if defined __GNUC__ || (defined __STDC__ && __STDC__)
128 # define __P(args) args
129 # else
130 # define __P(args) ()
131 # endif /* GCC. */
132 #endif /* Not __P. */
134 #ifndef PTR
135 # ifdef __STDC__
136 # define PTR void *
137 # else
138 # define PTR char *
139 # endif
140 #endif
142 #ifndef CHAR_BIT
143 # define CHAR_BIT 8
144 #endif
146 #ifndef NULL
147 # define NULL 0
148 #endif
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
162 #ifndef __isleap
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))
167 #endif
170 #ifdef _LIBC
171 # define my_strftime_gmtime_r __gmtime_r
172 # define my_strftime_localtime_r __localtime_r
173 # define tzname __tzname
174 # define tzset __tzset
175 #else
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 __P ((const time_t *, struct tm *));
183 static struct tm *
184 my_strftime_gmtime_r (t, tp)
185 const time_t *t;
186 struct tm *tp;
188 struct tm *l = gmtime (t);
189 if (! l)
190 return 0;
191 *tp = *l;
192 return tp;
195 static struct tm *my_strftime_localtime_r __P ((const time_t *, struct tm *));
196 static struct tm *
197 my_strftime_localtime_r (t, tp)
198 const time_t *t;
199 struct tm *tp;
201 struct tm *l = localtime (t);
202 if (! l)
203 return 0;
204 *tp = *l;
205 return tp;
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) \
228 do { \
229 int _len = (Len); \
231 do \
233 int _this = _len > 16 ? 16 : _len; \
234 (P) = MEMPCPY ((P), spaces, _this * sizeof (CHAR_T)); \
235 _len -= _this; \
237 while (_len > 0); \
238 } while (0)
240 # define memset_zero(P, Len) \
241 do { \
242 int _len = (Len); \
244 do \
246 int _this = _len > 16 ? 16 : _len; \
247 (P) = MEMPCPY ((P), zeroes, _this * sizeof (CHAR_T)); \
248 _len -= _this; \
250 while (_len > 0); \
251 } while (0)
252 #else
253 # ifdef COMPILE_WIDE
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))
256 # else
257 # define memset_space(P, Len) (memset ((P), ' ', (Len)), (P) += (Len))
258 # define memset_zero(P, Len) (memset ((P), '0', (Len)), (P) += (Len))
259 # endif
260 #endif
262 #define add(n, f) \
263 do \
265 int _n = (n); \
266 int _delta = width - _n; \
267 int _incr = _n + (_delta > 0 ? _delta : 0); \
268 if (i + _incr >= maxsize) \
269 return 0; \
270 if (p) \
272 if (_delta > 0) \
274 if (pad == L_('0')) \
275 memset_zero (p, _delta); \
276 else \
277 memset_space (p, _delta); \
279 f; \
280 p += _n; \
282 i += _incr; \
283 } while (0)
285 #define cpy(n, s) \
286 add ((n), \
287 if (to_lowcase) \
288 memcpy_lowcase (p, (s), _n); \
289 else if (to_uppcase) \
290 memcpy_uppcase (p, (s), _n); \
291 else \
292 MEMCPY ((PTR) p, (const PTR) (s), _n))
294 #ifdef COMPILE_WIDE
295 # define widen(os, ws, l) \
297 mbstate_t __st; \
298 const char *__s = os; \
299 memset (&__st, '\0', sizeof (__st)); \
300 l = __mbsrtowcs (NULL, &__s, 0, &__st); \
301 ws = alloca ((l + 1) * sizeof (wchar_t)); \
302 (void) __mbsrtowcs (ws, &__s, l, &__st); \
304 #endif
307 #ifdef COMPILE_WIDE
308 # define TOUPPER(Ch) towupper (Ch)
309 # define TOLOWER(Ch) towlower (Ch)
310 #else
311 # ifdef _LIBC
312 # define TOUPPER(Ch) toupper (Ch)
313 # define TOLOWER(Ch) tolower (Ch)
314 # else
315 # define TOUPPER(Ch) (islower (Ch) ? toupper (Ch) : (Ch))
316 # define TOLOWER(Ch) (isupper (Ch) ? tolower (Ch) : (Ch))
317 # endif
318 #endif
319 /* We don't use `isdigit' here since the locale dependent
320 interpretation is not what we want here. We only need to accept
321 the arabic digits in the ASCII range. One day there is perhaps a
322 more reliable way to accept other sets of digits. */
323 #define ISDIGIT(Ch) ((unsigned int) (Ch) - L_('0') <= 9)
325 static CHAR_T *memcpy_lowcase __P ((CHAR_T *dest, const CHAR_T *src,
326 size_t len));
328 static CHAR_T *
329 memcpy_lowcase (dest, src, len)
330 CHAR_T *dest;
331 const CHAR_T *src;
332 size_t len;
334 while (len-- > 0)
335 dest[len] = TOLOWER ((UCHAR_T) src[len]);
336 return dest;
339 static CHAR_T *memcpy_uppcase __P ((CHAR_T *dest, const CHAR_T *src,
340 size_t len));
342 static CHAR_T *
343 memcpy_uppcase (dest, src, len)
344 CHAR_T *dest;
345 const CHAR_T *src;
346 size_t len;
348 while (len-- > 0)
349 dest[len] = TOUPPER ((UCHAR_T) src[len]);
350 return dest;
354 #if ! HAVE_TM_GMTOFF
355 /* Yield the difference between *A and *B,
356 measured in seconds, ignoring leap seconds. */
357 # define tm_diff ftime_tm_diff
358 static int tm_diff __P ((const struct tm *, const struct tm *));
359 static int
360 tm_diff (a, b)
361 const struct tm *a;
362 const struct tm *b;
364 /* Compute intervening leap days correctly even if year is negative.
365 Take care to avoid int overflow in leap day calculations,
366 but it's OK to assume that A and B are close to each other. */
367 int a4 = (a->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (a->tm_year & 3);
368 int b4 = (b->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (b->tm_year & 3);
369 int a100 = a4 / 25 - (a4 % 25 < 0);
370 int b100 = b4 / 25 - (b4 % 25 < 0);
371 int a400 = a100 >> 2;
372 int b400 = b100 >> 2;
373 int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
374 int years = a->tm_year - b->tm_year;
375 int days = (365 * years + intervening_leap_days
376 + (a->tm_yday - b->tm_yday));
377 return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
378 + (a->tm_min - b->tm_min))
379 + (a->tm_sec - b->tm_sec));
381 #endif /* ! HAVE_TM_GMTOFF */
385 /* The number of days from the first day of the first ISO week of this
386 year to the year day YDAY with week day WDAY. ISO weeks start on
387 Monday; the first ISO week has the year's first Thursday. YDAY may
388 be as small as YDAY_MINIMUM. */
389 #define ISO_WEEK_START_WDAY 1 /* Monday */
390 #define ISO_WEEK1_WDAY 4 /* Thursday */
391 #define YDAY_MINIMUM (-366)
392 static int iso_week_days __P ((int, int));
393 #ifdef __GNUC__
394 __inline__
395 #endif
396 static int
397 iso_week_days (yday, wday)
398 int yday;
399 int wday;
401 /* Add enough to the first operand of % to make it nonnegative. */
402 int big_enough_multiple_of_7 = (-YDAY_MINIMUM / 7 + 2) * 7;
403 return (yday
404 - (yday - wday + ISO_WEEK1_WDAY + big_enough_multiple_of_7) % 7
405 + ISO_WEEK1_WDAY - ISO_WEEK_START_WDAY);
409 #if !(defined _NL_CURRENT || HAVE_STRFTIME)
410 static CHAR_T const weekday_name[][10] =
412 L_("Sunday"), L_("Monday"), L_("Tuesday"), L_("Wednesday"),
413 L_("Thursday"), L_("Friday"), L_("Saturday")
415 static CHAR_T const month_name[][10] =
417 L_("January"), L_("February"), L_("March"), L_("April"), L_("May"),
418 L_("June"), L_("July"), L_("August"), L_("September"), L_("October"),
419 L_("November"), L_("December")
421 #endif
424 /* When compiling this file, GNU applications can #define my_strftime
425 to a symbol (typically nstrftime) to get an extended strftime with
426 extra arguments UT and NS. Emacs is a special case for now, but
427 this Emacs-specific code can be removed once Emacs's config.h
428 defines my_strftime. */
429 #if defined emacs && !defined my_strftime
430 # define my_strftime nstrftime
431 #endif
433 #ifdef my_strftime
434 # define extra_args , ut, ns
435 # define extra_args_spec int ut; int ns;
436 # define extra_args_spec_iso , int ut, int ns
437 #else
438 # ifdef COMPILE_WIDE
439 # define my_strftime wcsftime
440 # else
441 # define my_strftime strftime
442 # endif
443 # define extra_args
444 # define extra_args_spec
445 # define extra_args_spec_iso
446 /* We don't have this information in general. */
447 # define ut 0
448 # define ns 0
449 #endif
451 #if !defined _LIBC && HAVE_TZNAME && HAVE_TZSET
452 /* Solaris 2.5 tzset sometimes modifies the storage returned by localtime.
453 Work around this bug by copying *tp before it might be munged. */
454 size_t _strftime_copytm __P ((char *, size_t, const char *,
455 const struct tm * extra_args_spec_iso));
456 size_t
457 my_strftime (s, maxsize, format, tp extra_args)
458 CHAR_T *s;
459 size_t maxsize;
460 const CHAR_T *format;
461 const struct tm *tp;
462 extra_args_spec
464 struct tm tmcopy;
465 tmcopy = *tp;
466 return _strftime_copytm (s, maxsize, format, &tmcopy extra_args);
468 # undef my_strftime
469 # define my_strftime _strftime_copytm
470 #endif
473 /* Write information from TP into S according to the format
474 string FORMAT, writing no more that MAXSIZE characters
475 (including the terminating '\0') and returning number of
476 characters written. If S is NULL, nothing will be written
477 anywhere, so to determine how many characters would be
478 written, use NULL for S and (size_t) UINT_MAX for MAXSIZE. */
479 size_t
480 my_strftime (s, maxsize, format, tp extra_args)
481 CHAR_T *s;
482 size_t maxsize;
483 const CHAR_T *format;
484 const struct tm *tp;
485 extra_args_spec
487 int hour12 = tp->tm_hour;
488 #ifdef _NL_CURRENT
489 /* We cannot make the following values variables since we must delay
490 the evaluation of these values until really needed since some
491 expressions might not be valid in every situation. The `struct tm'
492 might be generated by a strptime() call that initialized
493 only a few elements. Dereference the pointers only if the format
494 requires this. Then it is ok to fail if the pointers are invalid. */
495 # define a_wkday \
496 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABDAY_1) + tp->tm_wday))
497 # define f_wkday \
498 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(DAY_1) + tp->tm_wday))
499 # define a_month \
500 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABMON_1) + tp->tm_mon))
501 # define f_month \
502 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(MON_1) + tp->tm_mon))
503 # define ampm \
504 ((const CHAR_T *) _NL_CURRENT (LC_TIME, tp->tm_hour > 11 \
505 ? NLW(PM_STR) : NLW(AM_STR)))
507 # define aw_len STRLEN (a_wkday)
508 # define am_len STRLEN (a_month)
509 # define ap_len STRLEN (ampm)
510 #else
511 # if !HAVE_STRFTIME
512 # define f_wkday (weekday_name[tp->tm_wday])
513 # define f_month (month_name[tp->tm_mon])
514 # define a_wkday f_wkday
515 # define a_month f_month
516 # define ampm (L_("AMPM") + 2 * (tp->tm_hour > 11))
518 size_t aw_len = 3;
519 size_t am_len = 3;
520 size_t ap_len = 2;
521 # endif
522 #endif
523 const char *zone;
524 size_t i = 0;
525 CHAR_T *p = s;
526 const CHAR_T *f;
527 #if DO_MULTIBYTE && !defined COMPILE_WIDE
528 const char *format_end = NULL;
529 #endif
531 zone = NULL;
532 #if HAVE_TM_ZONE
533 /* The POSIX test suite assumes that setting
534 the environment variable TZ to a new value before calling strftime()
535 will influence the result (the %Z format) even if the information in
536 TP is computed with a totally different time zone.
537 This is bogus: though POSIX allows bad behavior like this,
538 POSIX does not require it. Do the right thing instead. */
539 zone = (const char *) tp->tm_zone;
540 #endif
541 #if HAVE_TZNAME
542 if (ut)
544 if (! (zone && *zone))
545 zone = "GMT";
547 else
549 /* POSIX.1 8.1.1 requires that whenever strftime() is called, the
550 time zone names contained in the external variable `tzname' shall
551 be set as if the tzset() function had been called. */
552 # if HAVE_TZSET
553 tzset ();
554 # endif
556 #endif
558 if (hour12 > 12)
559 hour12 -= 12;
560 else
561 if (hour12 == 0)
562 hour12 = 12;
564 for (f = format; *f != '\0'; ++f)
566 int pad = 0; /* Padding for number ('-', '_', or 0). */
567 int modifier; /* Field modifier ('E', 'O', or 0). */
568 int digits; /* Max digits for numeric format. */
569 int number_value; /* Numeric value to be printed. */
570 int negative_number; /* 1 if the number is negative. */
571 const CHAR_T *subfmt;
572 CHAR_T *bufp;
573 CHAR_T buf[1 + (sizeof (int) < sizeof (time_t)
574 ? INT_STRLEN_BOUND (time_t)
575 : INT_STRLEN_BOUND (int))];
576 int width = -1;
577 int to_lowcase = 0;
578 int to_uppcase = 0;
579 int change_case = 0;
580 int format_char;
582 #if DO_MULTIBYTE && !defined COMPILE_WIDE
583 switch (*f)
585 case L_('%'):
586 break;
588 case L_('\b'): case L_('\t'): case L_('\n'):
589 case L_('\v'): case L_('\f'): case L_('\r'):
590 case L_(' '): case L_('!'): case L_('"'): case L_('#'): case L_('&'):
591 case L_('\''): case L_('('): case L_(')'): case L_('*'): case L_('+'):
592 case L_(','): case L_('-'): case L_('.'): case L_('/'): case L_('0'):
593 case L_('1'): case L_('2'): case L_('3'): case L_('4'): case L_('5'):
594 case L_('6'): case L_('7'): case L_('8'): case L_('9'): case L_(':'):
595 case L_(';'): case L_('<'): case L_('='): case L_('>'): case L_('?'):
596 case L_('A'): case L_('B'): case L_('C'): case L_('D'): case L_('E'):
597 case L_('F'): case L_('G'): case L_('H'): case L_('I'): case L_('J'):
598 case L_('K'): case L_('L'): case L_('M'): case L_('N'): case L_('O'):
599 case L_('P'): case L_('Q'): case L_('R'): case L_('S'): case L_('T'):
600 case L_('U'): case L_('V'): case L_('W'): case L_('X'): case L_('Y'):
601 case L_('Z'): case L_('['): case L_('\\'): case L_(']'): case L_('^'):
602 case L_('_'): case L_('a'): case L_('b'): case L_('c'): case L_('d'):
603 case L_('e'): case L_('f'): case L_('g'): case L_('h'): case L_('i'):
604 case L_('j'): case L_('k'): case L_('l'): case L_('m'): case L_('n'):
605 case L_('o'): case L_('p'): case L_('q'): case L_('r'): case L_('s'):
606 case L_('t'): case L_('u'): case L_('v'): case L_('w'): case L_('x'):
607 case L_('y'): case L_('z'): case L_('{'): case L_('|'): case L_('}'):
608 case L_('~'):
609 /* The C Standard requires these 98 characters (plus '%') to
610 be in the basic execution character set. None of these
611 characters can start a multibyte sequence, so they need
612 not be analyzed further. */
613 add (1, *p = *f);
614 continue;
616 default:
617 /* Copy this multibyte sequence until we reach its end, find
618 an error, or come back to the initial shift state. */
620 mbstate_t mbstate = mbstate_zero;
621 size_t len = 0;
622 size_t fsize;
624 if (! format_end)
625 format_end = f + strlen (f) + 1;
626 fsize = format_end - f;
630 size_t bytes = mbrlen (f + len, fsize - len, &mbstate);
632 if (bytes == 0)
633 break;
635 if (bytes == (size_t) -2)
637 len += strlen (f + len);
638 break;
641 if (bytes == (size_t) -1)
643 len++;
644 break;
647 len += bytes;
649 while (! mbsinit (&mbstate));
651 cpy (len, f);
652 f += len - 1;
653 continue;
657 #else /* ! DO_MULTIBYTE */
659 /* Either multibyte encodings are not supported, they are
660 safe for formats, so any non-'%' byte can be copied through,
661 or this is the wide character version. */
662 if (*f != L_('%'))
664 add (1, *p = *f);
665 continue;
668 #endif /* ! DO_MULTIBYTE */
670 /* Check for flags that can modify a format. */
671 while (1)
673 switch (*++f)
675 /* This influences the number formats. */
676 case L_('_'):
677 case L_('-'):
678 case L_('0'):
679 pad = *f;
680 continue;
682 /* This changes textual output. */
683 case L_('^'):
684 to_uppcase = 1;
685 continue;
686 case L_('#'):
687 change_case = 1;
688 continue;
690 default:
691 break;
693 break;
696 /* As a GNU extension we allow to specify the field width. */
697 if (ISDIGIT (*f))
699 width = 0;
702 width *= 10;
703 width += *f - L_('0');
704 ++f;
706 while (ISDIGIT (*f));
709 /* Check for modifiers. */
710 switch (*f)
712 case L_('E'):
713 case L_('O'):
714 modifier = *f++;
715 break;
717 default:
718 modifier = 0;
719 break;
722 /* Now do the specified format. */
723 format_char = *f;
724 switch (format_char)
726 #define DO_NUMBER(d, v) \
727 digits = width == -1 ? d : width; \
728 number_value = v; goto do_number
729 #define DO_NUMBER_SPACEPAD(d, v) \
730 digits = width == -1 ? d : width; \
731 number_value = v; goto do_number_spacepad
733 case L_('%'):
734 if (modifier != 0)
735 goto bad_format;
736 add (1, *p = *f);
737 break;
739 case L_('a'):
740 if (modifier != 0)
741 goto bad_format;
742 if (change_case)
744 to_uppcase = 1;
745 to_lowcase = 0;
747 #if defined _NL_CURRENT || !HAVE_STRFTIME
748 cpy (aw_len, a_wkday);
749 break;
750 #else
751 goto underlying_strftime;
752 #endif
754 case 'A':
755 if (modifier != 0)
756 goto bad_format;
757 if (change_case)
759 to_uppcase = 1;
760 to_lowcase = 0;
762 #if defined _NL_CURRENT || !HAVE_STRFTIME
763 cpy (STRLEN (f_wkday), f_wkday);
764 break;
765 #else
766 goto underlying_strftime;
767 #endif
769 case L_('b'):
770 case L_('h'): /* POSIX.2 extension. */
771 if (change_case)
773 to_uppcase = 1;
774 to_lowcase = 0;
776 if (modifier != 0)
777 goto bad_format;
778 #if defined _NL_CURRENT || !HAVE_STRFTIME
779 cpy (am_len, a_month);
780 break;
781 #else
782 goto underlying_strftime;
783 #endif
785 case L_('B'):
786 if (modifier != 0)
787 goto bad_format;
788 if (change_case)
790 to_uppcase = 1;
791 to_lowcase = 0;
793 #if defined _NL_CURRENT || !HAVE_STRFTIME
794 cpy (STRLEN (f_month), f_month);
795 break;
796 #else
797 goto underlying_strftime;
798 #endif
800 case L_('c'):
801 if (modifier == L_('O'))
802 goto bad_format;
803 #ifdef _NL_CURRENT
804 if (! (modifier == 'E'
805 && (*(subfmt =
806 (const CHAR_T *) _NL_CURRENT (LC_TIME,
807 NLW(ERA_D_T_FMT)))
808 != '\0')))
809 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_T_FMT));
810 #else
811 # if HAVE_STRFTIME
812 goto underlying_strftime;
813 # else
814 subfmt = L_("%a %b %e %H:%M:%S %Y");
815 # endif
816 #endif
818 subformat:
820 CHAR_T *old_start = p;
821 size_t len = my_strftime (NULL, (size_t) -1, subfmt,
822 tp extra_args);
823 add (len, my_strftime (p, maxsize - i, subfmt,
824 tp extra_args));
826 if (to_uppcase)
827 while (old_start < p)
829 *old_start = TOUPPER ((UCHAR_T) *old_start);
830 ++old_start;
833 break;
835 #if HAVE_STRFTIME && ! (defined _NL_CURRENT && HAVE_STRUCT_ERA_ENTRY)
836 underlying_strftime:
838 /* The relevant information is available only via the
839 underlying strftime implementation, so use that. */
840 char ufmt[4];
841 char *u = ufmt;
842 char ubuf[1024]; /* enough for any single format in practice */
843 size_t len;
844 /* Make sure we're calling the actual underlying strftime.
845 In some cases, config.h contains something like
846 "#define strftime rpl_strftime". */
847 # ifdef strftime
848 # undef strftime
849 size_t strftime ();
850 # endif
852 *u++ = '%';
853 if (modifier != 0)
854 *u++ = modifier;
855 *u++ = format_char;
856 *u = '\0';
857 len = strftime (ubuf, sizeof ubuf, ufmt, tp);
858 if (len == 0 && ubuf[0] != '\0')
859 return 0;
860 cpy (len, ubuf);
862 break;
863 #endif
865 case L_('C'): /* POSIX.2 extension. */
866 if (modifier == L_('O'))
867 goto bad_format;
868 if (modifier == L_('E'))
870 #if HAVE_STRUCT_ERA_ENTRY
871 struct era_entry *era = _nl_get_era_entry (tp);
872 if (era)
874 # ifdef COMPILE_WIDE
875 size_t len = __wcslen (era->era_wname);
876 cpy (len, era->era_wname);
877 # else
878 size_t len = strlen (era->era_name);
879 cpy (len, era->era_name);
880 # endif
881 break;
883 #else
884 # if HAVE_STRFTIME
885 goto underlying_strftime;
886 # endif
887 #endif
891 int year = tp->tm_year + TM_YEAR_BASE;
892 DO_NUMBER (1, year / 100 - (year % 100 < 0));
895 case L_('x'):
896 if (modifier == L_('O'))
897 goto bad_format;
898 #ifdef _NL_CURRENT
899 if (! (modifier == L_('E')
900 && (*(subfmt =
901 (const CHAR_T *)_NL_CURRENT (LC_TIME, NLW(ERA_D_FMT)))
902 != L_('\0'))))
903 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_FMT));
904 goto subformat;
905 #else
906 # if HAVE_STRFTIME
907 goto underlying_strftime;
908 # else
909 /* Fall through. */
910 # endif
911 #endif
912 case L_('D'): /* POSIX.2 extension. */
913 if (modifier != 0)
914 goto bad_format;
915 subfmt = L_("%m/%d/%y");
916 goto subformat;
918 case L_('d'):
919 if (modifier == L_('E'))
920 goto bad_format;
922 DO_NUMBER (2, tp->tm_mday);
924 case L_('e'): /* POSIX.2 extension. */
925 if (modifier == L_('E'))
926 goto bad_format;
928 DO_NUMBER_SPACEPAD (2, tp->tm_mday);
930 /* All numeric formats set DIGITS and NUMBER_VALUE and then
931 jump to one of these two labels. */
933 do_number_spacepad:
934 /* Force `_' flag unless overwritten by `0' flag. */
935 if (pad != L_('0'))
936 pad = L_('_');
938 do_number:
939 /* Format the number according to the MODIFIER flag. */
941 if (modifier == L_('O') && 0 <= number_value)
943 #ifdef _NL_CURRENT
944 /* Get the locale specific alternate representation of
945 the number NUMBER_VALUE. If none exist NULL is returned. */
946 # ifdef COMPILE_WIDE
947 const wchar_t *cp = _nl_get_walt_digit (number_value);
948 # else
949 const char *cp = _nl_get_alt_digit (number_value);
950 # endif
952 if (cp != NULL)
954 size_t digitlen = STRLEN (cp);
955 if (digitlen != 0)
957 cpy (digitlen, cp);
958 break;
961 #else
962 # if HAVE_STRFTIME
963 goto underlying_strftime;
964 # endif
965 #endif
968 unsigned int u = number_value;
970 bufp = buf + sizeof (buf) / sizeof (buf[0]);
971 negative_number = number_value < 0;
973 if (negative_number)
974 u = -u;
977 *--bufp = u % 10 + L_('0');
978 while ((u /= 10) != 0);
981 do_number_sign_and_padding:
982 if (negative_number)
983 *--bufp = L_('-');
985 if (pad != L_('-'))
987 int padding = digits - (buf + (sizeof (buf) / sizeof (buf[0]))
988 - bufp);
990 if (pad == L_('_'))
992 while (0 < padding--)
993 *--bufp = L_(' ');
995 else
997 bufp += negative_number;
998 while (0 < padding--)
999 *--bufp = L_('0');
1000 if (negative_number)
1001 *--bufp = L_('-');
1005 cpy (buf + sizeof (buf) / sizeof (buf[0]) - bufp, bufp);
1006 break;
1008 case L_('F'):
1009 if (modifier != 0)
1010 goto bad_format;
1011 subfmt = L_("%Y-%m-%d");
1012 goto subformat;
1014 case L_('H'):
1015 if (modifier == L_('E'))
1016 goto bad_format;
1018 DO_NUMBER (2, tp->tm_hour);
1020 case L_('I'):
1021 if (modifier == L_('E'))
1022 goto bad_format;
1024 DO_NUMBER (2, hour12);
1026 case L_('k'): /* GNU extension. */
1027 if (modifier == L_('E'))
1028 goto bad_format;
1030 DO_NUMBER_SPACEPAD (2, tp->tm_hour);
1032 case L_('l'): /* GNU extension. */
1033 if (modifier == L_('E'))
1034 goto bad_format;
1036 DO_NUMBER_SPACEPAD (2, hour12);
1038 case L_('j'):
1039 if (modifier == L_('E'))
1040 goto bad_format;
1042 DO_NUMBER (3, 1 + tp->tm_yday);
1044 case L_('M'):
1045 if (modifier == L_('E'))
1046 goto bad_format;
1048 DO_NUMBER (2, tp->tm_min);
1050 case L_('m'):
1051 if (modifier == L_('E'))
1052 goto bad_format;
1054 DO_NUMBER (2, tp->tm_mon + 1);
1056 case L_('N'): /* GNU extension. */
1057 if (modifier == L_('E'))
1058 goto bad_format;
1060 number_value = ns;
1061 if (width != -1)
1063 /* Take an explicit width less than 9 as a precision. */
1064 int j;
1065 for (j = width; j < 9; j++)
1066 number_value /= 10;
1069 DO_NUMBER (9, number_value);
1071 case L_('n'): /* POSIX.2 extension. */
1072 add (1, *p = L_('\n'));
1073 break;
1075 case L_('P'):
1076 to_lowcase = 1;
1077 #if !defined _NL_CURRENT && HAVE_STRFTIME
1078 format_char = L_('p');
1079 #endif
1080 /* FALLTHROUGH */
1082 case L_('p'):
1083 if (change_case)
1085 to_uppcase = 0;
1086 to_lowcase = 1;
1088 #if defined _NL_CURRENT || !HAVE_STRFTIME
1089 cpy (ap_len, ampm);
1090 break;
1091 #else
1092 goto underlying_strftime;
1093 #endif
1095 case L_('R'): /* ISO C99 extension. */
1096 subfmt = L_("%H:%M");
1097 goto subformat;
1099 case L_('r'): /* POSIX.2 extension. */
1100 #ifdef _NL_CURRENT
1101 if (*(subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME,
1102 NLW(T_FMT_AMPM)))
1103 == L_('\0'))
1104 #endif
1105 subfmt = L_("%I:%M:%S %p");
1106 goto subformat;
1108 case L_('S'):
1109 if (modifier == L_('E'))
1110 goto bad_format;
1112 DO_NUMBER (2, tp->tm_sec);
1114 case L_('s'): /* GNU extension. */
1116 struct tm ltm;
1117 time_t t;
1119 ltm = *tp;
1120 t = mktime (&ltm);
1122 /* Generate string value for T using time_t arithmetic;
1123 this works even if sizeof (long) < sizeof (time_t). */
1125 bufp = buf + sizeof (buf) / sizeof (buf[0]);
1126 negative_number = t < 0;
1130 int d = t % 10;
1131 t /= 10;
1133 if (negative_number)
1135 d = -d;
1137 /* Adjust if division truncates to minus infinity. */
1138 if (0 < -1 % 10 && d < 0)
1140 t++;
1141 d += 10;
1145 *--bufp = d + L_('0');
1147 while (t != 0);
1149 digits = 1;
1150 goto do_number_sign_and_padding;
1153 case L_('X'):
1154 if (modifier == L_('O'))
1155 goto bad_format;
1156 #ifdef _NL_CURRENT
1157 if (! (modifier == L_('E')
1158 && (*(subfmt =
1159 (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ERA_T_FMT)))
1160 != L_('\0'))))
1161 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(T_FMT));
1162 goto subformat;
1163 #else
1164 # if HAVE_STRFTIME
1165 goto underlying_strftime;
1166 # else
1167 /* Fall through. */
1168 # endif
1169 #endif
1170 case L_('T'): /* POSIX.2 extension. */
1171 subfmt = L_("%H:%M:%S");
1172 goto subformat;
1174 case L_('t'): /* POSIX.2 extension. */
1175 add (1, *p = L_('\t'));
1176 break;
1178 case L_('u'): /* POSIX.2 extension. */
1179 DO_NUMBER (1, (tp->tm_wday - 1 + 7) % 7 + 1);
1181 case L_('U'):
1182 if (modifier == L_('E'))
1183 goto bad_format;
1185 DO_NUMBER (2, (tp->tm_yday - tp->tm_wday + 7) / 7);
1187 case L_('V'):
1188 case L_('g'): /* ISO C99 extension. */
1189 case L_('G'): /* ISO C99 extension. */
1190 if (modifier == L_('E'))
1191 goto bad_format;
1193 int year = tp->tm_year + TM_YEAR_BASE;
1194 int days = iso_week_days (tp->tm_yday, tp->tm_wday);
1196 if (days < 0)
1198 /* This ISO week belongs to the previous year. */
1199 year--;
1200 days = iso_week_days (tp->tm_yday + (365 + __isleap (year)),
1201 tp->tm_wday);
1203 else
1205 int d = iso_week_days (tp->tm_yday - (365 + __isleap (year)),
1206 tp->tm_wday);
1207 if (0 <= d)
1209 /* This ISO week belongs to the next year. */
1210 year++;
1211 days = d;
1215 switch (*f)
1217 case L_('g'):
1218 DO_NUMBER (2, (year % 100 + 100) % 100);
1220 case L_('G'):
1221 DO_NUMBER (1, year);
1223 default:
1224 DO_NUMBER (2, days / 7 + 1);
1228 case L_('W'):
1229 if (modifier == L_('E'))
1230 goto bad_format;
1232 DO_NUMBER (2, (tp->tm_yday - (tp->tm_wday - 1 + 7) % 7 + 7) / 7);
1234 case L_('w'):
1235 if (modifier == L_('E'))
1236 goto bad_format;
1238 DO_NUMBER (1, tp->tm_wday);
1240 case L_('Y'):
1241 if (modifier == 'E')
1243 #if HAVE_STRUCT_ERA_ENTRY
1244 struct era_entry *era = _nl_get_era_entry (tp);
1245 if (era)
1247 # ifdef COMPILE_WIDE
1248 subfmt = era->era_wformat;
1249 # else
1250 subfmt = era->era_format;
1251 # endif
1252 goto subformat;
1254 #else
1255 # if HAVE_STRFTIME
1256 goto underlying_strftime;
1257 # endif
1258 #endif
1260 if (modifier == L_('O'))
1261 goto bad_format;
1262 else
1263 DO_NUMBER (1, tp->tm_year + TM_YEAR_BASE);
1265 case L_('y'):
1266 if (modifier == L_('E'))
1268 #if HAVE_STRUCT_ERA_ENTRY
1269 struct era_entry *era = _nl_get_era_entry (tp);
1270 if (era)
1272 int delta = tp->tm_year - era->start_date[0];
1273 DO_NUMBER (1, (era->offset
1274 + delta * era->absolute_direction));
1276 #else
1277 # if HAVE_STRFTIME
1278 goto underlying_strftime;
1279 # endif
1280 #endif
1282 DO_NUMBER (2, (tp->tm_year % 100 + 100) % 100);
1284 case L_('Z'):
1285 if (change_case)
1287 to_uppcase = 0;
1288 to_lowcase = 1;
1291 #if HAVE_TZNAME
1292 /* The tzset() call might have changed the value. */
1293 if (!(zone && *zone) && tp->tm_isdst >= 0)
1294 zone = tzname[tp->tm_isdst];
1295 #endif
1296 if (! zone)
1297 zone = ""; /* POSIX.2 requires the empty string here. */
1299 #ifdef COMPILE_WIDE
1301 /* The zone string is always given in multibyte form. We have
1302 to transform it first. */
1303 wchar_t *wczone;
1304 size_t len;
1305 widen (zone, wczone, len);
1306 cpy (len, wczone);
1308 #else
1309 cpy (strlen (zone), zone);
1310 #endif
1311 break;
1313 case L_('z'): /* ISO C99 extension. */
1314 if (tp->tm_isdst < 0)
1315 break;
1318 int diff;
1319 #if HAVE_TM_GMTOFF
1320 diff = tp->tm_gmtoff;
1321 #else
1322 if (ut)
1323 diff = 0;
1324 else
1326 struct tm gtm;
1327 struct tm ltm;
1328 time_t lt;
1330 ltm = *tp;
1331 lt = mktime (&ltm);
1333 if (lt == (time_t) -1)
1335 /* mktime returns -1 for errors, but -1 is also a
1336 valid time_t value. Check whether an error really
1337 occurred. */
1338 struct tm tm;
1340 if (! my_strftime_localtime_r (&lt, &tm)
1341 || ((ltm.tm_sec ^ tm.tm_sec)
1342 | (ltm.tm_min ^ tm.tm_min)
1343 | (ltm.tm_hour ^ tm.tm_hour)
1344 | (ltm.tm_mday ^ tm.tm_mday)
1345 | (ltm.tm_mon ^ tm.tm_mon)
1346 | (ltm.tm_year ^ tm.tm_year)))
1347 break;
1350 if (! my_strftime_gmtime_r (&lt, &gtm))
1351 break;
1353 diff = tm_diff (&ltm, &gtm);
1355 #endif
1357 if (diff < 0)
1359 add (1, *p = L_('-'));
1360 diff = -diff;
1362 else
1363 add (1, *p = L_('+'));
1365 diff /= 60;
1366 DO_NUMBER (4, (diff / 60) * 100 + diff % 60);
1369 case L_('\0'): /* GNU extension: % at end of format. */
1370 --f;
1371 /* Fall through. */
1372 default:
1373 /* Unknown format; output the format, including the '%',
1374 since this is most likely the right thing to do if a
1375 multibyte string has been misparsed. */
1376 bad_format:
1378 int flen;
1379 for (flen = 1; f[1 - flen] != L_('%'); flen++)
1380 continue;
1381 cpy (flen, &f[1 - flen]);
1383 break;
1387 if (p && maxsize != 0)
1388 *p = L_('\0');
1389 return i;
1393 #ifdef emacs
1394 /* For Emacs we have a separate interface which corresponds to the normal
1395 strftime function plus the ut argument, but without the ns argument. */
1396 size_t
1397 emacs_strftimeu (s, maxsize, format, tp, ut)
1398 char *s;
1399 size_t maxsize;
1400 const char *format;
1401 const struct tm *tp;
1402 int ut;
1404 return my_strftime (s, maxsize, format, tp, ut, 0);
1406 #endif