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