?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
s4:scripting/python: always treat the highwatermark as opaque (bug #9508)
[Samba/gebeck_regimport.git] / lib / replace / strptime.c
blob20e5d8c39b6a2acc0189ad8fcb5ddf11285b0f52
1 /* Convert a string representation of time to a time value.
2 Copyright (C) 1996, 1997, 1998, 1999, 2000 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4 Contributed by Ulrich Drepper <drepper@cygnus.com>, 1996.
5
6 The GNU C Library is free software; you can redistribute it and/or
7 modify it under the terms of the GNU Lesser General Public License as
8 published by the Free Software Foundation; either version 3 of the
9 License, or (at your option) any later version.
10
11 The GNU C Library 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 GNU
14 Library General Public License for more details.
15
16 You should have received a copy of the GNU Lesser General Public
17 License along with the GNU C Library; see the file COPYING.LIB. If not,
18 see <http://www.gnu.org/licenses/>. */
19
20 /* XXX This version of the implementation is not really complete.
21 Some of the fields cannot add information alone. But if seeing
22 some of them in the same format (such as year, week and weekday)
23 this is enough information for determining the date. */
24
25 #include "replace.h"
26 #include "system/locale.h"
27 #include "system/time.h"
28
29 #ifndef __P
30 # if defined (__GNUC__) || (defined (__STDC__) && __STDC__)
31 # define __P(args) args
32 # else
33 # define __P(args) ()
34 # endif /* GCC. */
35 #endif /* Not __P. */
36
37 #if ! HAVE_LOCALTIME_R && ! defined localtime_r
38 # ifdef _LIBC
39 # define localtime_r __localtime_r
40 # else
41 /* Approximate localtime_r as best we can in its absence. */
42 # define localtime_r my_localtime_r
43 static struct tm *localtime_r __P ((const time_t *, struct tm *));
44 static struct tm *
45 localtime_r (t, tp)
46 const time_t *t;
47 struct tm *tp;
48 {
49 struct tm *l = localtime (t);
50 if (! l)
51 return 0;
52 *tp = *l;
53 return tp;
54 }
55 # endif /* ! _LIBC */
56 #endif /* ! HAVE_LOCALTIME_R && ! defined (localtime_r) */
57
58
59 #define match_char(ch1, ch2) if (ch1 != ch2) return NULL
60 #if defined __GNUC__ && __GNUC__ >= 2
61 # define match_string(cs1, s2) \
62 ({ size_t len = strlen (cs1); \
63 int result = strncasecmp ((cs1), (s2), len) == 0; \
64 if (result) (s2) += len; \
65 result; })
66 #else
67 /* Oh come on. Get a reasonable compiler. */
68 # define match_string(cs1, s2) \
69 (strncasecmp ((cs1), (s2), strlen (cs1)) ? 0 : ((s2) += strlen (cs1), 1))
70 #endif
71 /* We intentionally do not use isdigit() for testing because this will
72 lead to problems with the wide character version. */
73 #define get_number(from, to, n) \
74 do { \
75 int __n = n; \
76 val = 0; \
77 while (*rp == ' ') \
78 ++rp; \
79 if (*rp < '0' || *rp > '9') \
80 return NULL; \
81 do { \
82 val *= 10; \
83 val += *rp++ - '0'; \
84 } while (--__n > 0 && val * 10 <= to && *rp >= '0' && *rp <= '9'); \
85 if (val < from || val > to) \
86 return NULL; \
87 } while (0)
88 #ifdef _NL_CURRENT
89 # define get_alt_number(from, to, n) \
90 ({ \
91 __label__ do_normal; \
92 if (*decided != raw) \
93 { \
94 const char *alts = _NL_CURRENT (LC_TIME, ALT_DIGITS); \
95 int __n = n; \
96 int any = 0; \
97 while (*rp == ' ') \
98 ++rp; \
99 val = 0; \
100 do { \
101 val *= 10; \
102 while (*alts != '\0') \
103 { \
104 size_t len = strlen (alts); \
105 if (strncasecmp (alts, rp, len) == 0) \
106 break; \
107 alts += len + 1; \
108 ++val; \
109 } \
110 if (*alts == '\0') \
111 { \
112 if (*decided == not && ! any) \
113 goto do_normal; \
114 /* If we haven't read anything it's an error. */ \
115 if (! any) \
116 return NULL; \
117 /* Correct the premature multiplication. */ \
118 val /= 10; \
119 break; \
120 } \
121 else \
122 *decided = loc; \
123 } while (--__n > 0 && val * 10 <= to); \
124 if (val < from || val > to) \
125 return NULL; \
126 } \
127 else \
128 { \
129 do_normal: \
130 get_number (from, to, n); \
131 } \
132 0; \
133 })
134 #else
135 # define get_alt_number(from, to, n) \
136 /* We don't have the alternate representation. */ \
137 get_number(from, to, n)
138 #endif
139 #define recursive(new_fmt) \
140 (*(new_fmt) != '\0' \
141 && (rp = strptime_internal (rp, (new_fmt), tm, decided, era_cnt)) != NULL)
142
143
144 #ifdef _LIBC
145 /* This is defined in locale/C-time.c in the GNU libc. */
146 extern const struct locale_data _nl_C_LC_TIME;
147 extern const unsigned short int __mon_yday[2][13];
148
149 # define weekday_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (DAY_1)].string)
150 # define ab_weekday_name \
151 (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (ABDAY_1)].string)
152 # define month_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (MON_1)].string)
153 # define ab_month_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (ABMON_1)].string)
154 # define HERE_D_T_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (D_T_FMT)].string)
155 # define HERE_D_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (D_FMT)].string)
156 # define HERE_AM_STR (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (AM_STR)].string)
157 # define HERE_PM_STR (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (PM_STR)].string)
158 # define HERE_T_FMT_AMPM \
159 (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (T_FMT_AMPM)].string)
160 # define HERE_T_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (T_FMT)].string)
161
162 # define strncasecmp(s1, s2, n) __strncasecmp (s1, s2, n)
163 #else
164 static char const weekday_name[][10] =
165 {
166 "Sunday", "Monday", "Tuesday", "Wednesday",
167 "Thursday", "Friday", "Saturday"
168 };
169 static char const ab_weekday_name[][4] =
170 {
171 "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
172 };
173 static char const month_name[][10] =
174 {
175 "January", "February", "March", "April", "May", "June",
176 "July", "August", "September", "October", "November", "December"
177 };
178 static char const ab_month_name[][4] =
179 {
180 "Jan", "Feb", "Mar", "Apr", "May", "Jun",
181 "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
182 };
183 # define HERE_D_T_FMT "%a %b %e %H:%M:%S %Y"
184 # define HERE_D_FMT "%m/%d/%y"
185 # define HERE_AM_STR "AM"
186 # define HERE_PM_STR "PM"
187 # define HERE_T_FMT_AMPM "%I:%M:%S %p"
188 # define HERE_T_FMT "%H:%M:%S"
189
190 static const unsigned short int __mon_yday[2][13] =
191 {
192 /* Normal years. */
193 { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
194 /* Leap years. */
195 { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
196 };
197 #endif
198
199 /* Status of lookup: do we use the locale data or the raw data? */
200 enum locale_status { not, loc, raw };
201
202
203 #ifndef __isleap
204 /* Nonzero if YEAR is a leap year (every 4 years,
205 except every 100th isn't, and every 400th is). */
206 # define __isleap(year) \
207 ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
208 #endif
209
210 /* Compute the day of the week. */
211 static void
212 day_of_the_week (struct tm *tm)
213 {
214 /* We know that January 1st 1970 was a Thursday (= 4). Compute the
215 the difference between this data in the one on TM and so determine
216 the weekday. */
217 int corr_year = 1900 + tm->tm_year - (tm->tm_mon < 2);
218 int wday = (-473
219 + (365 * (tm->tm_year - 70))
220 + (corr_year / 4)
221 - ((corr_year / 4) / 25) + ((corr_year / 4) % 25 < 0)
222 + (((corr_year / 4) / 25) / 4)
223 + __mon_yday[0][tm->tm_mon]
224 + tm->tm_mday - 1);
225 tm->tm_wday = ((wday % 7) + 7) % 7;
226 }
227
228 /* Compute the day of the year. */
229 static void
230 day_of_the_year (struct tm *tm)
231 {
232 tm->tm_yday = (__mon_yday[__isleap (1900 + tm->tm_year)][tm->tm_mon]
233 + (tm->tm_mday - 1));
234 }
235
236 static char *
237 #ifdef _LIBC
238 internal_function
239 #endif
240 strptime_internal __P ((const char *rp, const char *fmt, struct tm *tm,
241 enum locale_status *decided, int era_cnt));
242
243 static char *
244 #ifdef _LIBC
245 internal_function
246 #endif
247 strptime_internal (rp, fmt, tm, decided, era_cnt)
248 const char *rp;
249 const char *fmt;
250 struct tm *tm;
251 enum locale_status *decided;
252 int era_cnt;
253 {
254 int cnt;
255 size_t val;
256 int have_I, is_pm;
257 int century, want_century;
258 int want_era;
259 int have_wday, want_xday;
260 int have_yday;
261 int have_mon, have_mday;
262 #ifdef _NL_CURRENT
263 const char *rp_backup;
264 size_t num_eras;
265 struct era_entry *era;
266
267 era = NULL;
268 #endif
269
270 have_I = is_pm = 0;
271 century = -1;
272 want_century = 0;
273 want_era = 0;
274
275 have_wday = want_xday = have_yday = have_mon = have_mday = 0;
276
277 while (*fmt != '\0')
278 {
279 /* A white space in the format string matches 0 more or white
280 space in the input string. */
281 if (isspace (*fmt))
282 {
283 while (isspace (*rp))
284 ++rp;
285 ++fmt;
286 continue;
287 }
288
289 /* Any character but `%' must be matched by the same character
290 in the iput string. */
291 if (*fmt != '%')
292 {
293 match_char (*fmt++, *rp++);
294 continue;
295 }
296
297 ++fmt;
298 #ifndef _NL_CURRENT
299 /* We need this for handling the `E' modifier. */
300 start_over:
301 #endif
302
303 #ifdef _NL_CURRENT
304 /* Make back up of current processing pointer. */
305 rp_backup = rp;
306 #endif
307
308 switch (*fmt++)
309 {
310 case '%':
311 /* Match the `%' character itself. */
312 match_char ('%', *rp++);
313 break;
314 case 'a':
315 case 'A':
316 /* Match day of week. */
317 for (cnt = 0; cnt < 7; ++cnt)
318 {
319 #ifdef _NL_CURRENT
320 if (*decided !=raw)
321 {
322 if (match_string (_NL_CURRENT (LC_TIME, DAY_1 + cnt), rp))
323 {
324 if (*decided == not
325 && strcmp (_NL_CURRENT (LC_TIME, DAY_1 + cnt),
326 weekday_name[cnt]))
327 *decided = loc;
328 break;
329 }
330 if (match_string (_NL_CURRENT (LC_TIME, ABDAY_1 + cnt), rp))
331 {
332 if (*decided == not
333 && strcmp (_NL_CURRENT (LC_TIME, ABDAY_1 + cnt),
334 ab_weekday_name[cnt]))
335 *decided = loc;
336 break;
337 }
338 }
339 #endif
340 if (*decided != loc
341 && (match_string (weekday_name[cnt], rp)
342 || match_string (ab_weekday_name[cnt], rp)))
343 {
344 *decided = raw;
345 break;
346 }
347 }
348 if (cnt == 7)
349 /* Does not match a weekday name. */
350 return NULL;
351 tm->tm_wday = cnt;
352 have_wday = 1;
353 break;
354 case 'b':
355 case 'B':
356 case 'h':
357 /* Match month name. */
358 for (cnt = 0; cnt < 12; ++cnt)
359 {
360 #ifdef _NL_CURRENT
361 if (*decided !=raw)
362 {
363 if (match_string (_NL_CURRENT (LC_TIME, MON_1 + cnt), rp))
364 {
365 if (*decided == not
366 && strcmp (_NL_CURRENT (LC_TIME, MON_1 + cnt),
367 month_name[cnt]))
368 *decided = loc;
369 break;
370 }
371 if (match_string (_NL_CURRENT (LC_TIME, ABMON_1 + cnt), rp))
372 {
373 if (*decided == not
374 && strcmp (_NL_CURRENT (LC_TIME, ABMON_1 + cnt),
375 ab_month_name[cnt]))
376 *decided = loc;
377 break;
378 }
379 }
380 #endif
381 if (match_string (month_name[cnt], rp)
382 || match_string (ab_month_name[cnt], rp))
383 {
384 *decided = raw;
385 break;
386 }
387 }
388 if (cnt == 12)
389 /* Does not match a month name. */
390 return NULL;
391 tm->tm_mon = cnt;
392 want_xday = 1;
393 break;
394 case 'c':
395 /* Match locale's date and time format. */
396 #ifdef _NL_CURRENT
397 if (*decided != raw)
398 {
399 if (!recursive (_NL_CURRENT (LC_TIME, D_T_FMT)))
400 {
401 if (*decided == loc)
402 return NULL;
403 else
404 rp = rp_backup;
405 }
406 else
407 {
408 if (*decided == not &&
409 strcmp (_NL_CURRENT (LC_TIME, D_T_FMT), HERE_D_T_FMT))
410 *decided = loc;
411 want_xday = 1;
412 break;
413 }
414 *decided = raw;
415 }
416 #endif
417 if (!recursive (HERE_D_T_FMT))
418 return NULL;
419 want_xday = 1;
420 break;
421 case 'C':
422 /* Match century number. */
423 #ifdef _NL_CURRENT
424 match_century:
425 #endif
426 get_number (0, 99, 2);
427 century = val;
428 want_xday = 1;
429 break;
430 case 'd':
431 case 'e':
432 /* Match day of month. */
433 get_number (1, 31, 2);
434 tm->tm_mday = val;
435 have_mday = 1;
436 want_xday = 1;
437 break;
438 case 'F':
439 if (!recursive ("%Y-%m-%d"))
440 return NULL;
441 want_xday = 1;
442 break;
443 case 'x':
444 #ifdef _NL_CURRENT
445 if (*decided != raw)
446 {
447 if (!recursive (_NL_CURRENT (LC_TIME, D_FMT)))
448 {
449 if (*decided == loc)
450 return NULL;
451 else
452 rp = rp_backup;
453 }
454 else
455 {
456 if (*decided == not
457 && strcmp (_NL_CURRENT (LC_TIME, D_FMT), HERE_D_FMT))
458 *decided = loc;
459 want_xday = 1;
460 break;
461 }
462 *decided = raw;
463 }
464 #endif
465 /* Fall through. */
466 case 'D':
467 /* Match standard day format. */
468 if (!recursive (HERE_D_FMT))
469 return NULL;
470 want_xday = 1;
471 break;
472 case 'k':
473 case 'H':
474 /* Match hour in 24-hour clock. */
475 get_number (0, 23, 2);
476 tm->tm_hour = val;
477 have_I = 0;
478 break;
479 case 'I':
480 /* Match hour in 12-hour clock. */
481 get_number (1, 12, 2);
482 tm->tm_hour = val % 12;
483 have_I = 1;
484 break;
485 case 'j':
486 /* Match day number of year. */
487 get_number (1, 366, 3);
488 tm->tm_yday = val - 1;
489 have_yday = 1;
490 break;
491 case 'm':
492 /* Match number of month. */
493 get_number (1, 12, 2);
494 tm->tm_mon = val - 1;
495 have_mon = 1;
496 want_xday = 1;
497 break;
498 case 'M':
499 /* Match minute. */
500 get_number (0, 59, 2);
501 tm->tm_min = val;
502 break;
503 case 'n':
504 case 't':
505 /* Match any white space. */
506 while (isspace (*rp))
507 ++rp;
508 break;
509 case 'p':
510 /* Match locale's equivalent of AM/PM. */
511 #ifdef _NL_CURRENT
512 if (*decided != raw)
513 {
514 if (match_string (_NL_CURRENT (LC_TIME, AM_STR), rp))
515 {
516 if (strcmp (_NL_CURRENT (LC_TIME, AM_STR), HERE_AM_STR))
517 *decided = loc;
518 break;
519 }
520 if (match_string (_NL_CURRENT (LC_TIME, PM_STR), rp))
521 {
522 if (strcmp (_NL_CURRENT (LC_TIME, PM_STR), HERE_PM_STR))
523 *decided = loc;
524 is_pm = 1;
525 break;
526 }
527 *decided = raw;
528 }
529 #endif
530 if (!match_string (HERE_AM_STR, rp)) {
531 if (match_string (HERE_PM_STR, rp)) {
532 is_pm = 1;
533 } else {
534 return NULL;
535 }
536 }
537 break;
538 case 'r':
539 #ifdef _NL_CURRENT
540 if (*decided != raw)
541 {
542 if (!recursive (_NL_CURRENT (LC_TIME, T_FMT_AMPM)))
543 {
544 if (*decided == loc)
545 return NULL;
546 else
547 rp = rp_backup;
548 }
549 else
550 {
551 if (*decided == not &&
552 strcmp (_NL_CURRENT (LC_TIME, T_FMT_AMPM),
553 HERE_T_FMT_AMPM))
554 *decided = loc;
555 break;
556 }
557 *decided = raw;
558 }
559 #endif
560 if (!recursive (HERE_T_FMT_AMPM))
561 return NULL;
562 break;
563 case 'R':
564 if (!recursive ("%H:%M"))
565 return NULL;
566 break;
567 case 's':
568 {
569 /* The number of seconds may be very high so we cannot use
570 the `get_number' macro. Instead read the number
571 character for character and construct the result while
572 doing this. */
573 time_t secs = 0;
574 if (*rp < '0' || *rp > '9')
575 /* We need at least one digit. */
576 return NULL;
577
578 do
579 {
580 secs *= 10;
581 secs += *rp++ - '0';
582 }
583 while (*rp >= '0' && *rp <= '9');
584
585 if (localtime_r (&secs, tm) == NULL)
586 /* Error in function. */
587 return NULL;
588 }
589 break;
590 case 'S':
591 get_number (0, 61, 2);
592 tm->tm_sec = val;
593 break;
594 case 'X':
595 #ifdef _NL_CURRENT
596 if (*decided != raw)
597 {
598 if (!recursive (_NL_CURRENT (LC_TIME, T_FMT)))
599 {
600 if (*decided == loc)
601 return NULL;
602 else
603 rp = rp_backup;
604 }
605 else
606 {
607 if (strcmp (_NL_CURRENT (LC_TIME, T_FMT), HERE_T_FMT))
608 *decided = loc;
609 break;
610 }
611 *decided = raw;
612 }
613 #endif
614 /* Fall through. */
615 case 'T':
616 if (!recursive (HERE_T_FMT))
617 return NULL;
618 break;
619 case 'u':
620 get_number (1, 7, 1);
621 tm->tm_wday = val % 7;
622 have_wday = 1;
623 break;
624 case 'g':
625 get_number (0, 99, 2);
626 /* XXX This cannot determine any field in TM. */
627 break;
628 case 'G':
629 if (*rp < '0' || *rp > '9')
630 return NULL;
631 /* XXX Ignore the number since we would need some more
632 information to compute a real date. */
633 do
634 ++rp;
635 while (*rp >= '0' && *rp <= '9');
636 break;
637 case 'U':
638 case 'V':
639 case 'W':
640 get_number (0, 53, 2);
641 /* XXX This cannot determine any field in TM without some
642 information. */
643 break;
644 case 'w':
645 /* Match number of weekday. */
646 get_number (0, 6, 1);
647 tm->tm_wday = val;
648 have_wday = 1;
649 break;
650 case 'y':
651 #ifdef _NL_CURRENT
652 match_year_in_century:
653 #endif
654 /* Match year within century. */
655 get_number (0, 99, 2);
656 /* The "Year 2000: The Millennium Rollover" paper suggests that
657 values in the range 69-99 refer to the twentieth century. */
658 tm->tm_year = val >= 69 ? val : val + 100;
659 /* Indicate that we want to use the century, if specified. */
660 want_century = 1;
661 want_xday = 1;
662 break;
663 case 'Y':
664 /* Match year including century number. */
665 get_number (0, 9999, 4);
666 tm->tm_year = val - 1900;
667 want_century = 0;
668 want_xday = 1;
669 break;
670 case 'Z':
671 /* XXX How to handle this? */
672 break;
673 case 'E':
674 #ifdef _NL_CURRENT
675 switch (*fmt++)
676 {
677 case 'c':
678 /* Match locale's alternate date and time format. */
679 if (*decided != raw)
680 {
681 const char *fmt = _NL_CURRENT (LC_TIME, ERA_D_T_FMT);
682
683 if (*fmt == '\0')
684 fmt = _NL_CURRENT (LC_TIME, D_T_FMT);
685
686 if (!recursive (fmt))
687 {
688 if (*decided == loc)
689 return NULL;
690 else
691 rp = rp_backup;
692 }
693 else
694 {
695 if (strcmp (fmt, HERE_D_T_FMT))
696 *decided = loc;
697 want_xday = 1;
698 break;
699 }
700 *decided = raw;
701 }
702 /* The C locale has no era information, so use the
703 normal representation. */
704 if (!recursive (HERE_D_T_FMT))
705 return NULL;
706 want_xday = 1;
707 break;
708 case 'C':
709 if (*decided != raw)
710 {
711 if (era_cnt >= 0)
712 {
713 era = _nl_select_era_entry (era_cnt);
714 if (match_string (era->era_name, rp))
715 {
716 *decided = loc;
717 break;
718 }
719 else
720 return NULL;
721 }
722 else
723 {
724 num_eras = _NL_CURRENT_WORD (LC_TIME,
725 _NL_TIME_ERA_NUM_ENTRIES);
726 for (era_cnt = 0; era_cnt < (int) num_eras;
727 ++era_cnt, rp = rp_backup)
728 {
729 era = _nl_select_era_entry (era_cnt);
730 if (match_string (era->era_name, rp))
731 {
732 *decided = loc;
733 break;
734 }
735 }
736 if (era_cnt == (int) num_eras)
737 {
738 era_cnt = -1;
739 if (*decided == loc)
740 return NULL;
741 }
742 else
743 break;
744 }
745
746 *decided = raw;
747 }
748 /* The C locale has no era information, so use the
749 normal representation. */
750 goto match_century;
751 case 'y':
752 if (*decided == raw)
753 goto match_year_in_century;
754
755 get_number(0, 9999, 4);
756 tm->tm_year = val;
757 want_era = 1;
758 want_xday = 1;
759 break;
760 case 'Y':
761 if (*decided != raw)
762 {
763 num_eras = _NL_CURRENT_WORD (LC_TIME,
764 _NL_TIME_ERA_NUM_ENTRIES);
765 for (era_cnt = 0; era_cnt < (int) num_eras;
766 ++era_cnt, rp = rp_backup)
767 {
768 era = _nl_select_era_entry (era_cnt);
769 if (recursive (era->era_format))
770 break;
771 }
772 if (era_cnt == (int) num_eras)
773 {
774 era_cnt = -1;
775 if (*decided == loc)
776 return NULL;
777 else
778 rp = rp_backup;
779 }
780 else
781 {
782 *decided = loc;
783 era_cnt = -1;
784 break;
785 }
786
787 *decided = raw;
788 }
789 get_number (0, 9999, 4);
790 tm->tm_year = val - 1900;
791 want_century = 0;
792 want_xday = 1;
793 break;
794 case 'x':
795 if (*decided != raw)
796 {
797 const char *fmt = _NL_CURRENT (LC_TIME, ERA_D_FMT);
798
799 if (*fmt == '\0')
800 fmt = _NL_CURRENT (LC_TIME, D_FMT);
801
802 if (!recursive (fmt))
803 {
804 if (*decided == loc)
805 return NULL;
806 else
807 rp = rp_backup;
808 }
809 else
810 {
811 if (strcmp (fmt, HERE_D_FMT))
812 *decided = loc;
813 break;
814 }
815 *decided = raw;
816 }
817 if (!recursive (HERE_D_FMT))
818 return NULL;
819 break;
820 case 'X':
821 if (*decided != raw)
822 {
823 const char *fmt = _NL_CURRENT (LC_TIME, ERA_T_FMT);
824
825 if (*fmt == '\0')
826 fmt = _NL_CURRENT (LC_TIME, T_FMT);
827
828 if (!recursive (fmt))
829 {
830 if (*decided == loc)
831 return NULL;
832 else
833 rp = rp_backup;
834 }
835 else
836 {
837 if (strcmp (fmt, HERE_T_FMT))
838 *decided = loc;
839 break;
840 }
841 *decided = raw;
842 }
843 if (!recursive (HERE_T_FMT))
844 return NULL;
845 break;
846 default:
847 return NULL;
848 }
849 break;
850 #else
851 /* We have no information about the era format. Just use
852 the normal format. */
853 if (*fmt != 'c' && *fmt != 'C' && *fmt != 'y' && *fmt != 'Y'
854 && *fmt != 'x' && *fmt != 'X')
855 /* This is an illegal format. */
856 return NULL;
857
858 goto start_over;
859 #endif
860 case 'O':
861 switch (*fmt++)
862 {
863 case 'd':
864 case 'e':
865 /* Match day of month using alternate numeric symbols. */
866 get_alt_number (1, 31, 2);
867 tm->tm_mday = val;
868 have_mday = 1;
869 want_xday = 1;
870 break;
871 case 'H':
872 /* Match hour in 24-hour clock using alternate numeric
873 symbols. */
874 get_alt_number (0, 23, 2);
875 tm->tm_hour = val;
876 have_I = 0;
877 break;
878 case 'I':
879 /* Match hour in 12-hour clock using alternate numeric
880 symbols. */
881 get_alt_number (1, 12, 2);
882 tm->tm_hour = val - 1;
883 have_I = 1;
884 break;
885 case 'm':
886 /* Match month using alternate numeric symbols. */
887 get_alt_number (1, 12, 2);
888 tm->tm_mon = val - 1;
889 have_mon = 1;
890 want_xday = 1;
891 break;
892 case 'M':
893 /* Match minutes using alternate numeric symbols. */
894 get_alt_number (0, 59, 2);
895 tm->tm_min = val;
896 break;
897 case 'S':
898 /* Match seconds using alternate numeric symbols. */
899 get_alt_number (0, 61, 2);
900 tm->tm_sec = val;
901 break;
902 case 'U':
903 case 'V':
904 case 'W':
905 get_alt_number (0, 53, 2);
906 /* XXX This cannot determine any field in TM without
907 further information. */
908 break;
909 case 'w':
910 /* Match number of weekday using alternate numeric symbols. */
911 get_alt_number (0, 6, 1);
912 tm->tm_wday = val;
913 have_wday = 1;
914 break;
915 case 'y':
916 /* Match year within century using alternate numeric symbols. */
917 get_alt_number (0, 99, 2);
918 tm->tm_year = val >= 69 ? val : val + 100;
919 want_xday = 1;
920 break;
921 default:
922 return NULL;
923 }
924 break;
925 default:
926 return NULL;
927 }
928 }
929
930 if (have_I && is_pm)
931 tm->tm_hour += 12;
932
933 if (century != -1)
934 {
935 if (want_century)
936 tm->tm_year = tm->tm_year % 100 + (century - 19) * 100;
937 else
938 /* Only the century, but not the year. Strange, but so be it. */
939 tm->tm_year = (century - 19) * 100;
940 }
941
942 #ifdef _NL_CURRENT
943 if (era_cnt != -1)
944 {
945 era = _nl_select_era_entry(era_cnt);
946 if (want_era)
947 tm->tm_year = (era->start_date[0]
948 + ((tm->tm_year - era->offset)
949 * era->absolute_direction));
950 else
951 /* Era start year assumed. */
952 tm->tm_year = era->start_date[0];
953 }
954 else
955 #endif
956 if (want_era)
957 return NULL;
958
959 if (want_xday && !have_wday)
960 {
961 if ( !(have_mon && have_mday) && have_yday)
962 {
963 /* We don't have tm_mon and/or tm_mday, compute them. */
964 int t_mon = 0;
965 while (__mon_yday[__isleap(1900 + tm->tm_year)][t_mon] <= tm->tm_yday)
966 t_mon++;
967 if (!have_mon)
968 tm->tm_mon = t_mon - 1;
969 if (!have_mday)
970 tm->tm_mday =
971 (tm->tm_yday
972 - __mon_yday[__isleap(1900 + tm->tm_year)][t_mon - 1] + 1);
973 }
974 day_of_the_week (tm);
975 }
976 if (want_xday && !have_yday)
977 day_of_the_year (tm);
978
979 return discard_const_p(char, rp);
980 }
981
982
983 char *rep_strptime(const char *buf, const char *format, struct tm *tm)
984 {
985 enum locale_status decided;
986
987 #ifdef _NL_CURRENT
988 decided = not;
989 #else
990 decided = raw;
991 #endif
992 return strptime_internal (buf, format, tm, &decided, -1);
993 }
reg import