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