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