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