Declare https-inspection experimental
[privoxy.git] / strptime.h
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
40 #ifndef __P
41 # if defined (__GNUC__) || (defined (__STDC__) && __STDC__)
42 #  define __P(args) args
43 # else
44 #  define __P(args) ()
45 # endif  /* GCC.  */
46 #endif  /* Not __P.  */
47
48 #if ! HAVE_LOCALTIME_R && ! defined localtime_r
49 # ifdef _LIBC
50 #  define localtime_r __localtime_r
51 # else
52 /* Approximate localtime_r as best we can in its absence.  */
53 #  define localtime_r my_localtime_r
54 static struct tm *localtime_r __P ((const time_t *, struct tm *));
55 static struct tm *
56 localtime_r (t, tp)
57      const time_t *t;
58      struct tm *tp;
59 {
60   struct tm *l = localtime (t);
61   if (! l)
62     return 0;
63   *tp = *l;
64   return tp;
65 }
66 # endif /* ! _LIBC */
67 #endif /* ! HAVE_LOCALTIME_R && ! defined (localtime_r) */
68
69
70 #define match_char(ch1, ch2) if (ch1 != ch2) return NULL
71 #if defined __GNUC__ && __GNUC__ >= 2
72 # define match_string(cs1, s2) \
73   ({ size_t len = strlen (cs1);                                               \
74      int result = strncasecmp ((cs1), (s2), len) == 0;                        \
75      if (result) (s2) += len;                                                 \
76      result; })
77 #else
78 /* Oh come on.  Get a reasonable compiler.  */
79 # define match_string(cs1, s2) \
80   (strncasecmp ((cs1), (s2), strlen (cs1)) ? 0 : ((s2) += strlen (cs1), 1))
81 #endif
82 /* We intentionally do not use isdigit() for testing because this will
83    lead to problems with the wide character version.  */
84 #define get_number(from, to, n) \
85   do {                                                                        \
86     int __n = n;                                                              \
87     val = 0;                                                                  \
88     while (*rp == ' ')                                                        \
89       ++rp;                                                                   \
90     if (*rp < '0' || *rp > '9')                                               \
91       return NULL;                                                            \
92     do {                                                                      \
93       val *= 10;                                                              \
94       val += *rp++ - '0';                                                     \
95     } while (--__n > 0 && val * 10 <= to && *rp >= '0' && *rp <= '9');        \
96     if (val < from || val > to)                                               \
97       return NULL;                                                            \
98   } while (0)
99 #ifdef _NL_CURRENT
100 # define get_alt_number(from, to, n) \
101   ({                                                                          \
102     __label__ do_normal;                                                      \
103     if (*decided != raw)                                                      \
104       {                                                                       \
105         const char *alts = _NL_CURRENT (LC_TIME, ALT_DIGITS);                 \
106         int __n = n;                                                          \
107         int any = 0;                                                          \
108         while (*rp == ' ')                                                    \
109           ++rp;                                                               \
110         val = 0;                                                              \
111         do {                                                                  \
112           val *= 10;                                                          \
113           while (*alts != '\0')                                               \
114             {                                                                 \
115               size_t len = strlen (alts);                                     \
116               if (strncasecmp (alts, rp, len) == 0)                           \
117                 break;                                                        \
118               alts += len + 1;                                                \
119               ++val;                                                          \
120             }                                                                 \
121           if (*alts == '\0')                                                  \
122             {                                                                 \
123               if (*decided == not && ! any)                                   \
124                 goto do_normal;                                               \
125               /* If we haven't read anything it's an error.  */               \
126               if (! any)                                                      \
127                 return NULL;                                                  \
128               /* Correct the premature multiplication.  */                    \
129               val /= 10;                                                      \
130               break;                                                          \
131             }                                                                 \
132           else                                                                \
133             *decided = loc;                                                   \
134         } while (--__n > 0 && val * 10 <= to);                                \
135         if (val < from || val > to)                                           \
136           return NULL;                                                        \
137       }                                                                       \
138     else                                                                      \
139       {                                                                       \
140        do_normal:                                                             \
141         get_number (from, to, n);                                             \
142       }                                                                       \
143     0;                                                                        \
144   })
145 #else
146 # define get_alt_number(from, to, n) \
147   /* We don't have the alternate representation.  */                          \
148   get_number(from, to, n)
149 #endif
150 #define recursive(new_fmt) \
151   (*(new_fmt) != '\0'                                                         \
152    && (rp = strptime_internal (rp, (new_fmt), tm, decided, era_cnt)) != NULL)
153
154
155 #ifdef _LIBC
156 /* This is defined in locale/C-time.c in the GNU libc.  */
157 extern const struct locale_data _nl_C_LC_TIME;
158 extern const unsigned short int __mon_yday[2][13];
159
160 # define weekday_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (DAY_1)].string)
161 # define ab_weekday_name \
162   (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (ABDAY_1)].string)
163 # define month_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (MON_1)].string)
164 # define ab_month_name (&_nl_C_LC_TIME.values[_NL_ITEM_INDEX (ABMON_1)].string)
165 # define HERE_D_T_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (D_T_FMT)].string)
166 # define HERE_D_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (D_FMT)].string)
167 # define HERE_AM_STR (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (AM_STR)].string)
168 # define HERE_PM_STR (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (PM_STR)].string)
169 # define HERE_T_FMT_AMPM \
170   (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (T_FMT_AMPM)].string)
171 # define HERE_T_FMT (_nl_C_LC_TIME.values[_NL_ITEM_INDEX (T_FMT)].string)
172
173 # define strncasecmp(s1, s2, n) __strncasecmp (s1, s2, n)
174 #else
175 static char const weekday_name[][10] =
176   {
177     "Sunday", "Monday", "Tuesday", "Wednesday",
178     "Thursday", "Friday", "Saturday"
179   };
180 static char const ab_weekday_name[][4] =
181   {
182     "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"
183   };
184 static char const month_name[][10] =
185   {
186     "January", "February", "March", "April", "May", "June",
187     "July", "August", "September", "October", "November", "December"
188   };
189 static char const ab_month_name[][4] =
190   {
191     "Jan", "Feb", "Mar", "Apr", "May", "Jun",
192     "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
193   };
194 # define HERE_D_T_FMT "%a %b %e %H:%M:%S %Y"
195 # define HERE_D_FMT "%m/%d/%y"
196 # define HERE_AM_STR "AM"
197 # define HERE_PM_STR "PM"
198 # define HERE_T_FMT_AMPM "%I:%M:%S %p"
199 # define HERE_T_FMT "%H:%M:%S"
200
201 const unsigned short int __mon_yday[2][13] =
202   {
203     /* Normal years.  */
204     { 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365 },
205     /* Leap years.  */
206     { 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366 }
207   };
208 #endif
209
210 /* Status of lookup: do we use the locale data or the raw data?  */
211 enum locale_status { not, loc, raw };
212
213
214 #ifndef __isleap
215 /* Nonzero if YEAR is a leap year (every 4 years,
216    except every 100th isn't, and every 400th is).  */
217 # define __isleap(year) \
218   ((year) % 4 == 0 && ((year) % 100 != 0 || (year) % 400 == 0))
219 #endif
220
221 /* Compute the day of the week.  */
222 static void
223 day_of_the_week (struct tm *tm)
224 {
225   /* We know that January 1st 1970 was a Thursday (= 4).  Compute the
226      the difference between this data in the one on TM and so determine
227      the weekday.  */
228   int corr_year = 1900 + tm->tm_year - (tm->tm_mon < 2);
229   int wday = (-473
230               + (365 * (tm->tm_year - 70))
231               + (corr_year / 4)
232               - ((corr_year / 4) / 25) + ((corr_year / 4) % 25 < 0)
233               + (((corr_year / 4) / 25) / 4)
234               + __mon_yday[0][tm->tm_mon]
235               + tm->tm_mday - 1);
236   tm->tm_wday = ((wday % 7) + 7) % 7;
237 }
238
239 /* Compute the day of the year.  */
240 static void
241 day_of_the_year (struct tm *tm)
242 {
243   tm->tm_yday = (__mon_yday[__isleap (1900 + tm->tm_year)][tm->tm_mon]
244                  + (tm->tm_mday - 1));
245 }
246
247 static char *
248 #ifdef _LIBC
249 internal_function
250 #endif
251 strptime_internal __P ((const char *rp, const char *fmt, struct tm *tm,
252                         enum locale_status *decided, int era_cnt));
253
254 static char *
255 #ifdef _LIBC
256 internal_function
257 #endif
258 strptime_internal (rp, fmt, tm, decided, era_cnt)
259      const char *rp;
260      const char *fmt;
261      struct tm *tm;
262      enum locale_status *decided;
263      int era_cnt;
264 {
265   const char *rp_backup;
266   int cnt;
267   size_t val;
268   int have_I, is_pm;
269   int century, want_century;
270   int want_era;
271   int have_wday, want_xday;
272   int have_yday;
273   int have_mon, have_mday;
274 #ifdef _NL_CURRENT
275   size_t num_eras;
276 #endif
277   struct era_entry *era;
278
279   have_I = is_pm = 0;
280   century = -1;
281   want_century = 0;
282   want_era = 0;
283   era = NULL;
284
285   have_wday = want_xday = have_yday = have_mon = have_mday = 0;
286
287   while (*fmt != '\0')
288     {
289       /* A white space in the format string matches 0 more or white
290          space in the input string.  */
291       if (isspace (*fmt))
292         {
293           while (isspace (*rp))
294             ++rp;
295           ++fmt;
296           continue;
297         }
298
299       /* Any character but `%' must be matched by the same character
300          in the input string.  */
301       if (*fmt != '%')
302         {
303           match_char (*fmt++, *rp++);
304           continue;
305         }
306
307       ++fmt;
308 #ifndef _NL_CURRENT
309       /* We need this for handling the `E' modifier.  */
310     start_over:
311 #endif
312
313       /* Make back up of current processing pointer.  */
314       rp_backup = rp;
315
316       switch (*fmt++)
317         {
318         case '%':
319           /* Match the `%' character itself.  */
320           match_char ('%', *rp++);
321           break;
322         case 'a':
323         case 'A':
324           /* Match day of week.  */
325           for (cnt = 0; cnt < 7; ++cnt)
326             {
327 #ifdef _NL_CURRENT
328               if (*decided !=raw)
329                 {
330                   if (match_string (_NL_CURRENT (LC_TIME, DAY_1 + cnt), rp))
331                     {
332                       if (*decided == not
333                           && strcmp (_NL_CURRENT (LC_TIME, DAY_1 + cnt),
334                                      weekday_name[cnt]))
335                         *decided = loc;
336                       break;
337                     }
338                   if (match_string (_NL_CURRENT (LC_TIME, ABDAY_1 + cnt), rp))
339                     {
340                       if (*decided == not
341                           && strcmp (_NL_CURRENT (LC_TIME, ABDAY_1 + cnt),
342                                      ab_weekday_name[cnt]))
343                         *decided = loc;
344                       break;
345                     }
346                 }
347 #endif
348               if (*decided != loc
349                   && (match_string (weekday_name[cnt], rp)
350                       || match_string (ab_weekday_name[cnt], rp)))
351                 {
352                   *decided = raw;
353                   break;
354                 }
355             }
356           if (cnt == 7)
357             /* Does not match a weekday name.  */
358             return NULL;
359           tm->tm_wday = cnt;
360           have_wday = 1;
361           break;
362         case 'b':
363         case 'B':
364         case 'h':
365           /* Match month name.  */
366           for (cnt = 0; cnt < 12; ++cnt)
367             {
368 #ifdef _NL_CURRENT
369               if (*decided !=raw)
370                 {
371                   if (match_string (_NL_CURRENT (LC_TIME, MON_1 + cnt), rp))
372                     {
373                       if (*decided == not
374                           && strcmp (_NL_CURRENT (LC_TIME, MON_1 + cnt),
375                                      month_name[cnt]))
376                         *decided = loc;
377                       break;
378                     }
379                   if (match_string (_NL_CURRENT (LC_TIME, ABMON_1 + cnt), rp))
380                     {
381                       if (*decided == not
382                           && strcmp (_NL_CURRENT (LC_TIME, ABMON_1 + cnt),
383                                      ab_month_name[cnt]))
384                         *decided = loc;
385                       break;
386                     }
387                 }
388 #endif
389               if (match_string (month_name[cnt], rp)
390                   || match_string (ab_month_name[cnt], rp))
391                 {
392                   *decided = raw;
393                   break;
394                 }
395             }
396           if (cnt == 12)
397             /* Does not match a month name.  */
398             return NULL;
399           tm->tm_mon = cnt;
400           want_xday = 1;
401           break;
402         case 'c':
403           /* Match locale's date and time format.  */
404 #ifdef _NL_CURRENT
405           if (*decided != raw)
406             {
407               if (!recursive (_NL_CURRENT (LC_TIME, D_T_FMT)))
408                 {
409                   if (*decided == loc)
410                     return NULL;
411                   else
412                     rp = rp_backup;
413                 }
414               else
415                 {
416                   if (*decided == not &&
417                       strcmp (_NL_CURRENT (LC_TIME, D_T_FMT), HERE_D_T_FMT))
418                     *decided = loc;
419                   want_xday = 1;
420                   break;
421                 }
422               *decided = raw;
423             }
424 #endif
425           if (!recursive (HERE_D_T_FMT))
426             return NULL;
427           want_xday = 1;
428           break;
429         case 'C':
430           /* Match century number.  */
431 #ifdef _NL_CURRENT
432         match_century:
433 #endif
434           get_number (0, 99, 2);
435           century = val;
436           want_xday = 1;
437           break;
438         case 'd':
439         case 'e':
440           /* Match day of month.  */
441           get_number (1, 31, 2);
442           tm->tm_mday = val;
443           have_mday = 1;
444           want_xday = 1;
445           break;
446         case 'F':
447           if (!recursive ("%Y-%m-%d"))
448             return NULL;
449           want_xday = 1;
450           break;
451         case 'x':
452 #ifdef _NL_CURRENT
453           if (*decided != raw)
454             {
455               if (!recursive (_NL_CURRENT (LC_TIME, D_FMT)))
456                 {
457                   if (*decided == loc)
458                     return NULL;
459                   else
460                     rp = rp_backup;
461                 }
462               else
463                 {
464                   if (*decided == not
465                       && strcmp (_NL_CURRENT (LC_TIME, D_FMT), HERE_D_FMT))
466                     *decided = loc;
467                   want_xday = 1;
468                   break;
469                 }
470               *decided = raw;
471             }
472 #endif
473           /* Fall through.  */
474         case 'D':
475           /* Match standard day format.  */
476           if (!recursive (HERE_D_FMT))
477             return NULL;
478           want_xday = 1;
479           break;
480         case 'k':
481         case 'H':
482           /* Match hour in 24-hour clock.  */
483           get_number (0, 23, 2);
484           tm->tm_hour = val;
485           have_I = 0;
486           break;
487         case 'I':
488           /* Match hour in 12-hour clock.  */
489           get_number (1, 12, 2);
490           tm->tm_hour = val % 12;
491           have_I = 1;
492           break;
493         case 'j':
494           /* Match day number of year.  */
495           get_number (1, 366, 3);
496           tm->tm_yday = val - 1;
497           have_yday = 1;
498           break;
499         case 'm':
500           /* Match number of month.  */
501           get_number (1, 12, 2);
502           tm->tm_mon = val - 1;
503           have_mon = 1;
504           want_xday = 1;
505           break;
506         case 'M':
507           /* Match minute.  */
508           get_number (0, 59, 2);
509           tm->tm_min = val;
510           break;
511         case 'n':
512         case 't':
513           /* Match any white space.  */
514           while (isspace (*rp))
515             ++rp;
516           break;
517         case 'p':
518           /* Match locale's equivalent of AM/PM.  */
519 #ifdef _NL_CURRENT
520           if (*decided != raw)
521             {
522               if (match_string (_NL_CURRENT (LC_TIME, AM_STR), rp))
523                 {
524                   if (strcmp (_NL_CURRENT (LC_TIME, AM_STR), HERE_AM_STR))
525                     *decided = loc;
526                   break;
527                 }
528               if (match_string (_NL_CURRENT (LC_TIME, PM_STR), rp))
529                 {
530                   if (strcmp (_NL_CURRENT (LC_TIME, PM_STR), HERE_PM_STR))
531                     *decided = loc;
532                   is_pm = 1;
533                   break;
534                 }
535               *decided = raw;
536             }
537 #endif
538           if (!match_string (HERE_AM_STR, rp)) {
539             if (match_string (HERE_PM_STR, rp))
540               is_pm = 1;
541             else
542               return NULL;
543           }
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 }