?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gencat: Get rid of alloca.
[glibc.git] / time / strptime_l.c
blob85c3249fcc256533b08186c5c18a8c369698b96e
1 /* Copyright (C) 2002-2023 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <https://www.gnu.org/licenses/>. */
17
18 #ifdef HAVE_CONFIG_H
19 # include <config.h>
20 #endif
21
22 #include <assert.h>
23 #include <ctype.h>
24 #include <langinfo.h>
25 #include <limits.h>
26 #include <string.h>
27 #include <time.h>
28 #include <stdbool.h>
29
30 #ifdef _LIBC
31 # define HAVE_LOCALTIME_R 0
32 # include "../locale/localeinfo.h"
33
34 # define time_t __time64_t
35 # define __localtime_r(t, tp) __localtime64_r (t, tp)
36 #endif
37
38 #if ! HAVE_LOCALTIME_R && ! defined localtime_r
39 # ifdef _LIBC
40 # define localtime_r __localtime_r
41 # else
42 /* Approximate localtime_r as best we can in its absence. */
43 # define localtime_r my_localtime_r
44 static struct tm *localtime_r (const time_t *, struct tm *);
45 static struct tm *
46 localtime_r (const time_t *t, struct tm *tp)
47 {
48 struct tm *l = localtime (t);
49 if (! l)
50 return 0;
51 *tp = *l;
52 return tp;
53 }
54 # endif /* ! _LIBC */
55 #endif /* ! HAVE_LOCALTIME_R && ! defined (localtime_r) */
56
57
58 #define match_char(ch1, ch2) if (ch1 != ch2) return NULL
59 #if defined __GNUC__ && __GNUC__ >= 2
60 # define match_string(cs1, s2) \
61 ({ size_t len = strlen (cs1); \
62 int result = __strncasecmp_l ((cs1), (s2), len, locale) == 0; \
63 if (result) (s2) += len; \
64 result; })
65 #else
66 /* Oh come on. Get a reasonable compiler. */
67 # define match_string(cs1, s2) \
68 (strncasecmp ((cs1), (s2), strlen (cs1)) ? 0 : ((s2) += strlen (cs1), 1))
69 #endif
70 /* We intentionally do not use isdigit() for testing because this will
71 lead to problems with the wide character version. */
72 #define get_number(from, to, n) \
73 do { \
74 int __n = n; \
75 val = 0; \
76 while (ISSPACE (*rp)) \
77 ++rp; \
78 if (*rp < '0' || *rp > '9') \
79 return NULL; \
80 do { \
81 val *= 10; \
82 val += *rp++ - '0'; \
83 } while (--__n > 0 && val * 10 <= to && *rp >= '0' && *rp <= '9'); \
84 if (val < from || val > to) \
85 return NULL; \
86 } while (0)
87 #ifdef _NL_CURRENT
88 # define get_alt_number(from, to, n) \
89 ({ \
90 __label__ do_normal; \
91 \
92 if (s.decided != raw) \
93 { \
94 val = _nl_parse_alt_digit (&rp HELPER_LOCALE_ARG); \
95 if (val == -1 && s.decided != loc) \
96 { \
97 s.decided = loc; \
98 goto do_normal; \
99 } \
100 if (val < from || val > to) \
101 return NULL; \
102 } \
103 else \
104 { \
105 do_normal: \
106 get_number (from, to, n); \
107 } \
108 0; \
109 })
110 #else
111 # define get_alt_number(from, to, n) \
112 /* We don't have the alternate representation. */ \
113 get_number(from, to, n)
114 #endif
115 #define recursive(new_fmt) \
116 (*(new_fmt) != '\0' \
117 && (rp = __strptime_internal (rp, (new_fmt), tm, &s LOCALE_ARG)) != NULL)
118
119
120 #ifdef _LIBC
121 /* This is defined in locale/C-time.c in the GNU libc. */
122 extern const struct __locale_data _nl_C_LC_TIME attribute_hidden;
123
124 # define weekday_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (DAY_1)].string)
125 # define ab_weekday_name \
126 (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (ABDAY_1)].string)
127 # define month_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (MON_1)].string)
128 # define ab_month_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (ABMON_1)].string)
129 # define alt_month_name \
130 (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (ALTMON_1)].string)
131 # define ab_alt_month_name \
132 (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (_NL_ABALTMON_1)].string)
133 # define HERE_D_T_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (D_T_FMT)].string)
134 # define HERE_D_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (D_FMT)].string)
135 # define HERE_AM_STR (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (AM_STR)].string)
136 # define HERE_PM_STR (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (PM_STR)].string)
137 # define HERE_T_FMT_AMPM \
138 (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (T_FMT_AMPM)].string)
139 # define HERE_T_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (T_FMT)].string)
140
141 # define strncasecmp(s1, s2, n) __strncasecmp (s1, s2, n)
142 #else
143 static char const weekday_name[][10] =
144 {
145 "Sunday", "Monday", "Tuesday", "Wednesday",
146 "Thursday", "Friday", "Saturday"
147 };
148 static char const ab_weekday_name[][4] =
149 {
150 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
151 };
152 static char const month_name[][10] =
153 {
154 "January", "February", "March", "April", "May", "June",
155 "July", "August", "September", "October", "November", "December"
156 };
157 static char const ab_month_name[][4] =
158 {
159 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
160 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
161 };
162 # define HERE_D_T_FMT "%a %b %e %H:%M:%S %Y"
163 # define HERE_D_FMT "%m/%d/%y"
164 # define HERE_AM_STR "AM"
165 # define HERE_PM_STR "PM"
166 # define HERE_T_FMT_AMPM "%I:%M:%S %p"
167 # define HERE_T_FMT "%H:%M:%S"
168
169 static const unsigned short int __mon_yday[2][13] =
170 {
171 /* Normal years. */
172 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
173 /* Leap years. */
174 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
175 };
176 #endif
177
178 #if defined _LIBC
179 /* We use this code also for the extended locale handling where the
180 function gets as an additional argument the locale which has to be
181 used. To access the values we have to redefine the _NL_CURRENT
182 macro. */
183 # define strptime __strptime_l
184 # undef _NL_CURRENT
185 # define _NL_CURRENT(category, item) \
186 (current->values[_NL_ITEM_INDEX (item)].string)
187 # undef _NL_CURRENT_WORD
188 # define _NL_CURRENT_WORD(category, item) \
189 (current->values[_NL_ITEM_INDEX (item)].word)
190 # define LOCALE_PARAM , locale_t locale
191 # define LOCALE_ARG , locale
192 # define HELPER_LOCALE_ARG , current
193 # define ISSPACE(Ch) __isspace_l (Ch, locale)
194 #else
195 # define LOCALE_PARAM
196 # define LOCALE_ARG
197 # define HELPER_LOCALE_ARG
198 # define ISSPACE(Ch) isspace (Ch)
199 #endif
200
201
202
203
204 #ifndef __isleap
205 /* Nonzero if YEAR is a leap year (every 4 years,
206 except every 100th isn't, and every 400th is). */
207 # define __isleap(year) \
208 ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
209 #endif
210
211 /* Compute the day of the week. */
212 static void
213 day_of_the_week (struct tm *tm)
214 {
215 /* We know that January 1st 1970 was a Thursday (= 4). Compute the
216 difference between this data in the one on TM and so determine
217 the weekday. */
218 int corr_year = 1900 + tm->tm_year - (tm->tm_mon < 2);
219 int wday = (-473
220 + (365 * (tm->tm_year - 70))
221 + (corr_year / 4)
222 - ((corr_year / 4) / 25) + ((corr_year / 4) % 25 < 0)
223 + (((corr_year / 4) / 25) / 4)
224 + __mon_yday[0][tm->tm_mon]
225 + tm->tm_mday - 1);
226 tm->tm_wday = ((wday % 7) + 7) % 7;
227 }
228
229 /* Compute the day of the year. */
230 static void
231 day_of_the_year (struct tm *tm)
232 {
233 tm->tm_yday = (__mon_yday[__isleap (1900 + tm->tm_year)][tm->tm_mon]
234 + (tm->tm_mday - 1));
235 }
236
237
238 #ifdef _LIBC
239 char *
240 #else
241 static char *
242 #endif
243 __strptime_internal (const char *rp, const char *fmt, struct tm *tmp,
244 void *statep LOCALE_PARAM)
245 {
246 #ifdef _LIBC
247 struct __locale_data *const current = locale->__locales[LC_TIME];
248 #endif
249
250 const char *rp_backup;
251 const char *rp_longest;
252 int cnt;
253 int cnt_longest;
254 size_t val;
255 size_t num_eras;
256 struct era_entry *era = NULL;
257 enum ptime_locale_status { not, loc, raw } decided_longest;
258 struct __strptime_state
259 {
260 unsigned int have_I : 1;
261 unsigned int have_wday : 1;
262 unsigned int have_yday : 1;
263 unsigned int have_mon : 1;
264 unsigned int have_mday : 1;
265 unsigned int have_uweek : 1;
266 unsigned int have_wweek : 1;
267 unsigned int is_pm : 1;
268 unsigned int want_century : 1;
269 unsigned int want_era : 1;
270 unsigned int want_xday : 1;
271 enum ptime_locale_status decided : 2;
272 signed char week_no;
273 signed char century;
274 int era_cnt;
275 } s;
276 struct tm tmb;
277 struct tm *tm;
278
279 if (statep == NULL)
280 {
281 memset (&s, 0, sizeof (s));
282 s.century = -1;
283 s.era_cnt = -1;
284 #ifdef _NL_CURRENT
285 s.decided = not;
286 #else
287 s.decided = raw;
288 #endif
289 tm = tmp;
290 }
291 else
292 {
293 s = *(struct __strptime_state *) statep;
294 tmb = *tmp;
295 tm = &tmb;
296 }
297
298 while (*fmt != '\0')
299 {
300 /* A white space in the format string matches 0 more or white
301 space in the input string. */
302 if (ISSPACE (*fmt))
303 {
304 while (ISSPACE (*rp))
305 ++rp;
306 ++fmt;
307 continue;
308 }
309
310 /* Any character but `%' must be matched by the same character
311 in the input string. */
312 if (*fmt != '%')
313 {
314 match_char (*fmt++, *rp++);
315 continue;
316 }
317
318 ++fmt;
319 /* We discard strftime modifiers. */
320 while (*fmt == '-' || *fmt == '_' || *fmt == '0'
321 || *fmt == '^' || *fmt == '#')
322 ++fmt;
323
324 /* And field width. */
325 while (*fmt >= '0' && *fmt <= '9')
326 ++fmt;
327
328 /* In some cases, modifiers are handled by adjusting state and
329 then restarting the switch statement below. */
330 start_over:
331
332 /* Make back up of current processing pointer. */
333 rp_backup = rp;
334
335 switch (*fmt++)
336 {
337 case '%':
338 /* Match the `%' character itself. */
339 match_char ('%', *rp++);
340 break;
341 case 'a':
342 case 'A':
343 /* Match day of week. */
344 rp_longest = NULL;
345 decided_longest = s.decided;
346 cnt_longest = -1;
347 for (cnt = 0; cnt < 7; ++cnt)
348 {
349 const char *trp;
350 #ifdef _NL_CURRENT
351 if (s.decided !=raw)
352 {
353 trp = rp;
354 if (match_string (_NL_CURRENT (LC_TIME, DAY_1 + cnt), trp)
355 && trp > rp_longest)
356 {
357 rp_longest = trp;
358 cnt_longest = cnt;
359 if (s.decided == not
360 && strcmp (_NL_CURRENT (LC_TIME, DAY_1 + cnt),
361 weekday_name[cnt]))
362 decided_longest = loc;
363 }
364 trp = rp;
365 if (match_string (_NL_CURRENT (LC_TIME, ABDAY_1 + cnt), trp)
366 && trp > rp_longest)
367 {
368 rp_longest = trp;
369 cnt_longest = cnt;
370 if (s.decided == not
371 && strcmp (_NL_CURRENT (LC_TIME, ABDAY_1 + cnt),
372 ab_weekday_name[cnt]))
373 decided_longest = loc;
374 }
375 }
376 #endif
377 if (s.decided != loc
378 && (((trp = rp, match_string (weekday_name[cnt], trp))
379 && trp > rp_longest)
380 || ((trp = rp, match_string (ab_weekday_name[cnt], rp))
381 && trp > rp_longest)))
382 {
383 rp_longest = trp;
384 cnt_longest = cnt;
385 decided_longest = raw;
386 }
387 }
388 if (rp_longest == NULL)
389 /* Does not match a weekday name. */
390 return NULL;
391 rp = rp_longest;
392 s.decided = decided_longest;
393 tm->tm_wday = cnt_longest;
394 s.have_wday = 1;
395 break;
396 case 'b':
397 case 'B':
398 case 'h':
399 /* Match month name. */
400 rp_longest = NULL;
401 decided_longest = s.decided;
402 cnt_longest = -1;
403 for (cnt = 0; cnt < 12; ++cnt)
404 {
405 const char *trp;
406 #ifdef _NL_CURRENT
407 if (s.decided !=raw)
408 {
409 trp = rp;
410 if (match_string (_NL_CURRENT (LC_TIME, MON_1 + cnt), trp)
411 && trp > rp_longest)
412 {
413 rp_longest = trp;
414 cnt_longest = cnt;
415 if (s.decided == not
416 && strcmp (_NL_CURRENT (LC_TIME, MON_1 + cnt),
417 month_name[cnt]))
418 decided_longest = loc;
419 }
420 trp = rp;
421 if (match_string (_NL_CURRENT (LC_TIME, ABMON_1 + cnt), trp)
422 && trp > rp_longest)
423 {
424 rp_longest = trp;
425 cnt_longest = cnt;
426 if (s.decided == not
427 && strcmp (_NL_CURRENT (LC_TIME, ABMON_1 + cnt),
428 ab_month_name[cnt]))
429 decided_longest = loc;
430 }
431 #ifdef _LIBC
432 /* Now check the alt month. */
433 trp = rp;
434 if (match_string (_NL_CURRENT (LC_TIME, ALTMON_1 + cnt), trp)
435 && trp > rp_longest)
436 {
437 rp_longest = trp;
438 cnt_longest = cnt;
439 if (s.decided == not
440 && strcmp (_NL_CURRENT (LC_TIME, ALTMON_1 + cnt),
441 alt_month_name[cnt]))
442 decided_longest = loc;
443 }
444 trp = rp;
445 if (match_string (_NL_CURRENT (LC_TIME, _NL_ABALTMON_1 + cnt),
446 trp)
447 && trp > rp_longest)
448 {
449 rp_longest = trp;
450 cnt_longest = cnt;
451 if (s.decided == not
452 && strcmp (_NL_CURRENT (LC_TIME, _NL_ABALTMON_1 + cnt),
453 alt_month_name[cnt]))
454 decided_longest = loc;
455 }
456 #endif
457 }
458 #endif
459 if (s.decided != loc
460 && (((trp = rp, match_string (month_name[cnt], trp))
461 && trp > rp_longest)
462 || ((trp = rp, match_string (ab_month_name[cnt], trp))
463 && trp > rp_longest)
464 #ifdef _LIBC
465 || ((trp = rp, match_string (alt_month_name[cnt], trp))
466 && trp > rp_longest)
467 || ((trp = rp, match_string (ab_alt_month_name[cnt], trp))
468 && trp > rp_longest)
469 #endif
470 ))
471 {
472 rp_longest = trp;
473 cnt_longest = cnt;
474 decided_longest = raw;
475 }
476 }
477 if (rp_longest == NULL)
478 /* Does not match a month name. */
479 return NULL;
480 rp = rp_longest;
481 s.decided = decided_longest;
482 tm->tm_mon = cnt_longest;
483 s.have_mon = 1;
484 s.want_xday = 1;
485 break;
486 case 'c':
487 /* Match locale's date and time format. */
488 #ifdef _NL_CURRENT
489 if (s.decided != raw)
490 {
491 if (!recursive (_NL_CURRENT (LC_TIME, D_T_FMT)))
492 {
493 if (s.decided == loc)
494 return NULL;
495 else
496 rp = rp_backup;
497 }
498 else
499 {
500 if (s.decided == not
501 && strcmp (_NL_CURRENT (LC_TIME, D_T_FMT), HERE_D_T_FMT))
502 s.decided = loc;
503 s.want_xday = 1;
504 break;
505 }
506 s.decided = raw;
507 }
508 #endif
509 if (!recursive (HERE_D_T_FMT))
510 return NULL;
511 s.want_xday = 1;
512 break;
513 case 'C':
514 /* Match century number. */
515 match_century:
516 get_number (0, 99, 2);
517 s.century = val;
518 s.want_xday = 1;
519 break;
520 case 'd':
521 case 'e':
522 /* Match day of month. */
523 get_number (1, 31, 2);
524 tm->tm_mday = val;
525 s.have_mday = 1;
526 s.want_xday = 1;
527 break;
528 case 'F':
529 if (!recursive ("%Y-%m-%d"))
530 return NULL;
531 s.want_xday = 1;
532 break;
533 case 'x':
534 #ifdef _NL_CURRENT
535 if (s.decided != raw)
536 {
537 if (!recursive (_NL_CURRENT (LC_TIME, D_FMT)))
538 {
539 if (s.decided == loc)
540 return NULL;
541 else
542 rp = rp_backup;
543 }
544 else
545 {
546 if (s.decided == not
547 && strcmp (_NL_CURRENT (LC_TIME, D_FMT), HERE_D_FMT))
548 s.decided = loc;
549 s.want_xday = 1;
550 break;
551 }
552 s.decided = raw;
553 }
554 #endif
555 /* Fall through. */
556 case 'D':
557 /* Match standard day format. */
558 if (!recursive (HERE_D_FMT))
559 return NULL;
560 s.want_xday = 1;
561 break;
562 case 'k':
563 case 'H':
564 /* Match hour in 24-hour clock. */
565 get_number (0, 23, 2);
566 tm->tm_hour = val;
567 s.have_I = 0;
568 break;
569 case 'l':
570 /* Match hour in 12-hour clock. GNU extension. */
571 case 'I':
572 /* Match hour in 12-hour clock. */
573 get_number (1, 12, 2);
574 tm->tm_hour = val % 12;
575 s.have_I = 1;
576 break;
577 case 'j':
578 /* Match day number of year. */
579 get_number (1, 366, 3);
580 tm->tm_yday = val - 1;
581 s.have_yday = 1;
582 break;
583 case 'm':
584 /* Match number of month. */
585 get_number (1, 12, 2);
586 tm->tm_mon = val - 1;
587 s.have_mon = 1;
588 s.want_xday = 1;
589 break;
590 case 'M':
591 /* Match minute. */
592 get_number (0, 59, 2);
593 tm->tm_min = val;
594 break;
595 case 'n':
596 case 't':
597 /* Match any white space. */
598 while (ISSPACE (*rp))
599 ++rp;
600 break;
601 case 'p':
602 /* Match locale's equivalent of AM/PM. */
603 #ifdef _NL_CURRENT
604 if (s.decided != raw)
605 {
606 if (match_string (_NL_CURRENT (LC_TIME, AM_STR), rp))
607 {
608 if (strcmp (_NL_CURRENT (LC_TIME, AM_STR), HERE_AM_STR))
609 s.decided = loc;
610 s.is_pm = 0;
611 break;
612 }
613 if (match_string (_NL_CURRENT (LC_TIME, PM_STR), rp))
614 {
615 if (strcmp (_NL_CURRENT (LC_TIME, PM_STR), HERE_PM_STR))
616 s.decided = loc;
617 s.is_pm = 1;
618 break;
619 }
620 s.decided = raw;
621 }
622 #endif
623 if (!match_string (HERE_AM_STR, rp))
624 {
625 if (match_string (HERE_PM_STR, rp))
626 s.is_pm = 1;
627 else
628 return NULL;
629 }
630 else
631 s.is_pm = 0;
632 break;
633 case 'r':
634 #ifdef _NL_CURRENT
635 if (s.decided != raw)
636 {
637 if (!recursive (_NL_CURRENT (LC_TIME, T_FMT_AMPM)))
638 {
639 if (s.decided == loc)
640 return NULL;
641 else
642 rp = rp_backup;
643 }
644 else
645 {
646 if (s.decided == not
647 && strcmp (_NL_CURRENT (LC_TIME, T_FMT_AMPM),
648 HERE_T_FMT_AMPM))
649 s.decided = loc;
650 break;
651 }
652 s.decided = raw;
653 }
654 #endif
655 if (!recursive (HERE_T_FMT_AMPM))
656 return NULL;
657 break;
658 case 'R':
659 if (!recursive ("%H:%M"))
660 return NULL;
661 break;
662 case 's':
663 {
664 /* The number of seconds may be very high so we cannot use
665 the `get_number' macro. Instead read the number
666 character for character and construct the result while
667 doing this. */
668 time_t secs = 0;
669 if (*rp < '0' || *rp > '9')
670 /* We need at least one digit. */
671 return NULL;
672
673 do
674 {
675 secs *= 10;
676 secs += *rp++ - '0';
677 }
678 while (*rp >= '0' && *rp <= '9');
679
680 if (localtime_r (&secs, tm) == NULL)
681 /* Error in function. */
682 return NULL;
683 }
684 break;
685 case 'S':
686 get_number (0, 61, 2);
687 tm->tm_sec = val;
688 break;
689 case 'X':
690 #ifdef _NL_CURRENT
691 if (s.decided != raw)
692 {
693 if (!recursive (_NL_CURRENT (LC_TIME, T_FMT)))
694 {
695 if (s.decided == loc)
696 return NULL;
697 else
698 rp = rp_backup;
699 }
700 else
701 {
702 if (strcmp (_NL_CURRENT (LC_TIME, T_FMT), HERE_T_FMT))
703 s.decided = loc;
704 break;
705 }
706 s.decided = raw;
707 }
708 #endif
709 /* Fall through. */
710 case 'T':
711 if (!recursive (HERE_T_FMT))
712 return NULL;
713 break;
714 case 'u':
715 get_number (1, 7, 1);
716 tm->tm_wday = val % 7;
717 s.have_wday = 1;
718 break;
719 case 'g':
720 get_number (0, 99, 2);
721 /* XXX This cannot determine any field in TM. */
722 break;
723 case 'G':
724 if (*rp < '0' || *rp > '9')
725 return NULL;
726 /* XXX Ignore the number since we would need some more
727 information to compute a real date. */
728 do
729 ++rp;
730 while (*rp >= '0' && *rp <= '9');
731 break;
732 case 'U':
733 get_number (0, 53, 2);
734 s.week_no = val;
735 s.have_uweek = 1;
736 break;
737 case 'W':
738 get_number (0, 53, 2);
739 s.week_no = val;
740 s.have_wweek = 1;
741 break;
742 case 'V':
743 get_number (0, 53, 2);
744 /* XXX This cannot determine any field in TM without some
745 information. */
746 break;
747 case 'w':
748 /* Match number of weekday. */
749 get_number (0, 6, 1);
750 tm->tm_wday = val;
751 s.have_wday = 1;
752 break;
753 case 'y':
754 match_year_in_century:
755 /* Match year within century. */
756 get_number (0, 99, 2);
757 /* The "Year 2000: The Millennium Rollover" paper suggests that
758 values in the range 69-99 refer to the twentieth century. */
759 tm->tm_year = val >= 69 ? val : val + 100;
760 /* Indicate that we want to use the century, if specified. */
761 s.want_century = 1;
762 s.want_xday = 1;
763 break;
764 case 'Y':
765 /* Match year including century number. */
766 get_number (0, 9999, 4);
767 tm->tm_year = val - 1900;
768 s.want_century = 0;
769 s.want_xday = 1;
770 break;
771 case 'Z':
772 /* Read timezone but perform no conversion. */
773 while (ISSPACE (*rp))
774 rp++;
775 while (!ISSPACE (*rp) && *rp != '\0')
776 rp++;
777 break;
778 case 'z':
779 /* We recognize four formats:
780 1. Two digits specify hours.
781 2. Four digits specify hours and minutes.
782 3. Two digits, ':', and two digits specify hours and minutes.
783 4. 'Z' is equivalent to +0000. */
784 {
785 val = 0;
786 while (ISSPACE (*rp))
787 ++rp;
788 if (*rp == 'Z')
789 {
790 ++rp;
791 tm->tm_gmtoff = 0;
792 break;
793 }
794 if (*rp != '+' && *rp != '-')
795 return NULL;
796 bool neg = *rp++ == '-';
797 int n = 0;
798 while (n < 4 && *rp >= '0' && *rp <= '9')
799 {
800 val = val * 10 + *rp++ - '0';
801 ++n;
802 if (*rp == ':' && n == 2 && isdigit (*(rp + 1)))
803 ++rp;
804 }
805 if (n == 2)
806 val *= 100;
807 else if (n != 4)
808 /* Only two or four digits recognized. */
809 return NULL;
810 else if (val % 100 >= 60)
811 /* Minutes valid range is 0 through 59. */
812 return NULL;
813 tm->tm_gmtoff = (val / 100) * 3600 + (val % 100) * 60;
814 if (neg)
815 tm->tm_gmtoff = -tm->tm_gmtoff;
816 }
817 break;
818 case 'E':
819 #ifdef _NL_CURRENT
820 switch (*fmt++)
821 {
822 case 'c':
823 /* Match locale's alternate date and time format. */
824 if (s.decided != raw)
825 {
826 const char *fmt = _NL_CURRENT (LC_TIME, ERA_D_T_FMT);
827
828 if (*fmt == '\0')
829 fmt = _NL_CURRENT (LC_TIME, D_T_FMT);
830
831 if (!recursive (fmt))
832 {
833 if (s.decided == loc)
834 return NULL;
835 else
836 rp = rp_backup;
837 }
838 else
839 {
840 if (strcmp (fmt, HERE_D_T_FMT))
841 s.decided = loc;
842 s.want_xday = 1;
843 break;
844 }
845 s.decided = raw;
846 }
847 /* The C locale has no era information, so use the
848 normal representation. */
849 if (!recursive (HERE_D_T_FMT))
850 return NULL;
851 s.want_xday = 1;
852 break;
853 case 'C':
854 if (s.decided != raw)
855 {
856 if (s.era_cnt >= 0)
857 {
858 era = _nl_select_era_entry (s.era_cnt HELPER_LOCALE_ARG);
859 if (era != NULL && match_string (era->era_name, rp))
860 {
861 s.decided = loc;
862 break;
863 }
864 else
865 return NULL;
866 }
867
868 num_eras = _NL_CURRENT_WORD (LC_TIME,
869 _NL_TIME_ERA_NUM_ENTRIES);
870 for (s.era_cnt = 0; s.era_cnt < (int) num_eras;
871 ++s.era_cnt, rp = rp_backup)
872 {
873 era = _nl_select_era_entry (s.era_cnt
874 HELPER_LOCALE_ARG);
875 if (era != NULL && match_string (era->era_name, rp))
876 {
877 s.decided = loc;
878 break;
879 }
880 }
881 if (s.era_cnt != (int) num_eras)
882 break;
883
884 s.era_cnt = -1;
885 if (s.decided == loc)
886 return NULL;
887
888 s.decided = raw;
889 }
890 /* The C locale has no era information, so use the
891 normal representation. */
892 goto match_century;
893 case 'y':
894 if (s.decided != raw)
895 {
896 get_number(0, 9999, 4);
897 tm->tm_year = val;
898 s.want_era = 1;
899 s.want_xday = 1;
900 s.want_century = 1;
901
902 if (s.era_cnt >= 0)
903 {
904 assert (s.decided == loc);
905
906 era = _nl_select_era_entry (s.era_cnt HELPER_LOCALE_ARG);
907 bool match = false;
908 if (era != NULL)
909 {
910 int delta = ((tm->tm_year - era->offset)
911 * era->absolute_direction);
912 /* The difference between two sets of years
913 does not include the final year itself,
914 therefore add 1 to the difference to
915 account for that final year. */
916 match = (delta >= 0
917 && delta < (((int64_t) era->stop_date[0]
918 - (int64_t) era->start_date[0])
919 * era->absolute_direction
920 + 1));
921 }
922 if (! match)
923 return NULL;
924
925 break;
926 }
927
928 num_eras = _NL_CURRENT_WORD (LC_TIME,
929 _NL_TIME_ERA_NUM_ENTRIES);
930 for (s.era_cnt = 0; s.era_cnt < (int) num_eras; ++s.era_cnt)
931 {
932 era = _nl_select_era_entry (s.era_cnt
933 HELPER_LOCALE_ARG);
934 if (era != NULL)
935 {
936 int delta = ((tm->tm_year - era->offset)
937 * era->absolute_direction);
938 /* See comment above about year difference + 1. */
939 if (delta >= 0
940 && delta < (((int64_t) era->stop_date[0]
941 - (int64_t) era->start_date[0])
942 * era->absolute_direction
943 + 1))
944 {
945 s.decided = loc;
946 break;
947 }
948 }
949 }
950 if (s.era_cnt != (int) num_eras)
951 break;
952
953 s.era_cnt = -1;
954 if (s.decided == loc)
955 return NULL;
956
957 s.decided = raw;
958 }
959
960 goto match_year_in_century;
961 case 'Y':
962 if (s.decided != raw)
963 {
964 num_eras = _NL_CURRENT_WORD (LC_TIME,
965 _NL_TIME_ERA_NUM_ENTRIES);
966 for (s.era_cnt = 0; s.era_cnt < (int) num_eras;
967 ++s.era_cnt, rp = rp_backup)
968 {
969 era = _nl_select_era_entry (s.era_cnt HELPER_LOCALE_ARG);
970 if (era != NULL && recursive (era->era_format))
971 break;
972 }
973 if (s.era_cnt == (int) num_eras)
974 {
975 s.era_cnt = -1;
976 if (s.decided == loc)
977 return NULL;
978 else
979 rp = rp_backup;
980 }
981 else
982 {
983 s.decided = loc;
984 break;
985 }
986
987 s.decided = raw;
988 }
989 get_number (0, 9999, 4);
990 tm->tm_year = val - 1900;
991 s.want_century = 0;
992 s.want_xday = 1;
993 break;
994 case 'x':
995 if (s.decided != raw)
996 {
997 const char *fmt = _NL_CURRENT (LC_TIME, ERA_D_FMT);
998
999 if (*fmt == '\0')
1000 fmt = _NL_CURRENT (LC_TIME, D_FMT);
1001
1002 if (!recursive (fmt))
1003 {
1004 if (s.decided == loc)
1005 return NULL;
1006 else
1007 rp = rp_backup;
1008 }
1009 else
1010 {
1011 if (strcmp (fmt, HERE_D_FMT))
1012 s.decided = loc;
1013 break;
1014 }
1015 s.decided = raw;
1016 }
1017 if (!recursive (HERE_D_FMT))
1018 return NULL;
1019 break;
1020 case 'X':
1021 if (s.decided != raw)
1022 {
1023 const char *fmt = _NL_CURRENT (LC_TIME, ERA_T_FMT);
1024
1025 if (*fmt == '\0')
1026 fmt = _NL_CURRENT (LC_TIME, T_FMT);
1027
1028 if (!recursive (fmt))
1029 {
1030 if (s.decided == loc)
1031 return NULL;
1032 else
1033 rp = rp_backup;
1034 }
1035 else
1036 {
1037 if (strcmp (fmt, HERE_T_FMT))
1038 s.decided = loc;
1039 break;
1040 }
1041 s.decided = raw;
1042 }
1043 if (!recursive (HERE_T_FMT))
1044 return NULL;
1045 break;
1046 default:
1047 return NULL;
1048 }
1049 break;
1050 #else
1051 /* We have no information about the era format. Just use
1052 the normal format. */
1053 if (*fmt != 'c' && *fmt != 'C' && *fmt != 'y' && *fmt != 'Y'
1054 && *fmt != 'x' && *fmt != 'X')
1055 /* This is an illegal format. */
1056 return NULL;
1057
1058 goto start_over;
1059 #endif
1060 case 'O':
1061 switch (*fmt++)
1062 {
1063 case 'b':
1064 case 'B':
1065 case 'h':
1066 /* Match month name. Reprocess as plain 'B'. */
1067 fmt--;
1068 goto start_over;
1069 case 'd':
1070 case 'e':
1071 /* Match day of month using alternate numeric symbols. */
1072 get_alt_number (1, 31, 2);
1073 tm->tm_mday = val;
1074 s.have_mday = 1;
1075 s.want_xday = 1;
1076 break;
1077 case 'H':
1078 /* Match hour in 24-hour clock using alternate numeric
1079 symbols. */
1080 get_alt_number (0, 23, 2);
1081 tm->tm_hour = val;
1082 s.have_I = 0;
1083 break;
1084 case 'I':
1085 /* Match hour in 12-hour clock using alternate numeric
1086 symbols. */
1087 get_alt_number (1, 12, 2);
1088 tm->tm_hour = val % 12;
1089 s.have_I = 1;
1090 break;
1091 case 'm':
1092 /* Match month using alternate numeric symbols. */
1093 get_alt_number (1, 12, 2);
1094 tm->tm_mon = val - 1;
1095 s.have_mon = 1;
1096 s.want_xday = 1;
1097 break;
1098 case 'M':
1099 /* Match minutes using alternate numeric symbols. */
1100 get_alt_number (0, 59, 2);
1101 tm->tm_min = val;
1102 break;
1103 case 'S':
1104 /* Match seconds using alternate numeric symbols. */
1105 get_alt_number (0, 61, 2);
1106 tm->tm_sec = val;
1107 break;
1108 case 'U':
1109 get_alt_number (0, 53, 2);
1110 s.week_no = val;
1111 s.have_uweek = 1;
1112 break;
1113 case 'W':
1114 get_alt_number (0, 53, 2);
1115 s.week_no = val;
1116 s.have_wweek = 1;
1117 break;
1118 case 'V':
1119 get_alt_number (0, 53, 2);
1120 /* XXX This cannot determine any field in TM without
1121 further information. */
1122 break;
1123 case 'w':
1124 /* Match number of weekday using alternate numeric symbols. */
1125 get_alt_number (0, 6, 1);
1126 tm->tm_wday = val;
1127 s.have_wday = 1;
1128 break;
1129 case 'y':
1130 /* Match year within century using alternate numeric symbols. */
1131 get_alt_number (0, 99, 2);
1132 tm->tm_year = val >= 69 ? val : val + 100;
1133 s.want_xday = 1;
1134 break;
1135 default:
1136 return NULL;
1137 }
1138 break;
1139 default:
1140 return NULL;
1141 }
1142 }
1143
1144 if (statep != NULL)
1145 {
1146 /* Recursive invocation, returning success, so
1147 update parent's struct tm and state. */
1148 *(struct __strptime_state *) statep = s;
1149 *tmp = tmb;
1150 return (char *) rp;
1151 }
1152
1153 if (s.have_I && s.is_pm)
1154 tm->tm_hour += 12;
1155
1156 if (s.century != -1)
1157 {
1158 if (s.want_century)
1159 tm->tm_year = tm->tm_year % 100 + (s.century - 19) * 100;
1160 else
1161 /* Only the century, but not the year. Strange, but so be it. */
1162 tm->tm_year = (s.century - 19) * 100;
1163 }
1164
1165 if (s.era_cnt != -1)
1166 {
1167 era = _nl_select_era_entry (s.era_cnt HELPER_LOCALE_ARG);
1168 if (era == NULL)
1169 return NULL;
1170 if (s.want_era)
1171 tm->tm_year = (era->start_date[0]
1172 + ((tm->tm_year - era->offset)
1173 * era->absolute_direction));
1174 else
1175 /* Era start year assumed. */
1176 tm->tm_year = era->start_date[0];
1177 }
1178 else
1179 if (s.want_era)
1180 {
1181 /* No era found but we have seen an E modifier. Rectify some
1182 values. */
1183 if (s.want_century && s.century == -1 && tm->tm_year < 69)
1184 tm->tm_year += 100;
1185 }
1186
1187 if (s.want_xday && !s.have_wday)
1188 {
1189 if ( !(s.have_mon && s.have_mday) && s.have_yday)
1190 {
1191 /* We don't have tm_mon and/or tm_mday, compute them. */
1192 int t_mon = 0;
1193 while (__mon_yday[__isleap(1900 + tm->tm_year)][t_mon] <= tm->tm_yday)
1194 t_mon++;
1195 if (!s.have_mon)
1196 tm->tm_mon = t_mon - 1;
1197 if (!s.have_mday)
1198 tm->tm_mday =
1199 (tm->tm_yday
1200 - __mon_yday[__isleap(1900 + tm->tm_year)][t_mon - 1] + 1);
1201 s.have_mon = 1;
1202 s.have_mday = 1;
1203 }
1204 /* Don't crash in day_of_the_week if tm_mon is uninitialized. */
1205 if (s.have_mon || (unsigned) tm->tm_mon <= 11)
1206 day_of_the_week (tm);
1207 }
1208
1209 if (s.want_xday && !s.have_yday && (s.have_mon || (unsigned) tm->tm_mon <= 11))
1210 day_of_the_year (tm);
1211
1212 if ((s.have_uweek || s.have_wweek) && s.have_wday)
1213 {
1214 int save_wday = tm->tm_wday;
1215 int save_mday = tm->tm_mday;
1216 int save_mon = tm->tm_mon;
1217 int w_offset = s.have_uweek ? 0 : 1;
1218
1219 tm->tm_mday = 1;
1220 tm->tm_mon = 0;
1221 day_of_the_week (tm);
1222 if (s.have_mday)
1223 tm->tm_mday = save_mday;
1224 if (s.have_mon)
1225 tm->tm_mon = save_mon;
1226
1227 if (!s.have_yday)
1228 tm->tm_yday = ((7 - (tm->tm_wday - w_offset)) % 7
1229 + (s.week_no - 1) * 7
1230 + (save_wday - w_offset + 7) % 7);
1231
1232 if (!s.have_mday || !s.have_mon)
1233 {
1234 int t_mon = 0;
1235 while (__mon_yday[__isleap(1900 + tm->tm_year)][t_mon]
1236 <= tm->tm_yday)
1237 t_mon++;
1238 if (!s.have_mon)
1239 tm->tm_mon = t_mon - 1;
1240 if (!s.have_mday)
1241 tm->tm_mday =
1242 (tm->tm_yday
1243 - __mon_yday[__isleap(1900 + tm->tm_year)][t_mon - 1] + 1);
1244 }
1245
1246 tm->tm_wday = save_wday;
1247 }
1248
1249 return (char *) rp;
1250 }
1251
1252
1253 char *
1254 strptime (const char *buf, const char *format, struct tm *tm LOCALE_PARAM)
1255 {
1256 return __strptime_internal (buf, format, tm, NULL LOCALE_ARG);
1257 }
1258
1259 #ifdef _LIBC
1260 weak_alias (__strptime_l, strptime_l)
1261 #endif
sources.redhat.com git mirror of glibc CVS