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