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