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