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