time/strptime_l.c

   1 /* Copyright (C) 2002, 2004 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             if (match_string (HERE_PM_STR, rp))
 543               is_pm = 1;
 544             else
 545               return NULL;
 546           break;
 547         case 'r':
 548 #ifdef _NL_CURRENT
 549           if (*decided != raw)
 550             {
 551               if (!recursive (_NL_CURRENT (LC_TIME, T_FMT_AMPM)))
 552                 {
 553                   if (*decided == loc)
 554                     return NULL;
 555                   else
 556                     rp = rp_backup;
 557                 }
 558               else
 559                 {
 560                   if (*decided == not &&
 561                       strcmp (_NL_CURRENT (LC_TIME, T_FMT_AMPM),
 562                               HERE_T_FMT_AMPM))
 563                     *decided = loc;
 564                   break;
 565                 }
 566               *decided = raw;
 567             }
 568 #endif
 569           if (!recursive (HERE_T_FMT_AMPM))
 570             return NULL;
 571           break;
 572         case 'R':
 573           if (!recursive ("%H:%M"))
 574             return NULL;
 575           break;
 576         case 's':
 577           {
 578             /* The number of seconds may be very high so we cannot use
 579                the `get_number' macro.  Instead read the number
 580                character for character and construct the result while
 581                doing this.  */
 582             time_t secs = 0;
 583             if (*rp < '0' || *rp > '9')
 584               /* We need at least one digit.  */
 585               return NULL;
 586
 587             do
 588               {
 589                 secs *= 10;
 590                 secs += *rp++ - '0';
 591               }
 592             while (*rp >= '0' && *rp <= '9');
 593
 594             if (localtime_r (&secs, tm) == NULL)
 595               /* Error in function.  */
 596               return NULL;
 597           }
 598           break;
 599         case 'S':
 600           get_number (0, 61, 2);
 601           tm->tm_sec = val;
 602           break;
 603         case 'X':
 604 #ifdef _NL_CURRENT
 605           if (*decided != raw)
 606             {
 607               if (!recursive (_NL_CURRENT (LC_TIME, T_FMT)))
 608                 {
 609                   if (*decided == loc)
 610                     return NULL;
 611                   else
 612                     rp = rp_backup;
 613                 }
 614               else
 615                 {
 616                   if (strcmp (_NL_CURRENT (LC_TIME, T_FMT), HERE_T_FMT))
 617                     *decided = loc;
 618                   break;
 619                 }
 620               *decided = raw;
 621             }
 622 #endif
 623           /* Fall through.  */
 624         case 'T':
 625           if (!recursive (HERE_T_FMT))
 626             return NULL;
 627           break;
 628         case 'u':
 629           get_number (1, 7, 1);
 630           tm->tm_wday = val % 7;
 631           have_wday = 1;
 632           break;
 633         case 'g':
 634           get_number (0, 99, 2);
 635           /* XXX This cannot determine any field in TM.  */
 636           break;
 637         case 'G':
 638           if (*rp < '0' || *rp > '9')
 639             return NULL;
 640           /* XXX Ignore the number since we would need some more
 641              information to compute a real date.  */
 642           do
 643             ++rp;
 644           while (*rp >= '0' && *rp <= '9');
 645           break;
 646         case 'U':
 647           get_number (0, 53, 2);
 648           week_no = val;
 649           have_uweek = 1;
 650           break;
 651         case 'W':
 652           get_number (0, 53, 2);
 653           week_no = val;
 654           have_wweek = 1;
 655           break;
 656         case 'V':
 657           get_number (0, 53, 2);
 658           /* XXX This cannot determine any field in TM without some
 659              information.  */
 660           break;
 661         case 'w':
 662           /* Match number of weekday.  */
 663           get_number (0, 6, 1);
 664           tm->tm_wday = val;
 665           have_wday = 1;
 666           break;
 667         case 'y':
 668         match_year_in_century:
 669           /* Match year within century.  */
 670           get_number (0, 99, 2);
 671           /* The "Year 2000: The Millennium Rollover" paper suggests that
 672              values in the range 69-99 refer to the twentieth century.  */
 673           tm->tm_year = val >= 69 ? val : val + 100;
 674           /* Indicate that we want to use the century, if specified.  */
 675           want_century = 1;
 676           want_xday = 1;
 677           break;
 678         case 'Y':
 679           /* Match year including century number.  */
 680           get_number (0, 9999, 4);
 681           tm->tm_year = val - 1900;
 682           want_century = 0;
 683           want_xday = 1;
 684           break;
 685         case 'Z':
 686           /* XXX How to handle this?  */
 687           break;
 688         case 'E':
 689 #ifdef _NL_CURRENT
 690           switch (*fmt++)
 691             {
 692             case 'c':
 693               /* Match locale's alternate date and time format.  */
 694               if (*decided != raw)
 695                 {
 696                   const char *fmt = _NL_CURRENT (LC_TIME, ERA_D_T_FMT);
 697
 698                   if (*fmt == '\0')
 699                     fmt = _NL_CURRENT (LC_TIME, D_T_FMT);
 700
 701                   if (!recursive (fmt))
 702                     {
 703                       if (*decided == loc)
 704                         return NULL;
 705                       else
 706                         rp = rp_backup;
 707                     }
 708                   else
 709                     {
 710                       if (strcmp (fmt, HERE_D_T_FMT))
 711                         *decided = loc;
 712                       want_xday = 1;
 713                       break;
 714                     }
 715                   *decided = raw;
 716                 }
 717               /* The C locale has no era information, so use the
 718                  normal representation.  */
 719               if (!recursive (HERE_D_T_FMT))
 720                 return NULL;
 721               want_xday = 1;
 722               break;
 723             case 'C':
 724               if (*decided != raw)
 725                 {
 726                   if (era_cnt >= 0)
 727                     {
 728                       era = _nl_select_era_entry (era_cnt HELPER_LOCALE_ARG);
 729                       if (era != NULL && match_string (era->era_name, rp))
 730                         {
 731                           *decided = loc;
 732                           break;
 733                         }
 734                       else
 735                         return NULL;
 736                     }
 737
 738                   num_eras = _NL_CURRENT_WORD (LC_TIME,
 739                                                _NL_TIME_ERA_NUM_ENTRIES);
 740                   for (era_cnt = 0; era_cnt < (int) num_eras;
 741                        ++era_cnt, rp = rp_backup)
 742                     {
 743                       era = _nl_select_era_entry (era_cnt
 744                                                   HELPER_LOCALE_ARG);
 745                       if (era != NULL && match_string (era->era_name, rp))
 746                         {
 747                           *decided = loc;
 748                           break;
 749                         }
 750                     }
 751                   if (era_cnt != (int) num_eras)
 752                     break;
 753
 754                   era_cnt = -1;
 755                   if (*decided == loc)
 756                     return NULL;
 757
 758                   *decided = raw;
 759                 }
 760               /* The C locale has no era information, so use the
 761                  normal representation.  */
 762               goto match_century;
 763             case 'y':
 764               if (*decided != raw)
 765                 {
 766                   get_number(0, 9999, 4);
 767                   tm->tm_year = val;
 768                   want_era = 1;
 769                   want_xday = 1;
 770                   want_century = 1;
 771
 772                   if (era_cnt >= 0)
 773                     {
 774                       assert (*decided == loc);
 775
 776                       era = _nl_select_era_entry (era_cnt HELPER_LOCALE_ARG);
 777                       bool match = false;
 778                       if (era != NULL)
 779                         {
 780                           int delta = ((tm->tm_year - era->offset)
 781                                        * era->absolute_direction);
 782                           match = (delta >= 0
 783                                    && delta < (((int64_t) era->stop_date[0]
 784                                                 - (int64_t) era->start_date[0])
 785                                                * era->absolute_direction));
 786                         }
 787                       if (! match)
 788                         return NULL;
 789
 790                       break;
 791                     }
 792
 793                   num_eras = _NL_CURRENT_WORD (LC_TIME,
 794                                                _NL_TIME_ERA_NUM_ENTRIES);
 795                   for (era_cnt = 0; era_cnt < (int) num_eras; ++era_cnt)
 796                     {
 797                       era = _nl_select_era_entry (era_cnt
 798                                                   HELPER_LOCALE_ARG);
 799                       if (era != NULL)
 800                         {
 801                           int delta = ((tm->tm_year - era->offset)
 802                                        * era->absolute_direction);
 803                           if (delta >= 0
 804                               && delta < (((int64_t) era->stop_date[0]
 805                                            - (int64_t) era->start_date[0])
 806                                           * era->absolute_direction))
 807                             {
 808                               *decided = loc;
 809                               break;
 810                             }
 811                         }
 812                     }
 813                   if (era_cnt != (int) num_eras)
 814                     break;
 815
 816                   era_cnt = -1;
 817                   if (*decided == loc)
 818                     return NULL;
 819
 820                   *decided = raw;
 821                 }
 822
 823               goto match_year_in_century;
 824             case 'Y':
 825               if (*decided != raw)
 826                 {
 827                   num_eras = _NL_CURRENT_WORD (LC_TIME,
 828                                                _NL_TIME_ERA_NUM_ENTRIES);
 829                   for (era_cnt = 0; era_cnt < (int) num_eras;
 830                        ++era_cnt, rp = rp_backup)
 831                     {
 832                       era = _nl_select_era_entry (era_cnt HELPER_LOCALE_ARG);
 833                       if (era != NULL && recursive (era->era_format))
 834                         break;
 835                     }
 836                   if (era_cnt == (int) num_eras)
 837                     {
 838                       era_cnt = -1;
 839                       if (*decided == loc)
 840                         return NULL;
 841                       else
 842                         rp = rp_backup;
 843                     }
 844                   else
 845                     {
 846                       *decided = loc;
 847                       era_cnt = -1;
 848                       break;
 849                     }
 850
 851                   *decided = raw;
 852                 }
 853               get_number (0, 9999, 4);
 854               tm->tm_year = val - 1900;
 855               want_century = 0;
 856               want_xday = 1;
 857               break;
 858             case 'x':
 859               if (*decided != raw)
 860                 {
 861                   const char *fmt = _NL_CURRENT (LC_TIME, ERA_D_FMT);
 862
 863                   if (*fmt == '\0')
 864                     fmt = _NL_CURRENT (LC_TIME, D_FMT);
 865
 866                   if (!recursive (fmt))
 867                     {
 868                       if (*decided == loc)
 869                         return NULL;
 870                       else
 871                         rp = rp_backup;
 872                     }
 873                   else
 874                     {
 875                       if (strcmp (fmt, HERE_D_FMT))
 876                         *decided = loc;
 877                       break;
 878                     }
 879                   *decided = raw;
 880                 }
 881               if (!recursive (HERE_D_FMT))
 882                 return NULL;
 883               break;
 884             case 'X':
 885               if (*decided != raw)
 886                 {
 887                   const char *fmt = _NL_CURRENT (LC_TIME, ERA_T_FMT);
 888
 889                   if (*fmt == '\0')
 890                     fmt = _NL_CURRENT (LC_TIME, T_FMT);
 891
 892                   if (!recursive (fmt))
 893                     {
 894                       if (*decided == loc)
 895                         return NULL;
 896                       else
 897                         rp = rp_backup;
 898                     }
 899                   else
 900                     {
 901                       if (strcmp (fmt, HERE_T_FMT))
 902                         *decided = loc;
 903                       break;
 904                     }
 905                   *decided = raw;
 906                 }
 907               if (!recursive (HERE_T_FMT))
 908                 return NULL;
 909               break;
 910             default:
 911               return NULL;
 912             }
 913           break;
 914 #else
 915           /* We have no information about the era format.  Just use
 916              the normal format.  */
 917           if (*fmt != 'c' && *fmt != 'C' && *fmt != 'y' && *fmt != 'Y'
 918               && *fmt != 'x' && *fmt != 'X')
 919             /* This is an illegal format.  */
 920             return NULL;
 921
 922           goto start_over;
 923 #endif
 924         case 'O':
 925           switch (*fmt++)
 926             {
 927             case 'd':
 928             case 'e':
 929               /* Match day of month using alternate numeric symbols.  */
 930               get_alt_number (1, 31, 2);
 931               tm->tm_mday = val;
 932               have_mday = 1;
 933               want_xday = 1;
 934               break;
 935             case 'H':
 936               /* Match hour in 24-hour clock using alternate numeric
 937                  symbols.  */
 938               get_alt_number (0, 23, 2);
 939               tm->tm_hour = val;
 940               have_I = 0;
 941               break;
 942             case 'I':
 943               /* Match hour in 12-hour clock using alternate numeric
 944                  symbols.  */
 945               get_alt_number (1, 12, 2);
 946               tm->tm_hour = val % 12;
 947               have_I = 1;
 948               break;
 949             case 'm':
 950               /* Match month using alternate numeric symbols.  */
 951               get_alt_number (1, 12, 2);
 952               tm->tm_mon = val - 1;
 953               have_mon = 1;
 954               want_xday = 1;
 955               break;
 956             case 'M':
 957               /* Match minutes using alternate numeric symbols.  */
 958               get_alt_number (0, 59, 2);
 959               tm->tm_min = val;
 960               break;
 961             case 'S':
 962               /* Match seconds using alternate numeric symbols.  */
 963               get_alt_number (0, 61, 2);
 964               tm->tm_sec = val;
 965               break;
 966             case 'U':
 967               get_alt_number (0, 53, 2);
 968               week_no = val;
 969               have_uweek = 1;
 970               break;
 971             case 'W':
 972               get_alt_number (0, 53, 2);
 973               week_no = val;
 974               have_wweek = 1;
 975               break;
 976             case 'V':
 977               get_alt_number (0, 53, 2);
 978               /* XXX This cannot determine any field in TM without
 979                  further information.  */
 980               break;
 981             case 'w':
 982               /* Match number of weekday using alternate numeric symbols.  */
 983               get_alt_number (0, 6, 1);
 984               tm->tm_wday = val;
 985               have_wday = 1;
 986               break;
 987             case 'y':
 988               /* Match year within century using alternate numeric symbols.  */
 989               get_alt_number (0, 99, 2);
 990               tm->tm_year = val >= 69 ? val : val + 100;
 991               want_xday = 1;
 992               break;
 993             default:
 994               return NULL;
 995             }
 996           break;
 997         default:
 998           return NULL;
 999         }
