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 digits = d > width ? d : width; \
720 number_value = v; goto do_number
721#define DO_NUMBER_SPACEPAD(d, v) \
722 digits = d > width ? d : width; \
723 number_value = v; goto do_number_spacepad
724
725 case L_('%'):
726 if (modifier != 0)
727 goto bad_format;
728 add (1, *p = *f);
729 break;
730
731 case L_('a'):
732 if (modifier != 0)
733 goto bad_format;
734 if (change_case)
735 {
736 to_uppcase = 1;
737 to_lowcase = 0;
738 }
739#if defined _NL_CURRENT || !HAVE_STRFTIME
740 cpy (aw_len, a_wkday);
741 break;
742#else
743 goto underlying_strftime;
744#endif
745
746 case 'A':
747 if (modifier != 0)
748 goto bad_format;
749 if (change_case)
750 {
751 to_uppcase = 1;
752 to_lowcase = 0;
753 }
754#if defined _NL_CURRENT || !HAVE_STRFTIME
755 cpy (STRLEN (f_wkday), f_wkday);
756 break;
757#else
758 goto underlying_strftime;
759#endif
760
761 case L_('b'):
762 case L_('h'):
763 if (change_case)
764 {
765 to_uppcase = 1;
766 to_lowcase = 0;
767 }
768 if (modifier != 0)
769 goto bad_format;
770#if defined _NL_CURRENT || !HAVE_STRFTIME
771 cpy (am_len, a_month);
772 break;
773#else
774 goto underlying_strftime;
775#endif
776
777 case L_('B'):
778 if (modifier != 0)
779 goto bad_format;
780 if (change_case)
781 {
782 to_uppcase = 1;
783 to_lowcase = 0;
784 }
785#if defined _NL_CURRENT || !HAVE_STRFTIME
786 cpy (STRLEN (f_month), f_month);
787 break;
788#else
789 goto underlying_strftime;
790#endif
791
792 case L_('c'):
793 if (modifier == L_('O'))
794 goto bad_format;
795#ifdef _NL_CURRENT
796 if (! (modifier == 'E'
797 && (*(subfmt =
798 (const CHAR_T *) _NL_CURRENT (LC_TIME,
799 NLW(ERA_D_T_FMT)))
800 != '\0')))
801 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_T_FMT));
802#else
803# if HAVE_STRFTIME
804 goto underlying_strftime;
805# else
806 subfmt = L_("%a %b %e %H:%M:%S %Y");
807# endif
808#endif
809
810 subformat:
811 {
812 CHAR_T *old_start = p;
813 size_t len = __strftime_internal (NULL, (size_t) -1, subfmt,
814 tp, tzset_called ut_argument
815 LOCALE_ARG);
816 add (len, __strftime_internal (p, maxsize - i, subfmt,
817 tp, tzset_called ut_argument
818 LOCALE_ARG));
819
820 if (to_uppcase)
821 while (old_start < p)
822 {
823 *old_start = TOUPPER ((UCHAR_T) *old_start, loc);
824 ++old_start;
825 }
826 }
827 break;
828
829#if HAVE_STRFTIME && ! (defined _NL_CURRENT && HAVE_STRUCT_ERA_ENTRY)
830 underlying_strftime:
831 {
832 /* The relevant information is available only via the
833 underlying strftime implementation, so use that. */
834 char ufmt[4];
835 char *u = ufmt;
836 char ubuf[1024]; /* enough for any single format in practice */
837 size_t len;
838 /* Make sure we're calling the actual underlying strftime.
839 In some cases, config.h contains something like
840 "#define strftime rpl_strftime". */
841# ifdef strftime
842# undef strftime
843 size_t strftime ();
844# endif
845
846 *u++ = '%';
847 if (modifier != 0)
848 *u++ = modifier;
849 *u++ = format_char;
850 *u = '\0';
851 len = strftime (ubuf, sizeof ubuf, ufmt, tp);
852 if (len == 0 && ubuf[0] != '\0')
853 return 0;
854 cpy (len, ubuf);
855 }
856 break;
857#endif
858
859 case L_('C'):
860 if (modifier == L_('E'))
861 {
862#if HAVE_STRUCT_ERA_ENTRY
863 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
864 if (era)
865 {
866# ifdef COMPILE_WIDE
867 size_t len = __wcslen (era->era_wname);
868 cpy (len, era->era_wname);
869# else
870 size_t len = strlen (era->era_name);
871 cpy (len, era->era_name);
872# endif
873 break;
874 }
875#else
876# if HAVE_STRFTIME
877 goto underlying_strftime;
878# endif
879#endif
880 }
881
882 {
883 int year = tp->tm_year + TM_YEAR_BASE;
884 DO_NUMBER (1, year / 100 - (year % 100 < 0));
885 }
886
887 case L_('x'):
888 if (modifier == L_('O'))
889 goto bad_format;
890#ifdef _NL_CURRENT
891 if (! (modifier == L_('E')
892 && (*(subfmt =
893 (const CHAR_T *)_NL_CURRENT (LC_TIME, NLW(ERA_D_FMT)))
894 != L_('\0'))))
895 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(D_FMT));
896 goto subformat;
897#else
898# if HAVE_STRFTIME
899 goto underlying_strftime;
900# else
901 /* Fall through. */
902# endif
903#endif
904 case L_('D'):
905 if (modifier != 0)
906 goto bad_format;
907 subfmt = L_("%m/%d/%y");
908 goto subformat;
909
910 case L_('d'):
911 if (modifier == L_('E'))
912 goto bad_format;
913
914 DO_NUMBER (2, tp->tm_mday);
915
916 case L_('e'):
917 if (modifier == L_('E'))
918 goto bad_format;
919
920 DO_NUMBER_SPACEPAD (2, tp->tm_mday);
921
922 /* All numeric formats set DIGITS and NUMBER_VALUE and then
923 jump to one of these two labels. */
924
925 do_number_spacepad:
926 /* Force `_' flag unless overwritten by `0' or '-' flag. */
927 if (pad != L_('0') && pad != L_('-'))
928 pad = L_('_');
929
930 do_number:
931 /* Format the number according to the MODIFIER flag. */
932
933 if (modifier == L_('O') && 0 <= number_value)
934 {
935#ifdef _NL_CURRENT
936 /* Get the locale specific alternate representation of
937 the number NUMBER_VALUE. If none exist NULL is returned. */
938 const CHAR_T *cp = nl_get_alt_digit (number_value
939 HELPER_LOCALE_ARG);
940
941 if (cp != NULL)
942 {
943 size_t digitlen = STRLEN (cp);
944 if (digitlen != 0)
945 {
946 cpy (digitlen, cp);
947 break;
948 }
949 }
950#else
951# if HAVE_STRFTIME
952 goto underlying_strftime;
953# endif
954#endif
955 }
956 {
957 unsigned int u = number_value;
958
959 bufp = buf + sizeof (buf) / sizeof (buf[0]);
960 negative_number = number_value < 0;
961
962 if (negative_number)
963 u = -u;
964
965 do
966 *--bufp = u % 10 + L_('0');
967 while ((u /= 10) != 0);
968 }
969
970 do_number_sign_and_padding:
971 if (negative_number)
972 *--bufp = L_('-');
973
974 if (pad != L_('-'))
975 {
976 int padding = digits - (buf + (sizeof (buf) / sizeof (buf[0]))
977 - bufp);
978
979 if (padding > 0)
980 {
981 if (pad == L_('_'))
982 {
983 if ((size_t) padding >= maxsize - i)
984 return 0;
985
986 if (p)
987 memset_space (p, padding);
988 i += padding;
989 width = width > padding ? width - padding : 0;
990 }
991 else
992 {
993 if ((size_t) digits >= maxsize - i)
994 return 0;
995
996 if (negative_number)
997 {
998 ++bufp;
999
1000 if (p)
1001 *p++ = L_('-');
1002 ++i;
1003 }
1004
1005 if (p)
1006 memset_zero (p, padding);
1007 i += padding;
1008 width = 0;
1009 }
1010 }
1011 }
1012
1013 cpy (buf + sizeof (buf) / sizeof (buf[0]) - bufp, bufp);
1014 break;
1015
1016 case L_('F'):
1017 if (modifier != 0)
1018 goto bad_format;
1019 subfmt = L_("%Y-%m-%d");
1020 goto subformat;
1021
1022 case L_('H'):
1023 if (modifier == L_('E'))
1024 goto bad_format;
1025
1026 DO_NUMBER (2, tp->tm_hour);
1027
1028 case L_('I'):
1029 if (modifier == L_('E'))
1030 goto bad_format;
1031
1032 DO_NUMBER (2, hour12);
1033
1034 case L_('k'): /* GNU extension. */
1035 if (modifier == L_('E'))
1036 goto bad_format;
1037
1038 DO_NUMBER_SPACEPAD (2, tp->tm_hour);
1039
1040 case L_('l'): /* GNU extension. */
1041 if (modifier == L_('E'))
1042 goto bad_format;
1043
1044 DO_NUMBER_SPACEPAD (2, hour12);
1045
1046 case L_('j'):
1047 if (modifier == L_('E'))
1048 goto bad_format;
1049
1050 DO_NUMBER (3, 1 + tp->tm_yday);
1051
1052 case L_('M'):
1053 if (modifier == L_('E'))
1054 goto bad_format;
1055
1056 DO_NUMBER (2, tp->tm_min);
1057
1058 case L_('m'):
1059 if (modifier == L_('E'))
1060 goto bad_format;
1061
1062 DO_NUMBER (2, tp->tm_mon + 1);
1063
1064 case L_('n'):
1065 add (1, *p = L_('\n'));
1066 break;
1067
1068 case L_('P'):
1069 to_lowcase = 1;
1070#if !defined _NL_CURRENT && HAVE_STRFTIME
1071 format_char = L_('p');
1072#endif
1073 /* FALLTHROUGH */
1074
1075 case L_('p'):
1076 if (change_case)
1077 {
1078 to_uppcase = 0;
1079 to_lowcase = 1;
1080 }
1081#if defined _NL_CURRENT || !HAVE_STRFTIME
1082 cpy (ap_len, ampm);
1083 break;
1084#else
1085 goto underlying_strftime;
1086#endif
1087
1088 case L_('R'):
1089 subfmt = L_("%H:%M");
1090 goto subformat;
1091
1092 case L_('r'):
1093#if !defined _NL_CURRENT && HAVE_STRFTIME
1094 goto underlying_strftime;
1095#else
1096# ifdef _NL_CURRENT
1097 if (*(subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME,
1098 NLW(T_FMT_AMPM)))
1099 == L_('\0'))
1100# endif
1101 subfmt = L_("%I:%M:%S %p");
1102 goto subformat;
1103#endif
1104
1105 case L_('S'):
1106 if (modifier == L_('E'))
1107 goto bad_format;
1108
1109 DO_NUMBER (2, tp->tm_sec);
1110
1111 case L_('s'): /* GNU extension. */
1112 {
1113 struct tm ltm;
1114 time_t t;
1115
1116 ltm = *tp;
1117 t = mktime (&ltm);
1118
1119 /* Generate string value for T using time_t arithmetic;
1120 this works even if sizeof (long) < sizeof (time_t). */
1121
1122 bufp = buf + sizeof (buf) / sizeof (buf[0]);
1123 negative_number = t < 0;
1124
1125 do
1126 {
1127 int d = t % 10;
1128 t /= 10;
1129
1130 if (negative_number)
1131 {
1132 d = -d;
1133
1134 /* Adjust if division truncates to minus infinity. */
1135 if (0 < -1 % 10 && d < 0)
1136 {
1137 t++;
1138 d += 10;
1139 }
1140 }
1141
1142 *--bufp = d + L_('0');
1143 }
1144 while (t != 0);
1145
1146 digits = 1;
1147 goto do_number_sign_and_padding;
1148 }
1149
1150 case L_('X'):
1151 if (modifier == L_('O'))
1152 goto bad_format;
1153#ifdef _NL_CURRENT
1154 if (! (modifier == L_('E')
1155 && (*(subfmt =
1156 (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(ERA_T_FMT)))
1157 != L_('\0'))))
1158 subfmt = (const CHAR_T *) _NL_CURRENT (LC_TIME, NLW(T_FMT));
1159 goto subformat;
1160#else
1161# if HAVE_STRFTIME
1162 goto underlying_strftime;
1163# else
1164 /* Fall through. */
1165# endif
1166#endif
1167 case L_('T'):
1168 subfmt = L_("%H:%M:%S");
1169 goto subformat;
1170
1171 case L_('t'):
1172 add (1, *p = L_('\t'));
1173 break;
1174
1175 case L_('u'):
1176 DO_NUMBER (1, (tp->tm_wday - 1 + 7) % 7 + 1);
1177
1178 case L_('U'):
1179 if (modifier == L_('E'))
1180 goto bad_format;
1181
1182 DO_NUMBER (2, (tp->tm_yday - tp->tm_wday + 7) / 7);
1183
1184 case L_('V'):
1185 case L_('g'):
1186 case L_('G'):
1187 if (modifier == L_('E'))
1188 goto bad_format;
1189 {
1190 int year = tp->tm_year + TM_YEAR_BASE;
1191 int days = iso_week_days (tp->tm_yday, tp->tm_wday);
1192
1193 if (days < 0)
1194 {
1195 /* This ISO week belongs to the previous year. */
1196 year--;
1197 days = iso_week_days (tp->tm_yday + (365 + __isleap (year)),
1198 tp->tm_wday);
1199 }
1200 else
1201 {
1202 int d = iso_week_days (tp->tm_yday - (365 + __isleap (year)),
1203 tp->tm_wday);
1204 if (0 <= d)
1205 {
1206 /* This ISO week belongs to the next year. */
1207 year++;
1208 days = d;
1209 }
1210 }
1211
1212 switch (*f)
1213 {
1214 case L_('g'):
1215 DO_NUMBER (2, (year % 100 + 100) % 100);
1216
1217 case L_('G'):
1218 DO_NUMBER (1, year);
1219
1220 default:
1221 DO_NUMBER (2, days / 7 + 1);
1222 }
1223 }
1224
1225 case L_('W'):
1226 if (modifier == L_('E'))
1227 goto bad_format;
1228
1229 DO_NUMBER (2, (tp->tm_yday - (tp->tm_wday - 1 + 7) % 7 + 7) / 7);
1230
1231 case L_('w'):
1232 if (modifier == L_('E'))
1233 goto bad_format;
1234
1235 DO_NUMBER (1, tp->tm_wday);
1236
1237 case L_('Y'):
1238 if (modifier == 'E')
1239 {
1240#if HAVE_STRUCT_ERA_ENTRY
1241 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
1242 if (era)
1243 {
1244# ifdef COMPILE_WIDE
1245 subfmt = era->era_wformat;
1246# else
1247 subfmt = era->era_format;
1248# endif
1249 goto subformat;
1250 }
1251#else
1252# if HAVE_STRFTIME
1253 goto underlying_strftime;
1254# endif
1255#endif
1256 }
1257 if (modifier == L_('O'))
1258 goto bad_format;
1259 else
1260 DO_NUMBER (1, tp->tm_year + TM_YEAR_BASE);
1261
1262 case L_('y'):
1263 if (modifier == L_('E'))
1264 {
1265#if HAVE_STRUCT_ERA_ENTRY
1266 struct era_entry *era = _nl_get_era_entry (tp HELPER_LOCALE_ARG);
1267 if (era)
1268 {
1269 int delta = tp->tm_year - era->start_date[0];
1270 DO_NUMBER (1, (era->offset
1271 + delta * era->absolute_direction));
1272 }
1273#else
1274# if HAVE_STRFTIME
1275 goto underlying_strftime;
1276# endif
1277#endif
1278 }
1279 DO_NUMBER (2, (tp->tm_year % 100 + 100) % 100);
1280
1281 case L_('Z'):
1282 if (change_case)
1283 {
1284 to_uppcase = 0;
1285 to_lowcase = 1;
1286 }
1287
1288#if HAVE_TZNAME
1289 /* The tzset() call might have changed the value. */
1290 if (!(zone && *zone) && tp->tm_isdst >= 0)
1291 {
1292 /* POSIX.1 requires that local time zone information is used as
1293 though strftime called tzset. */
1294# if HAVE_TZSET
1295 if (!*tzset_called)
1296 {
1297 tzset ();
1298 *tzset_called = true;
1299 }
1300# endif
1301 zone = tp->tm_isdst <= 1 ? tzname[tp->tm_isdst] : "?";
1302 }
1303#endif
1304 if (! zone)
1305 zone = "";
1306
1307#ifdef COMPILE_WIDE
1308 {
1309 /* The zone string is always given in multibyte form. We have
1310 to transform it first. */
1311 wchar_t *wczone;
1312 size_t len;
1313 widen (zone, wczone, len);
1314 cpy (len, wczone);
1315 }
1316#else
1317 cpy (strlen (zone), zone);
1318#endif
1319 break;
1320
1321 case L_('z'):
1322 if (tp->tm_isdst < 0)
1323 break;
1324
1325 {
1326 int diff;
1327#if HAVE_TM_GMTOFF
1328 diff = tp->tm_gmtoff;
1329#else
1330 if (ut)
1331 diff = 0;
1332 else
1333 {
1334 struct tm gtm;
1335 struct tm ltm;
1336 time_t lt;
1337
1338 /* POSIX.1 requires that local time zone information is used as
1339 though strftime called tzset. */
1340# if HAVE_TZSET
1341 if (!*tzset_called)
1342 {
1343 tzset ();
1344 *tzset_called = true;
1345 }
1346# endif
1347
1348 ltm = *tp;
1349 lt = mktime (&ltm);
1350
1351 if (lt == (time_t) -1)
1352 {
1353 /* mktime returns -1 for errors, but -1 is also a
1354 valid time_t value. Check whether an error really
1355 occurred. */
1356 struct tm tm;
1357
1358 if (! __localtime_r (&lt, &tm)
1359 || ((ltm.tm_sec ^ tm.tm_sec)
1360 | (ltm.tm_min ^ tm.tm_min)
1361 | (ltm.tm_hour ^ tm.tm_hour)
1362 | (ltm.tm_mday ^ tm.tm_mday)
1363 | (ltm.tm_mon ^ tm.tm_mon)
1364 | (ltm.tm_year ^ tm.tm_year)))
1365 break;
1366 }
1367
1368 if (! __gmtime_r (&lt, &gtm))
1369 break;
1370
1371 diff = tm_diff (&ltm, &gtm);
1372 }
1373#endif
1374
1375 if (diff < 0)
1376 {
1377 add (1, *p = L_('-'));
1378 diff = -diff;
1379 }
1380 else
1381 add (1, *p = L_('+'));
1382
1383 diff /= 60;
1384 DO_NUMBER (4, (diff / 60) * 100 + diff % 60);
1385 }
1386
1387 case L_('\0'): /* GNU extension: % at end of format. */
1388 --f;
1389 /* Fall through. */
1390 default:
1391 /* Unknown format; output the format, including the '%',
1392 since this is most likely the right thing to do if a
1393 multibyte string has been misparsed. */
1394 bad_format:
1395 {
1396 int flen;
1397 for (flen = 1; f[1 - flen] != L_('%'); flen++)
1398 continue;
1399 cpy (flen, &f[1 - flen]);
1400 }
1401 break;
1402 }
1403 }
1404
1405 if (p && maxsize != 0)
1406 *p = L_('\0');
1407 return i;
1408}
1409
1410
1411#ifdef emacs
1412/* For Emacs we have a separate interface which corresponds to the normal
1413 strftime function and does not have the extra information whether the
1414 TP arguments comes from a `gmtime' call or not. */
1415size_t
1416emacs_strftime (char *s, size_t maxsize, const char *format,
1417 const struct tm *tp)
1418{
1419 return my_strftime (s, maxsize, format, tp, 0);
1420}
1421#endif
1422
1423#if defined _LIBC && !defined COMPILE_WIDE
1424weak_alias (__strftime_l, strftime_l)
1425#endif
1426