HCoop / bpt / emacs.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge from emacs-23
[bpt/emacs.git] / src / strftime.c
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.
4
5 NOTE: The canonical source of this file is maintained with gnulib.
6 Bugs can be reported to bug-gnulib@gnu.org.
7
8 This file is part of the GNU Emacs.
9
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.
14
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.
19
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. */
24
25 #ifdef HAVE_CONFIG_H
26 # include <config.h>
27 #endif
28
29 #ifdef _LIBC
30 # define HAVE_LIMITS_H 1
31 # define HAVE_MBLEN 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
37 # define HAVE_TZSET 1
38 # define MULTIBYTE_IS_FORMAT_SAFE 1
39 # define STDC_HEADERS 1
40 # include "../locale/localeinfo.h"
41 #endif
42
43 #include <ctype.h>
44 #include <sys/types.h> /* Some systems define `time_t' here. */
45
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 #ifndef USE_CRT_DLL
58 extern char *tzname[];
59 #endif
60 #endif
61
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)
69
70 #if DO_MULTIBYTE
71 # if HAVE_MBRLEN
72 # include <wchar.h>
73 # ifdef HAVE_SYS__MBSTATE_T_H /* previously tested __hpux */
74 # include <sys/_mbstate_t.h>
75 # endif
76 # if !defined (mbsinit) && !defined (HAVE_MBSINIT)
77 # define mbsinit(ps) 1
78 # endif /* !defined (mbsinit) && !defined (HAVE_MBSINIT) */
79 # else
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)
84 # endif
85 static const mbstate_t mbstate_zero;
86 #endif
87
88 #ifdef HAVE_LIMITS_H
89 # include <limits.h>
90 #endif
91
92 #ifdef STDC_HEADERS
93 # include <stddef.h>
94 # include <stdlib.h>
95 # include <string.h>
96 #else
97 # ifndef HAVE_MEMCPY
98 # define memcpy(d, s, n) bcopy ((s), (d), (n))
99 # endif
100 #endif
101
102 #ifdef COMPILE_WIDE
103 # include <endian.h>
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
108
109 # define MEMCPY(d, s, n) __wmemcpy (d, s, n)
110 # define STRLEN(s) __wcslen (s)
111
112 #else
113 # define CHAR_T char
114 # define UCHAR_T unsigned char
115 # define L_(Str) Str
116 # define NLW(Sym) Sym
117
118 # if !defined STDC_HEADERS && !defined HAVE_MEMCPY
119 # define MEMCPY(d, s, n) bcopy ((s), (d), (n))
120 # else
121 # define MEMCPY(d, s, n) memcpy ((d), (s), (n))
122 # endif
123 # define STRLEN(s) strlen (s)
124
125 # ifdef _LIBC
126 # define MEMPCPY(d, s, n) __mempcpy (d, s, n)
127 # else
128 # ifndef HAVE_MEMPCPY
129 # define MEMPCPY(d, s, n) ((void *) ((char *) memcpy (d, s, n) + (n)))
130 # endif
131 # endif
132 #endif
133
134 #ifndef PTR
135 # ifdef __STDC__
136 # define PTR void *
137 # else
138 # define PTR char *
139 # endif
140 #endif
141
142 #ifndef CHAR_BIT
143 # define CHAR_BIT 8
144 #endif
145
146 #ifndef NULL
147 # define NULL 0
148 #endif
149
150 #define TYPE_SIGNED(t) ((t) -1 < 0)
151
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))
159
160 #define TM_YEAR_BASE 1900
161
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
168
169
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
176
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. */
180
181 # if ! HAVE_TM_GMTOFF
182 static struct tm *
183 my_strftime_gmtime_r (const time_t *t, struct tm *tp)
184 {
185 struct tm *l = gmtime (t);
186 if (! l)
187 return 0;
188 *tp = *l;
189 return tp;
190 }
191
192 static struct tm *
193 my_strftime_localtime_r (const time_t *t, struct tm *tp)
194 {
195 struct tm *l = localtime (t);
196 if (! l)
197 return 0;
198 *tp = *l;
199 return tp;
200 }
201 # endif /* ! HAVE_TM_GMTOFF */
202 #endif /* ! defined _LIBC */
203
204
205 #if !defined memset && !defined HAVE_MEMSET && !defined _LIBC
206 /* Some systems lack the `memset' function and we don't want to
207 introduce additional dependencies. */
208 /* The SGI compiler reportedly barfs on the trailing null
209 if we use a string constant as the initializer. 28 June 1997, rms. */
210 static const CHAR_T spaces[16] = /* " " */
211 {
212 L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),
213 L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' '),L_(' ')
214 };
215 static const CHAR_T zeroes[16] = /* "0000000000000000" */
216 {
217 L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),
218 L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0'),L_('0')
219 };
220
221 # define memset_space(P, Len) \
222 do { \
223 int _len = (Len); \
224 \
225 do \
226 { \
227 int _this = _len > 16 ? 16 : _len; \
228 (P) = MEMPCPY ((P), spaces, _this * sizeof (CHAR_T)); \
229 _len -= _this; \
230 } \
231 while (_len > 0); \
232 } while (0)
233
234 # define memset_zero(P, Len) \
235 do { \
236 int _len = (Len); \
237 \
238 do \
239 { \
240 int _this = _len > 16 ? 16 : _len; \
241 (P) = MEMPCPY ((P), zeroes, _this * sizeof (CHAR_T)); \
242 _len -= _this; \
243 } \
244 while (_len > 0); \
245 } while (0)
246 #else
247 # ifdef COMPILE_WIDE
248 # define memset_space(P, Len) (wmemset ((P), L' ', (Len)), (P) += (Len))
249 # define memset_zero(P, Len) (wmemset ((P), L'0', (Len)), (P) += (Len))
250 # else
251 # define memset_space(P, Len) (memset ((P), ' ', (Len)), (P) += (Len))
252 # define memset_zero(P, Len) (memset ((P), '0', (Len)), (P) += (Len))
253 # endif
254 #endif
255
256 #define add(n, f) \
257 do \
258 { \
259 int _n = (n); \
260 int _delta = width - _n; \
261 int _incr = _n + (_delta > 0 ? _delta : 0); \
262 if ((size_t) _incr >= maxsize - i) \
263 return 0; \
264 if (p) \
265 { \
266 if (_delta > 0) \
267 { \
268 if (pad == L_('0')) \
269 memset_zero (p, _delta); \
270 else \
271 memset_space (p, _delta); \
272 } \
273 f; \
274 p += _n; \
275 } \
276 i += _incr; \
277 } while (0)
278
279 #define cpy(n, s) \
280 add ((n), \
281 if (to_lowcase) \
282 memcpy_lowcase (p, (s), _n LOCALE_ARG); \
283 else if (to_uppcase) \
284 memcpy_uppcase (p, (s), _n LOCALE_ARG); \
285 else \
286 MEMCPY ((PTR) p, (const PTR) (s), _n))
287
288 #ifdef COMPILE_WIDE
289 # ifndef USE_IN_EXTENDED_LOCALE_MODEL
290 # undef __mbsrtowcs_l
291 # define __mbsrtowcs_l(d, s, l, st, loc) __mbsrtowcs (d, s, l, st)
292 # endif
293 # define widen(os, ws, l) \
294 { \
295 mbstate_t __st; \
296 const char *__s = os; \
297 memset (&__st, '\0', sizeof (__st)); \
298 l = __mbsrtowcs_l (NULL, &__s, 0, &__st, loc); \
299 ws = (wchar_t *) alloca ((l + 1) * sizeof (wchar_t)); \
300 (void) __mbsrtowcs_l (ws, &__s, l, &__st, loc); \
301 }
302 #endif
303
304
305 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
306 /* We use this code also for the extended locale handling where the
307 function gets as an additional argument the locale which has to be
308 used. To access the values we have to redefine the _NL_CURRENT
309 macro. */
310 # define strftime __strftime_l
311 # define wcsftime __wcsftime_l
312 # undef _NL_CURRENT
313 # define _NL_CURRENT(category, item) \
314 (current->values[_NL_ITEM_INDEX (item)].string)
315 # define LOCALE_ARG , loc
316 # define LOCALE_PARAM_DECL , __locale_t loc
317 # define HELPER_LOCALE_ARG , current
318 #else
319 # define LOCALE_ARG
320 # define LOCALE_PARAM_DECL
321 # ifdef _LIBC
322 # define HELPER_LOCALE_ARG , _NL_CURRENT_DATA (LC_TIME)
323 # else
324 # define HELPER_LOCALE_ARG
325 # endif
326 #endif
327
328 #ifdef COMPILE_WIDE
329 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
330 # define TOUPPER(Ch, L) __towupper_l (Ch, L)
331 # define TOLOWER(Ch, L) __towlower_l (Ch, L)
332 # else
333 # define TOUPPER(Ch, L) towupper (Ch)
334 # define TOLOWER(Ch, L) towlower (Ch)
335 # endif
336 #else
337 # ifdef _LIBC
338 # ifdef USE_IN_EXTENDED_LOCALE_MODEL
339 # define TOUPPER(Ch, L) __toupper_l (Ch, L)
340 # define TOLOWER(Ch, L) __tolower_l (Ch, L)
341 # else
342 # define TOUPPER(Ch, L) toupper (Ch)
343 # define TOLOWER(Ch, L) tolower (Ch)
344 # endif
345 # else
346 # define TOUPPER(Ch, L) (islower (Ch) ? toupper (Ch) : (Ch))
347 # define TOLOWER(Ch, L) (isupper (Ch) ? tolower (Ch) : (Ch))
348 # endif
349 #endif
350 /* We don't use `isdigit' here since the locale dependent
351 interpretation is not what we want here. We only need to accept
352 the arabic digits in the ASCII range. One day there is perhaps a
353 more reliable way to accept other sets of digits. */
354 #define ISDIGIT(Ch) ((unsigned int) (Ch) - L_('0') <= 9)
355
356 static CHAR_T *
357 memcpy_lowcase (CHAR_T *dest, const CHAR_T *src, size_t len LOCALE_PARAM_DECL)
358 {
359 while (len-- > 0)
360 dest[len] = TOLOWER ((UCHAR_T) src[len], loc);
361 return dest;
362 }
363
364 static CHAR_T *
365 memcpy_uppcase (CHAR_T *dest, const CHAR_T *src, size_t len LOCALE_PARAM_DECL)
366 {
367 while (len-- > 0)
368 dest[len] = TOUPPER ((UCHAR_T) src[len], loc);
369 return dest;
370 }
371
372
373 #if ! HAVE_TM_GMTOFF
374 /* Yield the difference between *A and *B,
375 measured in seconds, ignoring leap seconds. */
376 # define tm_diff ftime_tm_diff
377 static int
378 tm_diff (const struct tm *a, const struct tm *b)
379 {
380 /* Compute intervening leap days correctly even if year is negative.
381 Take care to avoid int overflow in leap day calculations,
382 but it's OK to assume that A and B are close to each other. */
383 int a4 = (a->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (a->tm_year & 3);
384 int b4 = (b->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (b->tm_year & 3);
385 int a100 = a4 / 25 - (a4 % 25 < 0);
386 int b100 = b4 / 25 - (b4 % 25 < 0);
387 int a400 = a100 >> 2;
388 int b400 = b100 >> 2;
389 int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400);
390 int years = a->tm_year - b->tm_year;
391 int days = (365 * years + intervening_leap_days
392 + (a->tm_yday - b->tm_yday));
393 return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour))
394 + (a->tm_min - b->tm_min))
395 + (a->tm_sec - b->tm_sec));
396 }
397 #endif /* ! HAVE_TM_GMTOFF */
398
399
400
401 /* The number of days from the first day of the first ISO week of this
402 year to the year day YDAY with week day WDAY. ISO weeks start on
403 Monday; the first ISO week has the year's first Thursday. YDAY may
404 be as small as YDAY_MINIMUM. */
405 #define ISO_WEEK_START_WDAY 1 /* Monday */
406 #define ISO_WEEK1_WDAY 4 /* Thursday */
407 #define YDAY_MINIMUM (-366)
408 static int iso_week_days (int, int);
409 #ifdef __GNUC__
410 __inline__
411 #endif
412 static int
413 iso_week_days (int yday, int wday)
414 {
415 /* Add enough to the first operand of % to make it nonnegative. */
416 int big_enough_multiple_of_7 = (-YDAY_MINIMUM / 7 + 2) * 7;
417 return (yday
418 - (yday - wday + ISO_WEEK1_WDAY + big_enough_multiple_of_7) % 7
419 + ISO_WEEK1_WDAY - ISO_WEEK_START_WDAY);
420 }
421
422
423 #if !(defined _NL_CURRENT || HAVE_STRFTIME)
424 static CHAR_T const weekday_name[][10] =
425 {
426 L_("Sunday"), L_("Monday"), L_("Tuesday"), L_("Wednesday"),
427 L_("Thursday"), L_("Friday"), L_("Saturday")
428 };
429 static CHAR_T const month_name[][10] =
430 {
431 L_("January"), L_("February"), L_("March"), L_("April"), L_("May"),
432 L_("June"), L_("July"), L_("August"), L_("September"), L_("October"),
433 L_("November"), L_("December")
434 };
435 #endif
436
437
438 /* When compiling this file, GNU applications can #define my_strftime
439 to a symbol (typically nstrftime) to get an extended strftime with
440 extra arguments UT and NS. */
441
442 #ifdef my_strftime
443 # define extra_args , ut, ns
444 # define extra_args_spec , int ut, int ns
445 #else
446 # ifdef COMPILE_WIDE
447 # define my_strftime wcsftime
448 # define nl_get_alt_digit _nl_get_walt_digit
449 # else
450 # define my_strftime strftime
451 # define nl_get_alt_digit _nl_get_alt_digit
452 # endif
453 # define extra_args
454 # define extra_args_spec
455 /* We don't have this information in general. */
456 # define ut 0
457 # define ns 0
458 #endif
459
460 #if !defined _LIBC && !defined(WINDOWSNT) && HAVE_TZNAME && HAVE_TZSET
461 /* Solaris 2.5 tzset sometimes modifies the storage returned by localtime.
462 Work around this bug by copying *tp before it might be munged. */
463 size_t
464 _strftime_copytm (CHAR_T *s, size_t maxsize, const CHAR_T *format,
465 const struct tm *tp extra_args_spec LOCALE_PARAM_DECL);
466 size_t
467 my_strftime (CHAR_T *s, size_t maxsize, const CHAR_T *format,
468 const struct tm *tp extra_args_spec)
469 {
470 struct tm tmcopy;
471 tmcopy = *tp;
472 return _strftime_copytm (s, maxsize, format, &tmcopy extra_args);
473 }
474 # undef my_strftime
475 # define my_strftime _strftime_copytm
476 #endif
477
478
479 /* Write information from TP into S according to the format
480 string FORMAT, writing no more that MAXSIZE characters
481 (including the terminating '\0') and returning number of
482 characters written. If S is NULL, nothing will be written
483 anywhere, so to determine how many characters would be
484 written, use NULL for S and (size_t) UINT_MAX for MAXSIZE. */
485 size_t
486 my_strftime (CHAR_T *s, size_t maxsize, const CHAR_T *format,
487 const struct tm *tp extra_args_spec LOCALE_PARAM_DECL)
488 {
489 #if defined _LIBC && defined USE_IN_EXTENDED_LOCALE_MODEL
490 struct locale_data *const current = loc->__locales[LC_TIME];
491 #endif
492
493 int hour12 = tp->tm_hour;
494 #ifdef _NL_CURRENT
495 /* We cannot make the following values variables since we must delay
496 the evaluation of these values until really needed since some
497 expressions might not be valid in every situation. The `struct tm'
498 might be generated by a strptime() call that initialized
499 only a few elements. Dereference the pointers only if the format
500 requires this. Then it is ok to fail if the pointers are invalid. */
501 # define a_wkday \
502 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABDAY_1) + tp->tm_wday))
503 # define f_wkday \
504 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(DAY_1) + tp->tm_wday))
505 # define a_month \
506 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ABMON_1) + tp->tm_mon))
507 # define f_month \
508 ((const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(MON_1) + tp->tm_mon))
509 # define ampm \
510 ((const CHAR_T *) _NL_CURRENT (LC_TIME, tp->tm_hour > 11 \
511 ? NLW(PM_STR) : NLW(AM_STR)))
512
513 # define aw_len STRLEN (a_wkday)
514 # define am_len STRLEN (a_month)
515 # define ap_len STRLEN (ampm)
516 #else
517 # if !HAVE_STRFTIME
518 # define f_wkday (weekday_name[tp->tm_wday])
519 # define f_month (month_name[tp->tm_mon])
520 # define a_wkday f_wkday
521 # define a_month f_month
522 # define ampm (L_("AMPM") + 2 * (tp->tm_hour > 11))
523
524 size_t aw_len = 3;
525 size_t am_len = 3;
526 size_t ap_len = 2;
527 # endif
528 #endif
529 const char *zone;
530 size_t i = 0;
531 CHAR_T *p = s;
532 const CHAR_T *f;
533 #if DO_MULTIBYTE && !defined COMPILE_WIDE
534 const char *format_end = NULL;
535 #endif
536
537 zone = NULL;
538 #if HAVE_TM_ZONE
539 /* The POSIX test suite assumes that setting
540 the environment variable TZ to a new value before calling strftime()
541 will influence the result (the %Z format) even if the information in
542 TP is computed with a totally different time zone.
543 This is bogus: though POSIX allows bad behavior like this,
544 POSIX does not require it. Do the right thing instead. */
545 zone = (const char *) tp->tm_zone;
546 #endif
547 #if HAVE_TZNAME
548 if (ut)
549 {
550 if (! (zone && *zone))
551 zone = "GMT";
552 }
553 else
554 {
555 /* POSIX.1 requires that local time zone information be used as
556 though strftime called tzset. */
557 # if HAVE_TZSET
558 tzset ();
559 # endif
560 }
561 #endif
562
563 if (hour12 > 12)
564 hour12 -= 12;
565 else
566 if (hour12 == 0)
567 hour12 = 12;
568
569 for (f = format; *f != '\0'; ++f)
570 {
571 int pad = 0; /* Padding for number ('-', '_', or 0). */
572 int modifier; /* Field modifier ('E', 'O', or 0). */
573 int digits; /* Max digits for numeric format. */
574 int number_value; /* Numeric value to be printed. */
575 int negative_number; /* 1 if the number is negative. */
576 const CHAR_T *subfmt;
577 CHAR_T *bufp;
578 CHAR_T buf[1 + (sizeof (int) < sizeof (time_t)
579 ? INT_STRLEN_BOUND (time_t)
580 : INT_STRLEN_BOUND (int))];
581 int width = -1;
582 int to_lowcase = 0;
583 int to_uppcase = 0;
584 int change_case = 0;
585 int format_char;
586
587 #if DO_MULTIBYTE && !defined COMPILE_WIDE
588 switch (*f)
589 {
590 case L_('%'):
591 break;
592
593 case L_('\b'): case L_('\t'): case L_('\n'):
594 case L_('\v'): case L_('\f'): case L_('\r'):
595 case L_(' '): case L_('!'): case L_('"'): case L_('#'): case L_('&'):
596 case L_('\''): case L_('('): case L_(')'): case L_('*'): case L_('+'):
597 case L_(','): case L_('-'): case L_('.'): case L_('/'): case L_('0'):
598 case L_('1'): case L_('2'): case L_('3'): case L_('4'): case L_('5'):
599 case L_('6'): case L_('7'): case L_('8'): case L_('9'): case L_(':'):
600 case L_(';'): case L_('<'): case L_('='): case L_('>'): case L_('?'):
601 case L_('A'): case L_('B'): case L_('C'): case L_('D'): case L_('E'):
602 case L_('F'): case L_('G'): case L_('H'): case L_('I'): case L_('J'):
603 case L_('K'): case L_('L'): case L_('M'): case L_('N'): case L_('O'):
604 case L_('P'): case L_('Q'): case L_('R'): case L_('S'): case L_('T'):
605 case L_('U'): case L_('V'): case L_('W'): case L_('X'): case L_('Y'):
606 case L_('Z'): case L_('['): case L_('\\'): case L_(']'): case L_('^'):
607 case L_('_'): case L_('a'): case L_('b'): case L_('c'): case L_('d'):
608 case L_('e'): case L_('f'): case L_('g'): case L_('h'): case L_('i'):
609 case L_('j'): case L_('k'): case L_('l'): case L_('m'): case L_('n'):
610 case L_('o'): case L_('p'): case L_('q'): case L_('r'): case L_('s'):
611 case L_('t'): case L_('u'): case L_('v'): case L_('w'): case L_('x'):
612 case L_('y'): case L_('z'): case L_('{'): case L_('|'): case L_('}'):
613 case L_('~'):
614 /* The C Standard requires these 98 characters (plus '%') to
615 be in the basic execution character set. None of these
616 characters can start a multibyte sequence, so they need
617 not be analyzed further. */
618 add (1, *p = *f);
619 continue;
620
621 default:
622 /* Copy this multibyte sequence until we reach its end, find
623 an error, or come back to the initial shift state. */
624 {
625 mbstate_t mbstate = mbstate_zero;
626 size_t len = 0;
627 size_t fsize;
628
629 if (! format_end)
630 format_end = f + strlen (f) + 1;
631 fsize = format_end - f;
632
633 do
634 {
635 size_t bytes = mbrlen (f + len, fsize - len, &mbstate);
636
637 if (bytes == 0)
638 break;
639
640 if (bytes == (size_t) -2)
641 {
642 len += strlen (f + len);
643 break;
644 }
645
646 if (bytes == (size_t) -1)
647 {
648 len++;
649 break;
650 }
651
652 len += bytes;
653 }
654 while (! mbsinit (&mbstate));
655
656 cpy (len, f);
657 f += len - 1;
658 continue;
659 }
660 }
661
662 #else /* ! DO_MULTIBYTE */
663
664 /* Either multibyte encodings are not supported, they are
665 safe for formats, so any non-'%' byte can be copied through,
666 or this is the wide character version. */
667 if (*f != L_('%'))
668 {
669 add (1, *p = *f);
670 continue;
671 }
672
673 #endif /* ! DO_MULTIBYTE */
674
675 /* Check for flags that can modify a format. */
676 while (1)
677 {
678 switch (*++f)
679 {
680 /* This influences the number formats. */
681 case L_('_'):
682 case L_('-'):
683 case L_('0'):
684 pad = *f;
685 continue;
686
687 /* This changes textual output. */
688 case L_('^'):
689 to_uppcase = 1;
690 continue;
691 case L_('#'):
692 change_case = 1;
693 continue;
694
695 default:
696 break;
697 }
698 break;
699 }
700
701 /* As a GNU extension we allow to specify the field width. */
702 if (ISDIGIT (*f))
703 {
704 width = 0;
705 do
706 {
707 if (width > INT_MAX / 10
708 || (width == INT_MAX / 10 && *f - L_('0') > INT_MAX % 10))
709 /* Avoid overflow. */
710 width = INT_MAX;
711 else
712 {
713 width *= 10;
714 width += *f - L_('0');
715 }
716 ++f;
717 }
718 while (ISDIGIT (*f));
719 }
720
721 /* Check for modifiers. */
722 switch (*f)
723 {
724 case L_('E'):
725 case L_('O'):
726 modifier = *f++;
727 break;
728
729 default:
730 modifier = 0;
731 break;
732 }
733
734 /* Now do the specified format. */
735 format_char = *f;
736 switch (format_char)
737 {
738 #define DO_NUMBER(d, v) \
739 digits = d > width ? d : width; \
740 number_value = v; goto do_number
741 #define DO_NUMBER_SPACEPAD(d, v) \
742 digits = d > width ? d : width; \
743 number_value = v; goto do_number_spacepad
744
745 case L_('%'):
746 if (modifier != 0)
747 goto bad_format;
748 add (1, *p = *f);
749 break;
750
751 case L_('a'):
752 if (modifier != 0)
753 goto bad_format;
754 if (change_case)
755 {
756 to_uppcase = 1;
757 to_lowcase = 0;
758 }
759 #if defined _NL_CURRENT || !HAVE_STRFTIME
760 cpy (aw_len, a_wkday);
761 break;
762 #else
763 goto underlying_strftime;
764 #endif
765
766 case 'A':
767 if (modifier != 0)
768 goto bad_format;
769 if (change_case)
770 {
771 to_uppcase = 1;
772 to_lowcase = 0;
773 }
774 #if defined _NL_CURRENT || !HAVE_STRFTIME
775 cpy (STRLEN (f_wkday), f_wkday);
776 break;
777 #else
778 goto underlying_strftime;
779 #endif
780
781 case L_('b'):
782 case L_('h'):
783 if (change_case)
784 {
785 to_uppcase = 1;
786 to_lowcase = 0;
787 }
788 if (modifier != 0)
789 goto bad_format;
790 #if defined _NL_CURRENT || !HAVE_STRFTIME
791 cpy (am_len, a_month);
792 break;
793 #else
794 goto underlying_strftime;
795 #endif
796
797 case L_('B'):
798 if (modifier != 0)
799 goto bad_format;
800 if (change_case)
801 {
802 to_uppcase = 1;
803 to_lowcase = 0;
804 }
805 #if defined _NL_CURRENT || !HAVE_STRFTIME
806 cpy (STRLEN (f_month), f_month);
807 break;
808 #else
809 goto underlying_strftime;
810 #endif
811
812 case L_('c'):
813 if (modifier == L_('O'))
814 goto bad_format;
815 #ifdef _NL_CURRENT
816 if (! (modifier == 'E'
817 && (*(subfmt =
818 (const CHAR_T *) _NL_CURRENT (LC_TIME,
819 NLW(ERA_D_T_FMT)))
820 != '\0')))
821 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_T_FMT));
822 #else
823 # if HAVE_STRFTIME
824 goto underlying_strftime;
825 # else
826 subfmt = L_("%a %b %e %H:%M:%S %Y");
827 # endif
828 #endif
829
830 subformat:
831 {
832 CHAR_T *old_start = p;
833 size_t len = my_strftime (NULL, (size_t) -1, subfmt,
834 tp extra_args LOCALE_ARG);
835 add (len, my_strftime (p, maxsize - i, subfmt,
836 tp extra_args LOCALE_ARG));
837
838 if (to_uppcase)
839 while (old_start < p)
840 {
841 *old_start = TOUPPER ((UCHAR_T) *old_start, loc);
842 ++old_start;
843 }
844 }
845 break;
846
847 #if HAVE_STRFTIME && ! (defined _NL_CURRENT && HAVE_STRUCT_ERA_ENTRY)
848 underlying_strftime:
849 {
850 /* The relevant information is available only via the
851 underlying strftime implementation, so use that. */
852 char ufmt[4];
853 char *u = ufmt;
854 char ubuf[1024]; /* enough for any single format in practice */
855 size_t len;
856 /* Make sure we're calling the actual underlying strftime.
857 In some cases, config.h contains something like
858 "#define strftime rpl_strftime". */
859 # ifdef strftime
860 # undef strftime
861 size_t strftime ();
862 # endif
863
864 #ifdef STRFTIME_NO_POSIX2
865 /* Some system libraries do not support the POSIX.2 extensions.
866 In those cases, convert %h to %b, and strip modifiers. */
867 modifier = 0;
868 if (format_char == 'h')
869 format_char = 'b';
870 #endif
871 *u++ = '%';
872 if (modifier != 0)
873 *u++ = modifier;
874 *u++ = format_char;
875 *u = '\0';
876 len = strftime (ubuf, sizeof ubuf, ufmt, tp);
877 if (len == 0 && ubuf[0] != '\0')
878 return 0;
879 cpy (len, ubuf);
880 }
881 break;
882 #endif
883
884 case L_('C'):
885 if (modifier == L_('O'))
886 goto bad_format;
887 if (modifier == L_('E'))
888 {
889 #if HAVE_STRUCT_ERA_ENTRY
890 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
891 if (era)
892 {
893 # ifdef COMPILE_WIDE
894 size_t len = __wcslen (era->era_wname);
895 cpy (len, era->era_wname);
896 # else
897 size_t len = strlen (era->era_name);
898 cpy (len, era->era_name);
899 # endif
900 break;
901 }
902 #else
903 # if HAVE_STRFTIME
904 goto underlying_strftime;
905 # endif
906 #endif
907 }
908
909 {
910 int year = tp->tm_year + TM_YEAR_BASE;
911 DO_NUMBER (1, year / 100 - (year % 100 < 0));
912 }
913
914 case L_('x'):
915 if (modifier == L_('O'))
916 goto bad_format;
917 #ifdef _NL_CURRENT
918 if (! (modifier == L_('E')
919 && (*(subfmt =
920 (const CHAR_T *)_NL_CURRENT (LC_TIME, NLW(ERA_D_FMT)))
921 != L_('\0'))))
922 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_FMT));
923 goto subformat;
924 #else
925 # if HAVE_STRFTIME
926 goto underlying_strftime;
927 # else
928 /* Fall through. */
929 # endif
930 #endif
931 case L_('D'):
932 if (modifier != 0)
933 goto bad_format;
934 subfmt = L_("%m/%d/%y");
935 goto subformat;
936
937 case L_('d'):
938 if (modifier == L_('E'))
939 goto bad_format;
940
941 DO_NUMBER (2, tp->tm_mday);
942
943 case L_('e'):
944 if (modifier == L_('E'))
945 goto bad_format;
946
947 DO_NUMBER_SPACEPAD (2, tp->tm_mday);
948
949 /* All numeric formats set DIGITS and NUMBER_VALUE and then
950 jump to one of these two labels. */
951
952 do_number_spacepad:
953 /* Force `_' flag unless overridden by `0' or `-' flag. */
954 if (pad != L_('0') && pad != L_('-'))
955 pad = L_('_');
956
957 do_number:
958 /* Format the number according to the MODIFIER flag. */
959
960 if (modifier == L_('O') && 0 <= number_value)
961 {
962 #ifdef _NL_CURRENT
963 /* Get the locale specific alternate representation of
964 the number NUMBER_VALUE. If none exist NULL is returned. */
965 const CHAR_T *cp = nl_get_alt_digit (number_value
966 HELPER_LOCALE_ARG);
967
968 if (cp != NULL)
969 {
970 size_t digitlen = STRLEN (cp);
971 if (digitlen != 0)
972 {
973 cpy (digitlen, cp);
974 break;
975 }
976 }
977 #else
978 # if HAVE_STRFTIME
979 goto underlying_strftime;
980 # endif
981 #endif
982 }
983 {
984 unsigned int u = number_value;
985
986 bufp = buf + sizeof (buf) / sizeof (buf[0]);
987 negative_number = number_value < 0;
988
989 if (negative_number)
990 u = -u;
991
992 do
993 *--bufp = u % 10 + L_('0');
994 while ((u /= 10) != 0);
995 }
996
997 do_number_sign_and_padding:
998 if (negative_number)
999 *--bufp = L_('-');
1000
1001 if (pad != L_('-'))
1002 {
1003 int padding = digits - (buf + (sizeof (buf) / sizeof (buf[0]))
1004 - bufp);
1005
1006 if (padding > 0)
1007 {
1008 if (pad == L_('_'))
1009 {
1010 if ((size_t) padding >= maxsize - i)
1011 return 0;
1012
1013 if (p)
1014 memset_space (p, padding);
1015 i += padding;
1016 width = width > padding ? width - padding : 0;
1017 }
1018 else
1019 {
1020 if ((size_t) digits >= maxsize - i)
1021 return 0;
1022
1023 if (negative_number)
1024 {
1025 ++bufp;
1026
1027 if (p)
1028 *p++ = L_('-');
1029 ++i;
1030 }
1031
1032 if (p)
1033 memset_zero (p, padding);
1034 i += padding;
1035 width = 0;
1036 }
1037 }
1038 }
1039
1040 cpy (buf + sizeof (buf) / sizeof (buf[0]) - bufp, bufp);
1041 break;
1042
1043 case L_('F'):
1044 if (modifier != 0)
1045 goto bad_format;
1046 subfmt = L_("%Y-%m-%d");
1047 goto subformat;
1048
1049 case L_('H'):
1050 if (modifier == L_('E'))
1051 goto bad_format;
1052
1053 DO_NUMBER (2, tp->tm_hour);
1054
1055 case L_('I'):
1056 if (modifier == L_('E'))
1057 goto bad_format;
1058
1059 DO_NUMBER (2, hour12);
1060
1061 case L_('k'): /* GNU extension. */
1062 if (modifier == L_('E'))
1063 goto bad_format;
1064
1065 DO_NUMBER_SPACEPAD (2, tp->tm_hour);
1066
1067 case L_('l'): /* GNU extension. */
1068 if (modifier == L_('E'))
1069 goto bad_format;
1070
1071 DO_NUMBER_SPACEPAD (2, hour12);
1072
1073 case L_('j'):
1074 if (modifier == L_('E'))
1075 goto bad_format;
1076
1077 DO_NUMBER (3, 1 + tp->tm_yday);
1078
1079 case L_('M'):
1080 if (modifier == L_('E'))
1081 goto bad_format;
1082
1083 DO_NUMBER (2, tp->tm_min);
1084
1085 case L_('m'):
1086 if (modifier == L_('E'))
1087 goto bad_format;
1088
1089 DO_NUMBER (2, tp->tm_mon + 1);
1090
1091 #ifndef _LIBC
1092 case L_('N'): /* GNU extension. */
1093 if (modifier == L_('E'))
1094 goto bad_format;
1095
1096 number_value = ns;
1097 if (width != -1)
1098 {
1099 /* Take an explicit width less than 9 as a precision. */
1100 int j;
1101 for (j = width; j < 9; j++)
1102 number_value /= 10;
1103 }
1104
1105 DO_NUMBER (9, number_value);
1106 #endif
1107
1108 case L_('n'):
1109 add (1, *p = L_('\n'));
1110 break;
1111
1112 case L_('P'):
1113 to_lowcase = 1;
1114 #if !defined _NL_CURRENT && HAVE_STRFTIME
1115 format_char = L_('p');
1116 #endif
1117 /* FALLTHROUGH */
1118
1119 case L_('p'):
1120 if (change_case)
1121 {
1122 to_uppcase = 0;
1123 to_lowcase = 1;
1124 }
1125 #if defined _NL_CURRENT || !HAVE_STRFTIME
1126 cpy (ap_len, ampm);
1127 break;
1128 #else
1129 goto underlying_strftime;
1130 #endif
1131
1132 case L_('R'):
1133 subfmt = L_("%H:%M");
1134 goto subformat;
1135
1136 case L_('r'):
1137 #ifdef _NL_CURRENT
1138 if (*(subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME,
1139 NLW(T_FMT_AMPM)))
1140 == L_('\0'))
1141 #endif
1142 subfmt = L_("%I:%M:%S %p");
1143 goto subformat;
1144
1145 case L_('S'):
1146 if (modifier == L_('E'))
1147 goto bad_format;
1148
1149 DO_NUMBER (2, tp->tm_sec);
1150
1151 case L_('s'): /* GNU extension. */
1152 {
1153 struct tm ltm;
1154 time_t t;
1155
1156 ltm = *tp;
1157 t = mktime (&ltm);
1158
1159 /* Generate string value for T using time_t arithmetic;
1160 this works even if sizeof (long) < sizeof (time_t). */
1161
1162 bufp = buf + sizeof (buf) / sizeof (buf[0]);
1163 negative_number = t < 0;
1164
1165 do
1166 {
1167 int d = t % 10;
1168 t /= 10;
1169
1170 if (negative_number)
1171 {
1172 d = -d;
1173
1174 /* Adjust if division truncates to minus infinity. */
1175 if (0 < -1 % 10 && d < 0)
1176 {
1177 t++;
1178 d += 10;
1179 }
1180 }
1181
1182 *--bufp = d + L_('0');
1183 }
1184 while (t != 0);
1185
1186 digits = 1;
1187 goto do_number_sign_and_padding;
1188 }
1189
1190 case L_('X'):
1191 if (modifier == L_('O'))
1192 goto bad_format;
1193 #ifdef _NL_CURRENT
1194 if (! (modifier == L_('E')
1195 && (*(subfmt =
1196 (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ERA_T_FMT)))
1197 != L_('\0'))))
1198 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(T_FMT));
1199 goto subformat;
1200 #else
1201 # if HAVE_STRFTIME
1202 goto underlying_strftime;
1203 # else
1204 /* Fall through. */
1205 # endif
1206 #endif
1207 case L_('T'):
1208 subfmt = L_("%H:%M:%S");
1209 goto subformat;
1210
1211 case L_('t'):
1212 add (1, *p = L_('\t'));
1213 break;
1214
1215 case L_('u'):
1216 DO_NUMBER (1, (tp->tm_wday - 1 + 7) % 7 + 1);
1217
1218 case L_('U'):
1219 if (modifier == L_('E'))
1220 goto bad_format;
1221
1222 DO_NUMBER (2, (tp->tm_yday - tp->tm_wday + 7) / 7);
1223
1224 case L_('V'):
1225 case L_('g'):
1226 case L_('G'):
1227 if (modifier == L_('E'))
1228 goto bad_format;
1229 {
1230 int year = tp->tm_year + TM_YEAR_BASE;
1231 int days = iso_week_days (tp->tm_yday, tp->tm_wday);
1232
1233 if (days < 0)
1234 {
1235 /* This ISO week belongs to the previous year. */
1236 year--;
1237 days = iso_week_days (tp->tm_yday + (365 + __isleap (year)),
1238 tp->tm_wday);
1239 }
1240 else
1241 {
1242 int d = iso_week_days (tp->tm_yday - (365 + __isleap (year)),
1243 tp->tm_wday);
1244 if (0 <= d)
1245 {
1246 /* This ISO week belongs to the next year. */
1247 year++;
1248 days = d;
1249 }
1250 }
1251
1252 switch (*f)
1253 {
1254 case L_('g'):
1255 DO_NUMBER (2, (year % 100 + 100) % 100);
1256
1257 case L_('G'):
1258 DO_NUMBER (1, year);
1259
1260 default:
1261 DO_NUMBER (2, days / 7 + 1);
1262 }
1263 }
1264
1265 case L_('W'):
1266 if (modifier == L_('E'))
1267 goto bad_format;
1268
1269 DO_NUMBER (2, (tp->tm_yday - (tp->tm_wday - 1 + 7) % 7 + 7) / 7);
1270
1271 case L_('w'):
1272 if (modifier == L_('E'))
1273 goto bad_format;
1274
1275 DO_NUMBER (1, tp->tm_wday);
1276
1277 case L_('Y'):
1278 if (modifier == 'E')
1279 {
1280 #if HAVE_STRUCT_ERA_ENTRY
1281 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
1282 if (era)
1283 {
1284 # ifdef COMPILE_WIDE
1285 subfmt = era->era_wformat;
1286 # else
1287 subfmt = era->era_format;
1288 # endif
1289 goto subformat;
1290 }
1291 #else
1292 # if HAVE_STRFTIME
1293 goto underlying_strftime;
1294 # endif
1295 #endif
1296 }
1297 if (modifier == L_('O'))
1298 goto bad_format;
1299 else
1300 DO_NUMBER (1, tp->tm_year + TM_YEAR_BASE);
1301
1302 case L_('y'):
1303 if (modifier == L_('E'))
1304 {
1305 #if HAVE_STRUCT_ERA_ENTRY
1306 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
1307 if (era)
1308 {
1309 int delta = tp->tm_year - era->start_date[0];
1310 DO_NUMBER (1, (era->offset
1311 + delta * era->absolute_direction));
1312 }
1313 #else
1314 # if HAVE_STRFTIME
1315 goto underlying_strftime;
1316 # endif
1317 #endif
1318 }
1319 DO_NUMBER (2, (tp->tm_year % 100 + 100) % 100);
1320
1321 case L_('Z'):
1322 if (change_case)
1323 {
1324 to_uppcase = 0;
1325 to_lowcase = 1;
1326 }
1327
1328 #if HAVE_TZNAME
1329 /* The tzset() call might have changed the value. */
1330 if (!(zone && *zone) && tp->tm_isdst >= 0)
1331 zone = tzname[tp->tm_isdst];
1332 #endif
1333 if (! zone)
1334 zone = "";
1335
1336 #ifdef COMPILE_WIDE
1337 {
1338 /* The zone string is always given in multibyte form. We have
1339 to transform it first. */
1340 wchar_t *wczone;
1341 size_t len;
1342 widen (zone, wczone, len);
1343 cpy (len, wczone);
1344 }
1345 #else
1346 cpy (strlen (zone), zone);
1347 #endif
1348 break;
1349
1350 case L_('z'):
1351 if (tp->tm_isdst < 0)
1352 break;
1353
1354 {
1355 int diff;
1356 #if HAVE_TM_GMTOFF
1357 diff = tp->tm_gmtoff;
1358 #else
1359 if (ut)
1360 diff = 0;
1361 else
1362 {
1363 struct tm gtm;
1364 struct tm ltm;
1365 time_t lt;
1366
1367 ltm = *tp;
1368 lt = mktime (&ltm);
1369
1370 if (lt == (time_t) -1)
1371 {
1372 /* mktime returns -1 for errors, but -1 is also a
1373 valid time_t value. Check whether an error really
1374 occurred. */
1375 struct tm tm;
1376
1377 if (! my_strftime_localtime_r (&lt, &tm)
1378 || ((ltm.tm_sec ^ tm.tm_sec)
1379 | (ltm.tm_min ^ tm.tm_min)
1380 | (ltm.tm_hour ^ tm.tm_hour)
1381 | (ltm.tm_mday ^ tm.tm_mday)
1382 | (ltm.tm_mon ^ tm.tm_mon)
1383 | (ltm.tm_year ^ tm.tm_year)))
1384 break;
1385 }
1386
1387 if (! my_strftime_gmtime_r (&lt, &gtm))
1388 break;
1389
1390 diff = tm_diff (&ltm, &gtm);
1391 }
1392 #endif
1393
1394 if (diff < 0)
1395 {
1396 add (1, *p = L_('-'));
1397 diff = -diff;
1398 }
1399 else
1400 add (1, *p = L_('+'));
1401
1402 diff /= 60;
1403 DO_NUMBER (4, (diff / 60) * 100 + diff % 60);
1404 }
1405
1406 case L_('\0'): /* GNU extension: % at end of format. */
1407 --f;
1408 /* Fall through. */
1409 default:
1410 /* Unknown format; output the format, including the '%',
1411 since this is most likely the right thing to do if a
1412 multibyte string has been misparsed. */
1413 bad_format:
1414 {
1415 int flen;
1416 for (flen = 1; f[1 - flen] != L_('%'); flen++)
1417 continue;
1418 cpy (flen, &f[1 - flen]);
1419 }
1420 break;
1421 }
1422 }
1423
1424 if (p && maxsize != 0)
1425 *p = L_('\0');
1426 return i;
1427 }
1428 #ifdef _LIBC
1429 libc_hidden_def (my_strftime)
1430 #endif
1431
1432
1433 #ifdef emacs
1434 #undef ut
1435 /* For Emacs we have a separate interface which corresponds to the normal
1436 strftime function plus the ut argument, but without the ns argument. */
1437 size_t
1438 emacs_strftimeu (char *s, size_t maxsize, const char *format,
1439 const struct tm *tp, int ut)
1440 {
1441 return my_strftime (s, maxsize, format, tp, ut, 0);
1442 }
1443 #endif
1444
Unnamed repository; edit this file 'description' to name the repository.