1000     }
1001
1002   if (have_I && is_pm)
1003     tm->tm_hour += 12;
1004
1005   if (century != -1)
1006     {
1007       if (want_century)
1008         tm->tm_year = tm->tm_year % 100 + (century - 19) * 100;
1009       else
1010         /* Only the century, but not the year.  Strange, but so be it.  */
1011         tm->tm_year = (century - 19) * 100;
1012     }
1013
1014   if (era_cnt != -1)
1015     {
1016       era = _nl_select_era_entry (era_cnt HELPER_LOCALE_ARG);
1017       if (era == NULL)
1018         return NULL;
1019       if (want_era)
1020         tm->tm_year = (era->start_date[0]
1021                        + ((tm->tm_year - era->offset)
1022                           * era->absolute_direction));
1023       else
1024         /* Era start year assumed.  */
1025         tm->tm_year = era->start_date[0];
1026     }
1027   else
1028     if (want_era)
1029       {
1030         /* No era found but we have seen an E modifier.  Rectify some
1031            values.  */
1032         if (want_century && century == -1 && tm->tm_year < 69)
1033           tm->tm_year += 100;
1034       }
1035
1036   if (want_xday && !have_wday)
1037     {
1038       if ( !(have_mon && have_mday) && have_yday)
1039         {
1040           /* We don't have tm_mon and/or tm_mday, compute them.  */
1041           int t_mon = 0;
1042           while (__mon_yday[__isleap(1900 + tm->tm_year)][t_mon] <= tm->tm_yday)
1043               t_mon++;
1044           if (!have_mon)
1045               tm->tm_mon = t_mon - 1;
1046           if (!have_mday)
1047               tm->tm_mday =
1048                 (tm->tm_yday
1049                  - __mon_yday[__isleap(1900 + tm->tm_year)][t_mon - 1] + 1);
1050         }
1051       day_of_the_week (tm);
1052     }
1053
1054   if (want_xday && !have_yday)
1055     day_of_the_year (tm);
1056
1057   if ((have_uweek || have_wweek) && have_wday)
1058     {
1059       int save_wday = tm->tm_wday;
1060       int save_mday = tm->tm_mday;
1061       int save_mon = tm->tm_mon;
1062       int w_offset = have_uweek ? 0 : 1;
1063
1064       tm->tm_mday = 1;
1065       tm->tm_mon = 0;
1066       day_of_the_week (tm);
1067       if (have_mday)
1068         tm->tm_mday = save_mday;
1069       if (have_mon)
1070         tm->tm_mon = save_mon;
1071
1072       if (!have_yday)
1073         tm->tm_yday = ((7 - (tm->tm_wday - w_offset)) % 7
1074                        + (week_no - 1) *7
1075                        + save_wday - w_offset);
1076
1077       if (!have_mday || !have_mon)
1078         {
1079           int t_mon = 0;
1080           while (__mon_yday[__isleap(1900 + tm->tm_year)][t_mon]
1081                  <= tm->tm_yday)
1082             t_mon++;
1083           if (!have_mon)
1084             tm->tm_mon = t_mon - 1;
1085           if (!have_mday)
1086               tm->tm_mday =
1087                 (tm->tm_yday
1088                  - __mon_yday[__isleap(1900 + tm->tm_year)][t_mon - 1] + 1);
1089         }
1090
1091       tm->tm_wday = save_wday;
1092     }
1093
1094   return (char *) rp;
1095 }
1096
1097
1098 char *
1099 strptime (buf, format, tm LOCALE_PARAM)
1100      const char *buf;
1101      const char *format;
1102      struct tm *tm;
1103      LOCALE_PARAM_DECL
1104 {
1105   enum ptime_locale_status decided;
1106
1107 #ifdef _NL_CURRENT
1108   decided = not;
1109 #else
1110   decided = raw;
1111 #endif
1112   return __strptime_internal (buf, format, tm, &decided, -1 LOCALE_ARG);
1113 }
1114
1115 #ifdef _LIBC
1116 weak_alias (__strptime_l, strptime_l)
1117 #endif