|
2772
|
1 /* Copyright (C) 1991, 92, 93, 94, 95, 96 Free Software Foundation, Inc. |
|
|
2 |
|
|
3 NOTE: The canonical source of this file is maintained with the GNU C |
|
|
4 Library. Bugs can be reported to bug-glibc@prep.ai.mit.edu. |
|
1185
|
5 |
|
2772
|
6 This program is free software; you can redistribute it and/or modify it |
|
|
7 under the terms of the GNU General Public License as published by the |
|
|
8 Free Software Foundation; either version 2, or (at your option) any |
|
|
9 later version. |
|
1185
|
10 |
|
|
11 This program is distributed in the hope that it will be useful, |
|
|
12 but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
|
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
|
14 GNU General Public License for more details. |
|
|
15 |
|
|
16 You should have received a copy of the GNU General Public License |
|
2772
|
17 along with this program; if not, write to the Free Software Foundation, |
|
|
18 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ |
|
1185
|
19 |
|
|
20 #ifdef HAVE_CONFIG_H |
|
2772
|
21 # include <config.h> |
|
|
22 #endif |
|
|
23 |
|
|
24 #ifdef _LIBC |
|
|
25 # define HAVE_LIMITS_H 1 |
|
|
26 # define HAVE_MBLEN 1 |
|
|
27 # define HAVE_MBRLEN 1 |
|
|
28 # define HAVE_STRUCT_ERA_ENTRY 1 |
|
|
29 # define HAVE_TM_GMTOFF 1 |
|
|
30 # define HAVE_TM_ZONE 1 |
|
|
31 # define MULTIBYTE_IS_FORMAT_SAFE 1 |
|
|
32 # define STDC_HEADERS 1 |
|
|
33 # include <ansidecl.h> |
|
|
34 # include "../locale/localeinfo.h" |
|
1185
|
35 #endif |
|
|
36 |
|
2772
|
37 #include <sys/types.h> /* Some systems define `time_t' here. */ |
|
2442
|
38 |
|
2772
|
39 #ifdef TIME_WITH_SYS_TIME |
|
|
40 # include <sys/time.h> |
|
|
41 # include <time.h> |
|
|
42 #else |
|
|
43 # ifdef HAVE_SYS_TIME_H |
|
|
44 # include <sys/time.h> |
|
|
45 # else |
|
|
46 # include <time.h> |
|
|
47 # endif |
|
|
48 #endif |
|
|
49 |
|
|
50 #if HAVE_TZNAME |
|
|
51 extern char *tzname[]; |
|
2442
|
52 #endif |
|
2435
|
53 |
|
2772
|
54 /* Do multibyte processing if multibytes are supported, unless |
|
|
55 multibyte sequences are safe in formats. Multibyte sequences are |
|
|
56 safe if they cannot contain byte sequences that look like format |
|
|
57 conversion specifications. The GNU C Library uses UTF8 multibyte |
|
|
58 encoding, which is safe for formats, but strftime.c can be used |
|
|
59 with other C libraries that use unsafe encodings. */ |
|
|
60 #define DO_MULTIBYTE (HAVE_MBLEN && ! MULTIBYTE_IS_FORMAT_SAFE) |
|
|
61 |
|
|
62 #if DO_MULTIBYTE |
|
|
63 # if HAVE_MBRLEN |
|
|
64 # include <wchar.h> |
|
|
65 # else |
|
|
66 /* Simulate mbrlen with mblen as best we can. */ |
|
|
67 # define mbstate_t int |
|
|
68 # define mbrlen(s, n, ps) mblen (s, n) |
|
|
69 # define mbsinit(ps) (*(ps) == 0) |
|
|
70 # endif |
|
|
71 static const mbstate_t mbstate_zero; |
|
|
72 #endif |
|
|
73 |
|
|
74 #if HAVE_LIMITS_H |
|
|
75 # include <limits.h> |
|
|
76 #endif |
|
|
77 |
|
|
78 #if STDC_HEADERS |
|
|
79 # include <stddef.h> |
|
|
80 # include <stdlib.h> |
|
|
81 # include <string.h> |
|
2435
|
82 #else |
|
2772
|
83 # define memcpy(d, s, n) bcopy (s, d, n) |
|
|
84 #endif |
|
|
85 |
|
|
86 #ifndef __P |
|
|
87 #if defined (__GNUC__) || (defined (__STDC__) && __STDC__) |
|
|
88 #define __P(args) args |
|
1185
|
89 #else |
|
2772
|
90 #define __P(args) () |
|
|
91 #endif /* GCC. */ |
|
|
92 #endif /* Not __P. */ |
|
|
93 |
|
|
94 #ifndef PTR |
|
|
95 #ifdef __STDC__ |
|
|
96 #define PTR void * |
|
|
97 #else |
|
|
98 #define PTR char * |
|
1185
|
99 #endif |
|
2436
|
100 #endif |
|
1185
|
101 |
|
2772
|
102 #ifndef CHAR_BIT |
|
|
103 #define CHAR_BIT 8 |
|
1185
|
104 #endif |
|
|
105 |
|
2772
|
106 #define TYPE_SIGNED(t) ((t) -1 < 0) |
|
|
107 |
|
|
108 /* Bound on length of the string representing an integer value of type t. |
|
|
109 Subtract one for the sign bit if t is signed; |
|
|
110 302 / 1000 is log10 (2) rounded up; |
|
|
111 add one for integer division truncation; |
|
|
112 add one more for a minus sign if t is signed. */ |
|
|
113 #define INT_STRLEN_BOUND(t) \ |
|
|
114 ((sizeof (t) * CHAR_BIT - TYPE_SIGNED (t)) * 302 / 100 + 1 + TYPE_SIGNED (t)) |
|
|
115 |
|
|
116 #define TM_YEAR_BASE 1900 |
|
|
117 |
|
|
118 #ifndef __isleap |
|
|
119 /* Nonzero if YEAR is a leap year (every 4 years, |
|
|
120 except every 100th isn't, and every 400th is). */ |
|
|
121 #define __isleap(year) \ |
|
|
122 ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0)) |
|
1185
|
123 #endif |
|
|
124 |
|
|
125 |
|
2772
|
126 #ifdef _LIBC |
|
|
127 # define gmtime_r __gmtime_r |
|
|
128 # define localtime_r __localtime_r |
|
|
129 #else |
|
|
130 # if ! HAVE_LOCALTIME_R |
|
|
131 # if ! HAVE_TM_GMTOFF |
|
|
132 /* Approximate gmtime_r as best we can in its absence. */ |
|
|
133 #define gmtime_r my_gmtime_r |
|
|
134 static struct tm *gmtime_r __P ((const time_t *, struct tm *)); |
|
|
135 static struct tm * |
|
|
136 gmtime_r (t, tp) |
|
|
137 const time_t *t; |
|
|
138 struct tm *tp; |
|
1185
|
139 { |
|
2772
|
140 struct tm *l = gmtime (t); |
|
|
141 if (! l) |
|
|
142 return 0; |
|
|
143 *tp = *l; |
|
|
144 return tp; |
|
|
145 } |
|
|
146 # endif /* ! HAVE_TM_GMTOFF */ |
|
1185
|
147 |
|
2772
|
148 /* Approximate localtime_r as best we can in its absence. */ |
|
|
149 #define localtime_r my_localtime_r |
|
|
150 static struct tm *localtime_r __P ((const time_t *, struct tm *)); |
|
|
151 static struct tm * |
|
|
152 localtime_r (t, tp) |
|
|
153 const time_t *t; |
|
|
154 struct tm *tp; |
|
1185
|
155 { |
|
2772
|
156 struct tm *l = localtime (t); |
|
|
157 if (! l) |
|
|
158 return 0; |
|
|
159 *tp = *l; |
|
|
160 return tp; |
|
|
161 } |
|
|
162 # endif /* ! HAVE_LOCALTIME_R */ |
|
|
163 #endif /* ! defined (_LIBC) */ |
|
1185
|
164 |
|
|
165 |
|
2772
|
166 #define add(n, f) \ |
|
|
167 do \ |
|
|
168 { \ |
|
|
169 i += (n); \ |
|
|
170 if (i >= maxsize) \ |
|
|
171 return 0; \ |
|
|
172 else \ |
|
|
173 if (p) \ |
|
|
174 { \ |
|
|
175 f; \ |
|
|
176 p += (n); \ |
|
|
177 } \ |
|
|
178 } while (0) |
|
|
179 #define cpy(n, s) add ((n), memcpy((PTR) p, (PTR) (s), (n))) |
|
1185
|
180 |
|
2772
|
181 #if ! HAVE_TM_GMTOFF |
|
|
182 /* Yield the difference between *A and *B, |
|
|
183 measured in seconds, ignoring leap seconds. */ |
|
|
184 static int tm_diff __P ((const struct tm *, const struct tm *)); |
|
1185
|
185 static int |
|
2772
|
186 tm_diff (a, b) |
|
|
187 const struct tm *a; |
|
|
188 const struct tm *b; |
|
1185
|
189 { |
|
2772
|
190 /* Compute intervening leap days correctly even if year is negative. |
|
|
191 Take care to avoid int overflow in leap day calculations, |
|
|
192 but it's OK to assume that A and B are close to each other. */ |
|
|
193 int a4 = (a->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (a->tm_year & 3); |
|
|
194 int b4 = (b->tm_year >> 2) + (TM_YEAR_BASE >> 2) - ! (b->tm_year & 3); |
|
|
195 int a100 = a4 / 25 - (a4 % 25 < 0); |
|
|
196 int b100 = b4 / 25 - (b4 % 25 < 0); |
|
|
197 int a400 = a100 >> 2; |
|
|
198 int b400 = b100 >> 2; |
|
|
199 int intervening_leap_days = (a4 - b4) - (a100 - b100) + (a400 - b400); |
|
|
200 int years = a->tm_year - b->tm_year; |
|
|
201 int days = (365 * years + intervening_leap_days |
|
|
202 + (a->tm_yday - b->tm_yday)); |
|
|
203 return (60 * (60 * (24 * days + (a->tm_hour - b->tm_hour)) |
|
|
204 + (a->tm_min - b->tm_min)) |
|
|
205 + (a->tm_sec - b->tm_sec)); |
|
|
206 } |
|
|
207 #endif /* ! HAVE_TM_GMTOFF */ |
|
|
208 |
|
|
209 |
|
1185
|
210 |
|
2772
|
211 /* The number of days from the first day of the first ISO week of this |
|
|
212 year to the year day YDAY with week day WDAY. ISO weeks start on |
|
|
213 Monday; the first ISO week has the year's first Thursday. YDAY may |
|
|
214 be as small as YDAY_MINIMUM. */ |
|
|
215 #define ISO_WEEK_START_WDAY 1 /* Monday */ |
|
|
216 #define ISO_WEEK1_WDAY 4 /* Thursday */ |
|
|
217 #define YDAY_MINIMUM (-366) |
|
|
218 static int iso_week_days __P ((int, int)); |
|
|
219 #ifdef __GNUC__ |
|
|
220 inline |
|
|
221 #endif |
|
|
222 static int |
|
|
223 iso_week_days (yday, wday) |
|
|
224 int yday; |
|
|
225 int wday; |
|
|
226 { |
|
|
227 /* Add enough to the first operand of % to make it nonnegative. */ |
|
|
228 int big_enough_multiple_of_7 = (-YDAY_MINIMUM / 7 + 2) * 7; |
|
|
229 return (yday |
|
|
230 - (yday - wday + ISO_WEEK1_WDAY + big_enough_multiple_of_7) % 7 |
|
|
231 + ISO_WEEK1_WDAY - ISO_WEEK_START_WDAY); |
|
1185
|
232 } |
|
|
233 |
|
|
234 |
|
2772
|
235 #ifndef _NL_CURRENT |
|
|
236 static char const weekday_name[][10] = |
|
|
237 { |
|
|
238 "Sunday", "Monday", "Tuesday", "Wednesday", |
|
|
239 "Thursday", "Friday", "Saturday" |
|
|
240 }; |
|
|
241 static char const month_name[][10] = |
|
|
242 { |
|
|
243 "January", "February", "March", "April", "May", "June", |
|
|
244 "July", "August", "September", "October", "November", "December" |
|
|
245 }; |
|
|
246 #endif |
|
1185
|
247 |
|
2772
|
248 /* Write information from TP into S according to the format |
|
|
249 string FORMAT, writing no more that MAXSIZE characters |
|
|
250 (including the terminating '\0') and returning number of |
|
|
251 characters written. If S is NULL, nothing will be written |
|
|
252 anywhere, so to determine how many characters would be |
|
|
253 written, use NULL for S and (size_t) UINT_MAX for MAXSIZE. */ |
|
|
254 size_t |
|
|
255 strftime (s, maxsize, format, tp) |
|
|
256 char *s; |
|
|
257 size_t maxsize; |
|
|
258 const char *format; |
|
|
259 register const struct tm *tp; |
|
1185
|
260 { |
|
2772
|
261 int hour12 = tp->tm_hour; |
|
|
262 #ifdef _NL_CURRENT |
|
|
263 const char *const a_wkday = _NL_CURRENT (LC_TIME, ABDAY_1 + tp->tm_wday); |
|
|
264 const char *const f_wkday = _NL_CURRENT (LC_TIME, DAY_1 + tp->tm_wday); |
|
|
265 const char *const a_month = _NL_CURRENT (LC_TIME, ABMON_1 + tp->tm_mon); |
|
|
266 const char *const f_month = _NL_CURRENT (LC_TIME, MON_1 + tp->tm_mon); |
|
|
267 const char *const ampm = _NL_CURRENT (LC_TIME, |
|
|
268 hour12 > 11 ? PM_STR : AM_STR); |
|
|
269 size_t aw_len = strlen (a_wkday); |
|
|
270 size_t am_len = strlen (a_month); |
|
|
271 size_t ap_len = strlen (ampm); |
|
|
272 #else |
|
|
273 const char *const f_wkday = weekday_name[tp->tm_wday]; |
|
|
274 const char *const f_month = month_name[tp->tm_mon]; |
|
|
275 const char *const a_wkday = f_wkday; |
|
|
276 const char *const a_month = f_month; |
|
|
277 const char *const ampm = "AMPM" + 2 * (hour12 > 11); |
|
|
278 size_t aw_len = 3; |
|
|
279 size_t am_len = 3; |
|
|
280 size_t ap_len = 2; |
|
|
281 #endif |
|
|
282 size_t wkday_len = strlen (f_wkday); |
|
|
283 size_t month_len = strlen (f_month); |
|
|
284 const char *zone; |
|
|
285 size_t zonelen; |
|
|
286 register size_t i = 0; |
|
|
287 register char *p = s; |
|
|
288 register const char *f; |
|
1185
|
289 |
|
2772
|
290 zone = 0; |
|
|
291 #if HAVE_TM_ZONE |
|
|
292 zone = (const char *) tp->tm_zone; |
|
|
293 #endif |
|
|
294 #if HAVE_TZNAME |
|
|
295 if (!(zone && *zone) && tp->tm_isdst >= 0) |
|
|
296 zone = tzname[tp->tm_isdst]; |
|
|
297 #endif |
|
|
298 if (! zone) |
|
|
299 zone = ""; /* POSIX.2 requires the empty string here. */ |
|
|
300 |
|
|
301 zonelen = strlen (zone); |
|
|
302 |
|
|
303 if (hour12 > 12) |
|
|
304 hour12 -= 12; |
|
|
305 else |
|
|
306 if (hour12 == 0) hour12 = 12; |
|
1185
|
307 |
|
2772
|
308 for (f = format; *f != '\0'; ++f) |
|
|
309 { |
|
|
310 int pad; /* Padding for number ('-', '_', or 0). */ |
|
|
311 int modifier; /* Field modifier ('E', 'O', or 0). */ |
|
|
312 int digits; /* Max digits for numeric format. */ |
|
|
313 int number_value; /* Numeric value to be printed. */ |
|
|
314 int negative_number; /* 1 if the number is negative. */ |
|
|
315 const char *subfmt; |
|
|
316 char *bufp; |
|
|
317 char buf[1 + (sizeof (int) < sizeof (time_t) |
|
|
318 ? INT_STRLEN_BOUND (time_t) |
|
|
319 : INT_STRLEN_BOUND (int))]; |
|
|
320 |
|
|
321 #if DO_MULTIBYTE |
|
|
322 |
|
|
323 switch (*f) |
|
|
324 { |
|
|
325 case '%': |
|
|
326 break; |
|
1185
|
327 |
|
2772
|
328 case '\a': case '\b': case '\t': case '\n': |
|
|
329 case '\v': case '\f': case '\r': |
|
|
330 case ' ': case '!': case '"': case '#': case '&': case'\'': |
|
|
331 case '(': case ')': case '*': case '+': case ',': case '-': |
|
|
332 case '.': case '/': case '0': case '1': case '2': case '3': |
|
|
333 case '4': case '5': case '6': case '7': case '8': case '9': |
|
|
334 case ':': case ';': case '<': case '=': case '>': case '?': |
|
|
335 case 'A': case 'B': case 'C': case 'D': case 'E': case 'F': |
|
|
336 case 'G': case 'H': case 'I': case 'J': case 'K': case 'L': |
|
|
337 case 'M': case 'N': case 'O': case 'P': case 'Q': case 'R': |
|
|
338 case 'S': case 'T': case 'U': case 'V': case 'W': case 'X': |
|
|
339 case 'Y': case 'Z': case '[': case'\\': case ']': case '^': |
|
|
340 case '_': case 'a': case 'b': case 'c': case 'd': case 'e': |
|
|
341 case 'f': case 'g': case 'h': case 'i': case 'j': case 'k': |
|
|
342 case 'l': case 'm': case 'n': case 'o': case 'p': case 'q': |
|
|
343 case 'r': case 's': case 't': case 'u': case 'v': case 'w': |
|
|
344 case 'x': case 'y': case 'z': case '{': case '|': case '}': |
|
|
345 case '~': |
|
|
346 /* The C Standard requires these 98 characters (plus '%') to |
|
|
347 be in the basic execution character set. None of these |
|
|
348 characters can start a multibyte sequence, so they need |
|
|
349 not be analyzed further. */ |
|
|
350 add (1, *p = *f); |
|
|
351 continue; |
|
1185
|
352 |
|
2772
|
353 default: |
|
|
354 /* Copy this multibyte sequence until we reach its end, find |
|
|
355 an error, or come back to the initial shift state. */ |
|
|
356 { |
|
|
357 mbstate_t mbstate = mbstate_zero; |
|
|
358 size_t len = 0; |
|
1185
|
359 |
|
2772
|
360 do |
|
|
361 { |
|
|
362 size_t bytes = mbrlen (f + len, (size_t) -1, &mbstate); |
|
|
363 |
|
|
364 if (bytes == 0) |
|
|
365 break; |
|
|
366 |
|
|
367 if (bytes == (size_t) -2 || bytes == (size_t) -1) |
|
|
368 { |
|
|
369 len++; |
|
|
370 break; |
|
|
371 } |
|
|
372 |
|
|
373 len += bytes; |
|
|
374 } |
|
|
375 while (! mbsinit (&mbstate)); |
|
1185
|
376 |
|
2772
|
377 cpy (len, f); |
|
|
378 continue; |
|
|
379 } |
|
|
380 } |
|
|
381 |
|
|
382 #else /* ! DO_MULTIBYTE */ |
|
|
383 |
|
|
384 /* Either multibyte encodings are not supported, or they are |
|
|
385 safe for formats, so any non-'%' byte can be copied through. */ |
|
|
386 if (*f != '%') |
|
|
387 { |
|
|
388 add (1, *p = *f); |
|
|
389 continue; |
|
|
390 } |
|
|
391 |
|
|
392 #endif /* ! DO_MULTIBYTE */ |
|
1185
|
393 |
|
2772
|
394 /* Check for flags that can modify a number format. */ |
|
|
395 ++f; |
|
|
396 switch (*f) |
|
|
397 { |
|
|
398 case '_': |
|
|
399 case '-': |
|
|
400 pad = *f++; |
|
|
401 break; |
|
|
402 |
|
|
403 default: |
|
|
404 pad = 0; |
|
|
405 break; |
|
|
406 } |
|
1185
|
407 |
|
2772
|
408 /* Check for modifiers. */ |
|
|
409 switch (*f) |
|
|
410 { |
|
|
411 case 'E': |
|
|
412 case 'O': |
|
|
413 modifier = *f++; |
|
|
414 break; |
|
|
415 |
|
|
416 default: |
|
|
417 modifier = 0; |
|
|
418 break; |
|
|
419 } |
|
|
420 |
|
|
421 /* Now do the specified format. */ |
|
|
422 switch (*f) |
|
|
423 { |
|
|
424 #define DO_NUMBER(d, v) \ |
|
|
425 digits = d; number_value = v; goto do_number |
|
|
426 #define DO_NUMBER_SPACEPAD(d, v) \ |
|
|
427 digits = d; number_value = v; goto do_number_spacepad |
|
1185
|
428 |
|
2772
|
429 case '%': |
|
|
430 if (modifier != 0) |
|
|
431 goto bad_format; |
|
|
432 add (1, *p = *f); |
|
|
433 break; |
|
|
434 |
|
|
435 case 'a': |
|
|
436 if (modifier != 0) |
|
|
437 goto bad_format; |
|
|
438 cpy (aw_len, a_wkday); |
|
|
439 break; |
|
|
440 |
|
|
441 case 'A': |
|
|
442 if (modifier != 0) |
|
|
443 goto bad_format; |
|
|
444 cpy (wkday_len, f_wkday); |
|
|
445 break; |
|
1185
|
446 |
|
2772
|
447 case 'b': |
|
|
448 case 'h': /* POSIX.2 extension. */ |
|
|
449 if (modifier != 0) |
|
|
450 goto bad_format; |
|
|
451 cpy (am_len, a_month); |
|
|
452 break; |
|
1185
|
453 |
|
2772
|
454 case 'B': |
|
|
455 if (modifier != 0) |
|
|
456 goto bad_format; |
|
|
457 cpy (month_len, f_month); |
|
|
458 break; |
|
|
459 |
|
|
460 case 'c': |
|
|
461 if (modifier == 'O') |
|
|
462 goto bad_format; |
|
|
463 #ifdef _NL_CURRENT |
|
|
464 if (! (modifier == 'E' |
|
|
465 && *(subfmt = _NL_CURRENT (LC_TIME, ERA_D_T_FMT)) != '\0')) |
|
|
466 subfmt = _NL_CURRENT (LC_TIME, D_T_FMT); |
|
|
467 #else |
|
|
468 subfmt = "%a %b %e %H:%M:%S %Y"; |
|
1185
|
469 #endif |
|
|
470 |
|
2772
|
471 subformat: |
|
|
472 { |
|
|
473 size_t len = strftime (p, maxsize - i, subfmt, tp); |
|
|
474 if (len == 0 && *subfmt) |
|
|
475 return 0; |
|
|
476 add (len, ;); |
|
|
477 } |
|
|
478 break; |
|
1185
|
479 |
|
2772
|
480 case 'C': /* POSIX.2 extension. */ |
|
|
481 if (modifier == 'O') |
|
|
482 goto bad_format; |
|
|
483 #if HAVE_STRUCT_ERA_ENTRY |
|
|
484 if (modifier == 'E') |
|
|
485 { |
|
|
486 struct era_entry *era = _nl_get_era_entry (tp); |
|
|
487 if (era) |
|
|
488 { |
|
|
489 size_t len = strlen (era->name_fmt); |
|
|
490 cpy (len, era->name_fmt); |
|
|
491 break; |
|
|
492 } |
|
|
493 } |
|
|
494 #endif |
|
|
495 { |
|
|
496 int year = tp->tm_year + TM_YEAR_BASE; |
|
|
497 DO_NUMBER (1, year / 100 - (year % 100 < 0)); |
|
|
498 } |
|
|
499 |
|
|
500 case 'x': |
|
|
501 if (modifier == 'O') |
|
|
502 goto bad_format; |
|
|
503 #ifdef _NL_CURRENT |
|
|
504 if (! (modifier == 'E' |
|
|
505 && *(subfmt = _NL_CURRENT (LC_TIME, ERA_D_FMT)) != '\0')) |
|
|
506 subfmt = _NL_CURRENT (LC_TIME, D_FMT); |
|
|
507 goto subformat; |
|
|
508 #endif |
|
|
509 /* Fall through. */ |
|
|
510 case 'D': /* POSIX.2 extension. */ |
|
|
511 if (modifier != 0) |
|
|
512 goto bad_format; |
|
|
513 subfmt = "%m/%d/%y"; |
|
|
514 goto subformat; |
|
|
515 |
|
|
516 case 'd': |
|
|
517 if (modifier == 'E') |
|
|
518 goto bad_format; |
|
|
519 |
|
|
520 DO_NUMBER (2, tp->tm_mday); |
|
1185
|
521 |
|
2772
|
522 case 'e': /* POSIX.2 extension. */ |
|
|
523 if (modifier == 'E') |
|
|
524 goto bad_format; |
|
|
525 |
|
|
526 DO_NUMBER_SPACEPAD (2, tp->tm_mday); |
|
|
527 |
|
|
528 /* All numeric formats set DIGITS and NUMBER_VALUE and then |
|
|
529 jump to one of these two labels. */ |
|
|
530 |
|
|
531 do_number_spacepad: |
|
|
532 /* Force `_' flag. */ |
|
|
533 pad = '_'; |
|
|
534 |
|
|
535 do_number: |
|
|
536 /* Format the number according to the MODIFIER flag. */ |
|
|
537 |
|
|
538 #ifdef _NL_CURRENT |
|
|
539 if (modifier == 'O' && 0 <= number_value) |
|
1185
|
540 { |
|
2772
|
541 /* Get the locale specific alternate representation of |
|
|
542 the number NUMBER_VALUE. If none exist NULL is returned. */ |
|
|
543 const char *cp = _nl_get_alt_digit (number_value); |
|
|
544 |
|
|
545 if (cp != NULL) |
|
|
546 { |
|
|
547 size_t digitlen = strlen (cp); |
|
|
548 if (digitlen != 0) |
|
|
549 { |
|
|
550 cpy (digitlen, cp); |
|
|
551 break; |
|
|
552 } |
|
|
553 } |
|
1185
|
554 } |
|
2772
|
555 #endif |
|
|
556 { |
|
|
557 unsigned int u = number_value; |
|
|
558 |
|
|
559 bufp = buf + sizeof (buf); |
|
|
560 negative_number = number_value < 0; |
|
|
561 |
|
|
562 if (negative_number) |
|
|
563 u = -u; |
|
1185
|
564 |
|
2772
|
565 do |
|
|
566 *--bufp = u % 10 + '0'; |
|
|
567 while ((u /= 10) != 0); |
|
|
568 } |
|
|
569 |
|
|
570 do_number_sign_and_padding: |
|
|
571 if (negative_number) |
|
|
572 *--bufp = '-'; |
|
|
573 |
|
|
574 if (pad != '-') |
|
1185
|
575 { |
|
2772
|
576 int padding = digits - (buf + sizeof (buf) - bufp); |
|
|
577 |
|
|
578 if (pad == '_') |
|
|
579 { |
|
|
580 while (0 < padding--) |
|
|
581 *--bufp = ' '; |
|
|
582 } |
|
|
583 else |
|
|
584 { |
|
|
585 bufp += negative_number; |
|
|
586 while (0 < padding--) |
|
|
587 *--bufp = '0'; |
|
|
588 if (negative_number) |
|
|
589 *--bufp = '-'; |
|
|
590 } |
|
|
591 } |
|
|
592 |
|
|
593 cpy (buf + sizeof (buf) - bufp, bufp); |
|
|
594 break; |
|
|
595 |
|
|
596 |
|
|
597 case 'H': |
|
|
598 if (modifier == 'E') |
|
|
599 goto bad_format; |
|
|
600 |
|
|
601 DO_NUMBER (2, tp->tm_hour); |
|
|
602 |
|
|
603 case 'I': |
|
|
604 if (modifier == 'E') |
|
|
605 goto bad_format; |
|
|
606 |
|
|
607 DO_NUMBER (2, hour12); |
|
|
608 |
|
|
609 case 'k': /* GNU extension. */ |
|
|
610 if (modifier == 'E') |
|
|
611 goto bad_format; |
|
|
612 |
|
|
613 DO_NUMBER_SPACEPAD (2, tp->tm_hour); |
|
|
614 |
|
|
615 case 'l': /* GNU extension. */ |
|
|
616 if (modifier == 'E') |
|
|
617 goto bad_format; |
|
|
618 |
|
|
619 DO_NUMBER_SPACEPAD (2, hour12); |
|
|
620 |
|
|
621 case 'j': |
|
|
622 if (modifier == 'E') |
|
|
623 goto bad_format; |
|
|
624 |
|
|
625 DO_NUMBER (3, 1 + tp->tm_yday); |
|
|
626 |
|
|
627 case 'M': |
|
|
628 if (modifier == 'E') |
|
|
629 goto bad_format; |
|
|
630 |
|
|
631 DO_NUMBER (2, tp->tm_min); |
|
|
632 |
|
|
633 case 'm': |
|
|
634 if (modifier == 'E') |
|
|
635 goto bad_format; |
|
|
636 |
|
|
637 DO_NUMBER (2, tp->tm_mon + 1); |
|
1185
|
638 |
|
2772
|
639 case 'n': /* POSIX.2 extension. */ |
|
|
640 add (1, *p = '\n'); |
|
|
641 break; |
|
|
642 |
|
|
643 case 'p': |
|
|
644 cpy (ap_len, ampm); |
|
|
645 break; |
|
|
646 |
|
|
647 case 'R': /* GNU extension. */ |
|
|
648 subfmt = "%H:%M"; |
|
|
649 goto subformat; |
|
|
650 |
|
|
651 case 'r': /* POSIX.2 extension. */ |
|
|
652 #ifdef _NL_CURRENT |
|
|
653 if (*(subfmt = _NL_CURRENT (LC_TIME, T_FMT_AMPM)) == '\0') |
|
|
654 #endif |
|
|
655 subfmt = "%I:%M:%S %p"; |
|
|
656 goto subformat; |
|
|
657 |
|
|
658 case 'S': |
|
|
659 if (modifier == 'E') |
|
|
660 goto bad_format; |
|
|
661 |
|
|
662 DO_NUMBER (2, tp->tm_sec); |
|
|
663 |
|
|
664 case 's': /* GNU extension. */ |
|
|
665 { |
|
|
666 struct tm ltm; |
|
|
667 time_t t; |
|
|
668 |
|
|
669 ltm = *tp; |
|
|
670 t = mktime (<m); |
|
|
671 |
|
|
672 /* Generate string value for T using time_t arithmetic; |
|
|
673 this works even if sizeof (long) < sizeof (time_t). */ |
|
|
674 |
|
|
675 bufp = buf + sizeof (buf); |
|
|
676 negative_number = t < 0; |
|
|
677 |
|
|
678 do |
|
1185
|
679 { |
|
2772
|
680 int d = t % 10; |
|
|
681 t /= 10; |
|
|
682 |
|
|
683 if (negative_number) |
|
|
684 { |
|
|
685 d = -d; |
|
|
686 |
|
|
687 /* Adjust if division truncates to minus infinity. */ |
|
|
688 if (0 < -1 % 10 && d < 0) |
|
|
689 { |
|
|
690 t++; |
|
|
691 d += 10; |
|
|
692 } |
|
|
693 } |
|
|
694 |
|
|
695 *--bufp = d + '0'; |
|
|
696 } |
|
|
697 while (t != 0); |
|
|
698 |
|
|
699 digits = 1; |
|
|
700 goto do_number_sign_and_padding; |
|
|
701 } |
|
1185
|
702 |
|
2772
|
703 case 'X': |
|
|
704 if (modifier == 'O') |
|
|
705 goto bad_format; |
|
|
706 #ifdef _NL_CURRENT |
|
|
707 if (! (modifier == 'E' |
|
|
708 && *(subfmt = _NL_CURRENT (LC_TIME, ERA_T_FMT)) != '\0')) |
|
|
709 subfmt = _NL_CURRENT (LC_TIME, T_FMT); |
|
|
710 goto subformat; |
|
|
711 #endif |
|
|
712 /* Fall through. */ |
|
|
713 case 'T': /* POSIX.2 extension. */ |
|
|
714 subfmt = "%H:%M:%S"; |
|
|
715 goto subformat; |
|
|
716 |
|
|
717 case 't': /* POSIX.2 extension. */ |
|
|
718 add (1, *p = '\t'); |
|
|
719 break; |
|
|
720 |
|
|
721 case 'u': /* POSIX.2 extension. */ |
|
|
722 DO_NUMBER (1, (tp->tm_wday - 1 + 7) % 7 + 1); |
|
|
723 |
|
|
724 case 'U': |
|
|
725 if (modifier == 'E') |
|
|
726 goto bad_format; |
|
|
727 |
|
|
728 DO_NUMBER (2, (tp->tm_yday - tp->tm_wday + 7) / 7); |
|
|
729 |
|
|
730 case 'V': |
|
|
731 case 'g': /* GNU extension. */ |
|
|
732 case 'G': /* GNU extension. */ |
|
|
733 if (modifier == 'E') |
|
|
734 goto bad_format; |
|
|
735 { |
|
|
736 int year = tp->tm_year + TM_YEAR_BASE; |
|
|
737 int days = iso_week_days (tp->tm_yday, tp->tm_wday); |
|
|
738 |
|
|
739 if (days < 0) |
|
|
740 { |
|
|
741 /* This ISO week belongs to the previous year. */ |
|
|
742 year--; |
|
|
743 days = iso_week_days (tp->tm_yday + (365 + __isleap (year)), |
|
|
744 tp->tm_wday); |
|
|
745 } |
|
|
746 else |
|
|
747 { |
|
|
748 int d = iso_week_days (tp->tm_yday - (365 + __isleap (year)), |
|
|
749 tp->tm_wday); |
|
|
750 if (0 <= d) |
|
|
751 { |
|
|
752 /* This ISO week belongs to the next year. */ |
|
|
753 year++; |
|
|
754 days = d; |
|
|
755 } |
|
|
756 } |
|
|
757 |
|
|
758 switch (*f) |
|
|
759 { |
|
|
760 case 'g': |
|
|
761 DO_NUMBER (2, (year % 100 + 100) % 100); |
|
|
762 |
|
|
763 case 'G': |
|
|
764 DO_NUMBER (1, year); |
|
|
765 |
|
|
766 default: |
|
|
767 DO_NUMBER (2, days / 7 + 1); |
|
1185
|
768 } |
|
2772
|
769 } |
|
|
770 |
|
|
771 case 'W': |
|
|
772 if (modifier == 'E') |
|
|
773 goto bad_format; |
|
|
774 |
|
|
775 DO_NUMBER (2, (tp->tm_yday - (tp->tm_wday - 1 + 7) % 7 + 7) / 7); |
|
|
776 |
|
|
777 case 'w': |
|
|
778 if (modifier == 'E') |
|
|
779 goto bad_format; |
|
|
780 |
|
|
781 DO_NUMBER (1, tp->tm_wday); |
|
|
782 |
|
|
783 case 'Y': |
|
|
784 #if HAVE_STRUCT_ERA_ENTRY |
|
|
785 if (modifier == 'E') |
|
|
786 { |
|
|
787 struct era_entry *era = _nl_get_era_entry (tp); |
|
|
788 if (era) |
|
|
789 { |
|
|
790 subfmt = strchr (era->name_fmt, '\0') + 1; |
|
|
791 goto subformat; |
|
|
792 } |
|
|
793 } |
|
|
794 #endif |
|
|
795 if (modifier == 'O') |
|
|
796 goto bad_format; |
|
|
797 else |
|
|
798 DO_NUMBER (1, tp->tm_year + TM_YEAR_BASE); |
|
1185
|
799 |
|
2772
|
800 case 'y': |
|
|
801 #if HAVE_STRUCT_ERA_ENTRY |
|
|
802 if (modifier == 'E') |
|
|
803 { |
|
|
804 struct era_entry *era = _nl_get_era_entry (tp); |
|
|
805 if (era) |
|
|
806 { |
|
|
807 int delta = tp->tm_year - era->start_date[0]; |
|
|
808 DO_NUMBER (1, (era->offset |
|
|
809 + (era->direction == '-' ? -delta : delta))); |
|
|
810 } |
|
|
811 } |
|
|
812 #endif |
|
|
813 DO_NUMBER (2, (tp->tm_year % 100 + 100) % 100); |
|
|
814 |
|
|
815 case 'Z': |
|
|
816 cpy (zonelen, zone); |
|
|
817 break; |
|
|
818 |
|
|
819 case 'z': /* GNU extension. */ |
|
|
820 if (tp->tm_isdst < 0) |
|
|
821 break; |
|
|
822 |
|
|
823 { |
|
|
824 int diff; |
|
|
825 #if HAVE_TM_GMTOFF |
|
|
826 diff = tp->tm_gmtoff; |
|
|
827 #else |
|
|
828 struct tm gtm; |
|
|
829 struct tm ltm; |
|
|
830 time_t lt; |
|
|
831 |
|
|
832 ltm = *tp; |
|
|
833 lt = mktime (<m); |
|
|
834 |
|
|
835 if (lt == (time_t) -1) |
|
1185
|
836 { |
|
2772
|
837 /* mktime returns -1 for errors, but -1 is also a |
|
|
838 valid time_t value. Check whether an error really |
|
|
839 occurred. */ |
|
|
840 struct tm tm; |
|
|
841 localtime_r (<, &tm); |
|
|
842 |
|
|
843 if ((ltm.tm_sec ^ tm.tm_sec) |
|
|
844 | (ltm.tm_min ^ tm.tm_min) |
|
|
845 | (ltm.tm_hour ^ tm.tm_hour) |
|
|
846 | (ltm.tm_mday ^ tm.tm_mday) |
|
|
847 | (ltm.tm_mon ^ tm.tm_mon) |
|
|
848 | (ltm.tm_year ^ tm.tm_year)) |
|
|
849 break; |
|
1185
|
850 } |
|
2772
|
851 |
|
|
852 if (! gmtime_r (<, >m)) |
|
1185
|
853 break; |
|
|
854 |
|
2772
|
855 diff = tm_diff (<m, >m); |
|
1185
|
856 #endif |
|
2772
|
857 |
|
|
858 if (diff < 0) |
|
|
859 { |
|
|
860 add (1, *p = '-'); |
|
|
861 diff = -diff; |
|
|
862 } |
|
|
863 else |
|
|
864 add (1, *p = '+'); |
|
|
865 |
|
|
866 diff /= 60; |
|
|
867 DO_NUMBER (4, (diff / 60) * 100 + diff % 60); |
|
|
868 } |
|
1185
|
869 |
|
2772
|
870 case '\0': /* GNU extension: % at end of format. */ |
|
|
871 --f; |
|
|
872 /* Fall through. */ |
|
|
873 default: |
|
|
874 /* Unknown format; output the format, including the '%', |
|
|
875 since this is most likely the right thing to do if a |
|
|
876 multibyte string has been misparsed. */ |
|
|
877 bad_format: |
|
|
878 { |
|
|
879 int flen; |
|
|
880 for (flen = 1; f[1 - flen] != '%'; flen++) |
|
|
881 continue; |
|
|
882 cpy (flen, &f[1 - flen]); |
|
|
883 } |
|
|
884 break; |
|
1185
|
885 } |
|
|
886 } |
|
2772
|
887 |
|
|
888 if (p) |
|
|
889 *p = '\0'; |
|
|
890 return i; |
|
1185
|
891 } |
