locale/programs/ld-time.c

   1 /* Copyright (C) 1995-2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3    Contributed by Ulrich Drepper <drepper@gnu.org>, 1995.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License version 2 as
   7    published by the Free Software Foundation.
   8
   9    This program 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
  12    GNU General Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License
  15    along with this program; if not, write to the Free Software Foundation,
  16    Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 #ifdef HAVE_CONFIG_H
  19 # include <config.h>
  20 #endif
  21
  22 #include <byteswap.h>
  23 #include <langinfo.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <wchar.h>
  27 #include <sys/uio.h>
  28
  29 #include <assert.h>
  30
  31 #include "localedef.h"
  32 #include "linereader.h"
  33 #include "localeinfo.h"
  34 #include "locfile.h"
  35
  36
  37 /* Entry describing an entry of the era specification.  */
  38 struct era_data
  39 {
  40   int32_t direction;
  41   int32_t offset;
  42   int32_t start_date[3];
  43   int32_t stop_date[3];
  44   const char *name;
  45   const char *format;
  46   uint32_t *wname;
  47   uint32_t *wformat;
  48 };
  49
  50
  51 /* The real definition of the struct for the LC_TIME locale.  */
  52 struct locale_time_t
  53 {
  54   const char *abday[7];
  55   const uint32_t *wabday[7];
  56   int abday_defined;
  57   const char *day[7];
  58   const uint32_t *wday[7];
  59   int day_defined;
  60   const char *abmon[12];
  61   const uint32_t *wabmon[12];
  62   int abmon_defined;
  63   const char *mon[12];
  64   const uint32_t *wmon[12];
  65   int mon_defined;
  66   const char *am_pm[2];
  67   const uint32_t *wam_pm[2];
  68   int am_pm_defined;
  69   const char *d_t_fmt;
  70   const uint32_t *wd_t_fmt;
  71   const char *d_fmt;
  72   const uint32_t *wd_fmt;
  73   const char *t_fmt;
  74   const uint32_t *wt_fmt;
  75   const char *t_fmt_ampm;
  76   const uint32_t *wt_fmt_ampm;
  77   const char **era;
  78   const uint32_t **wera;
  79   uint32_t num_era;
  80   const char *era_year;
  81   const uint32_t *wera_year;
  82   const char *era_d_t_fmt;
  83   const uint32_t *wera_d_t_fmt;
  84   const char *era_t_fmt;
  85   const uint32_t *wera_t_fmt;
  86   const char *era_d_fmt;
  87   const uint32_t *wera_d_fmt;
  88   const char *alt_digits[100];
  89   const uint32_t *walt_digits[100];
  90   const char *date_fmt;
  91   const uint32_t *wdate_fmt;
  92   int alt_digits_defined;
  93   unsigned char week_ndays;
  94   uint32_t week_1stday;
  95   unsigned char week_1stweek;
  96   unsigned char first_weekday;
  97   unsigned char first_workday;
  98   unsigned char cal_direction;
  99   const char *timezone;
 100   const uint32_t *wtimezone;
 101
 102   struct era_data *era_entries;
 103 };
 104
 105
 106 /* This constant is used to represent an empty wide character string.  */
 107 static const uint32_t empty_wstr[1] = { 0 };
 108
 109
 110 static void
 111 time_startup (struct linereader *lr, struct localedef_t *locale,
 112               int ignore_content)
 113 {
 114   if (!ignore_content)
 115     locale->categories[LC_TIME].time =
 116       (struct locale_time_t *) xcalloc (1, sizeof (struct locale_time_t));
 117
 118   if (lr != NULL)
 119     {
 120       lr->translate_strings = 1;
 121       lr->return_widestr = 1;
 122     }
 123 }
 124
 125
 126 void
 127 time_finish (struct localedef_t *locale, const struct charmap_t *charmap)
 128 {
 129   struct locale_time_t *time = locale->categories[LC_TIME].time;
 130   int nothing = 0;
 131
 132   /* Now resolve copying and also handle completely missing definitions.  */
 133   if (time == NULL)
 134     {
 135       /* First see whether we were supposed to copy.  If yes, find the
 136          actual definition.  */
 137       if (locale->copy_name[LC_TIME] != NULL)
 138         {
 139           /* Find the copying locale.  This has to happen transitively since
 140              the locale we are copying from might also copying another one.  */
 141           struct localedef_t *from = locale;
 142
 143           do
 144             from = find_locale (LC_TIME, from->copy_name[LC_TIME],
 145                                 from->repertoire_name, charmap);
 146           while (from->categories[LC_TIME].time == NULL
 147                  && from->copy_name[LC_TIME] != NULL);
 148
 149           time = locale->categories[LC_TIME].time
 150             = from->categories[LC_TIME].time;
 151         }
 152
 153       /* If there is still no definition issue an warning and create an
 154          empty one.  */
 155       if (time == NULL)
 156         {
 157           if (! be_quiet)
 158             WITH_CUR_LOCALE (error (0, 0, _("\
 159 No definition for %s category found"), "LC_TIME"));
 160           time_startup (NULL, locale, 0);
 161           time = locale->categories[LC_TIME].time;
 162           nothing = 1;
 163         }
 164     }
 165
 166 #define noparen(arg1, argn...) arg1, ##argn
 167 #define TESTARR_ELEM(cat, val) \
 168   if (!time->cat##_defined)                                                   \
 169     {                                                                         \
 170       const char *initval[] = { noparen val };                                \
 171       unsigned int i;                                                         \
 172                                                                               \
 173       if (! be_quiet && ! nothing)                                            \
 174         WITH_CUR_LOCALE (error (0, 0, _("%s: field `%s' not defined"),        \
 175                                 "LC_TIME", #cat));                            \
 176                                                                               \
 177       for (i = 0; i < sizeof (initval) / sizeof (initval[0]); ++i)            \
 178         time->cat[i] = initval[i];                                            \
 179     }
 180
 181   TESTARR_ELEM (abday, ( "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" ));
 182   TESTARR_ELEM (day, ( "Sunday", "Monday", "Tuesday", "Wednesday",
 183                         "Thursday", "Friday", "Saturday" ));
 184   TESTARR_ELEM (abmon, ( "Jan", "Feb", "Mar", "Apr", "May", "Jun",
 185                           "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ));
 186   TESTARR_ELEM (mon, ( "January", "February", "March", "April",
 187                         "May", "June", "July", "August",
 188                         "September", "October", "November", "December" ));
 189   TESTARR_ELEM (am_pm, ( "AM", "PM" ));
 190
 191 #define TEST_ELEM(cat, initval) \
 192   if (time->cat == NULL)                                                      \
 193     {                                                                         \
 194       if (! be_quiet && ! nothing)                                            \
 195         WITH_CUR_LOCALE (error (0, 0, _("%s: field `%s' not defined"),        \
 196                                 "LC_TIME", #cat));                            \
 197                                                                               \
 198       time->cat = initval;                                                    \
 199     }
 200
 201   TEST_ELEM (d_t_fmt, "%a %b %e %H:%M:%S %Y");
 202   TEST_ELEM (d_fmt, "%m/%d/%y");
 203   TEST_ELEM (t_fmt, "%H:%M:%S");
 204
 205   /* According to C.Y.Alexis Cheng <alexis@vnet.ibm.com> the T_FMT_AMPM
 206      field is optional.  */
 207   if (time->t_fmt_ampm == NULL)
 208     {
 209       if (time->am_pm[0][0] == '\0' && time->am_pm[1][0] == '\0')
 210         {
 211           /* No AM/PM strings defined, use the 24h format as default.  */
 212           time->t_fmt_ampm = time->t_fmt;
 213           time->wt_fmt_ampm = time->wt_fmt;
 214         }
 215       else
 216         {
 217           time->t_fmt_ampm = "%I:%M:%S %p";
 218           time->wt_fmt_ampm = (const uint32_t *) L"%I:%M:%S %p";
 219         }
 220     }
 221
 222   /* Now process the era entries.  */
 223   if (time->num_era != 0)
 224     {
 225       const int days_per_month[12] = { 31, 29, 31, 30, 31, 30,
 226                                        31, 31, 30, 31 ,30, 31 };
 227       size_t idx;
 228       wchar_t *wstr;
 229
 230       time->era_entries =
 231         (struct era_data *) xmalloc (time->num_era
 232                                      * sizeof (struct era_data));
 233
 234       for (idx = 0; idx < time->num_era; ++idx)
 235         {
 236           size_t era_len = strlen (time->era[idx]);
 237           char *str = xmalloc ((era_len + 1 + 3) & ~3);
 238           char *endp;
 239
 240           memcpy (str, time->era[idx], era_len + 1);
 241
 242           /* First character must be + or - for the direction.  */
 243           if (*str != '+' && *str != '-')
 244             {
 245               if (!be_quiet)
 246                 WITH_CUR_LOCALE (error (0, 0, _("\
 247 %s: direction flag in string %Zd in `era' field is not '+' nor '-'"),
 248                                         "LC_TIME", idx + 1));
 249               /* Default arbitrarily to '+'.  */
 250               time->era_entries[idx].direction = '+';
 251             }
 252           else
 253             time->era_entries[idx].direction = *str;
 254           if (*++str != ':')
 255             {
 256               if (!be_quiet)
 257                 WITH_CUR_LOCALE (error (0, 0, _("\
 258 %s: direction flag in string %Zd in `era' field is not a single character"),
 259                                         "LC_TIME", idx + 1));
 260               (void) strsep (&str, ":");
 261             }
 262           else
 263             ++str;
 264
 265           /* Now the offset year.  */
 266           time->era_entries[idx].offset = strtol (str, &endp, 10);
 267           if (endp == str)
 268             {
 269               if (!be_quiet)
 270                 WITH_CUR_LOCALE (error (0, 0, _("\
 271 %s: invalid number for offset in string %Zd in `era' field"),
 272                                         "LC_TIME", idx + 1));
 273               (void) strsep (&str, ":");
 274             }
 275           else if (*endp != ':')
 276             {
 277               if (!be_quiet)
 278                 WITH_CUR_LOCALE (error (0, 0, _("\
 279 %s: garbage at end of offset value in string %Zd in `era' field"),
 280                                         "LC_TIME", idx + 1));
 281               (void) strsep (&str, ":");
 282             }
 283           else
 284             str = endp + 1;
 285
 286           /* Next is the starting date in ISO format.  */
 287           if (strncmp (str, "-*", 2) == 0)
 288             {
 289               time->era_entries[idx].start_date[0] =
 290                 time->era_entries[idx].start_date[1] =
 291                 time->era_entries[idx].start_date[2] = 0x80000000;
 292               if (str[2] != ':')
 293                 goto garbage_start_date;
 294               str += 3;
 295             }
 296           else if (strncmp (str, "+*", 2) == 0)
 297             {
 298               time->era_entries[idx].start_date[0] =
 299                 time->era_entries[idx].start_date[1] =
 300                 time->era_entries[idx].start_date[2] = 0x7fffffff;
 301               if (str[2] != ':')
 302                 goto garbage_start_date;
 303               str += 3;
 304             }
 305           else
 306             {
 307               time->era_entries[idx].start_date[0] = strtol (str, &endp, 10);
 308               if (endp == str || *endp != '/')
 309                 goto invalid_start_date;
 310               else
 311                 str = endp + 1;
 312               time->era_entries[idx].start_date[0] -= 1900;
 313               /* year -1 represent 1 B.C. (not -1 A.D.) */
 314               if (time->era_entries[idx].start_date[0] < -1900)
 315                 ++time->era_entries[idx].start_date[0];
 316
 317               time->era_entries[idx].start_date[1] = strtol (str, &endp, 10);
 318               if (endp == str || *endp != '/')
 319                 goto invalid_start_date;
 320               else
 321                 str = endp + 1;
 322               time->era_entries[idx].start_date[1] -= 1;
 323
 324               time->era_entries[idx].start_date[2] = strtol (str, &endp, 10);
 325               if (endp == str)
 326                 {
 327                 invalid_start_date:
 328                   if (!be_quiet)
 329                     WITH_CUR_LOCALE (error (0, 0, _("\
 330 %s: invalid starting date in string %Zd in `era' field"),
 331                                             "LC_TIME", idx + 1));
 332                   (void) strsep (&str, ":");
 333                 }
 334               else if (*endp != ':')
 335                 {
 336                 garbage_start_date:
 337                   if (!be_quiet)
 338                     WITH_CUR_LOCALE (error (0, 0, _("\
 339 %s: garbage at end of starting date in string %Zd in `era' field "),
 340                                             "LC_TIME", idx + 1));
 341                   (void) strsep (&str, ":");
 342                 }
 343               else
 344                 {
 345                   str = endp + 1;
 346
 347                   /* Check for valid value.  */
 348                   if ((time->era_entries[idx].start_date[1] < 0
 349                        || time->era_entries[idx].start_date[1] >= 12
 350                        || time->era_entries[idx].start_date[2] < 0
 351                        || (time->era_entries[idx].start_date[2]
 352                            > days_per_month[time->era_entries[idx].start_date[1]])
 353                        || (time->era_entries[idx].start_date[1] == 2
 354                            && time->era_entries[idx].start_date[2] == 29
 355                            && !__isleap (time->era_entries[idx].start_date[0])))
 356                       && !be_quiet)
 357                           WITH_CUR_LOCALE (error (0, 0, _("\
 358 %s: starting date is invalid in string %Zd in `era' field"),
 359                                                   "LC_TIME", idx + 1));
 360                 }
 361             }
 362
 363           /* Next is the stopping date in ISO format.  */
 364           if (strncmp (str, "-*", 2) == 0)
 365             {
 366               time->era_entries[idx].stop_date[0] =
 367                 time->era_entries[idx].stop_date[1] =
 368                 time->era_entries[idx].stop_date[2] = 0x80000000;
 369               if (str[2] != ':')
 370                 goto garbage_stop_date;
 371               str += 3;
 372             }
 373           else if (strncmp (str, "+*", 2) == 0)
 374             {
 375               time->era_entries[idx].stop_date[0] =
 376                 time->era_entries[idx].stop_date[1] =
 377                 time->era_entries[idx].stop_date[2] = 0x7fffffff;
 378               if (str[2] != ':')
 379                 goto garbage_stop_date;
 380               str += 3;
 381             }
 382           else
 383             {
 384               time->era_entries[idx].stop_date[0] = strtol (str, &endp, 10);
 385               if (endp == str || *endp != '/')
 386                 goto invalid_stop_date;
 387               else
 388                 str = endp + 1;
 389               time->era_entries[idx].stop_date[0] -= 1900;
 390               /* year -1 represent 1 B.C. (not -1 A.D.) */
 391               if (time->era_entries[idx].stop_date[0] < -1900)
 392                 ++time->era_entries[idx].stop_date[0];
 393
 394               time->era_entries[idx].stop_date[1] = strtol (str, &endp, 10);
 395               if (endp == str || *endp != '/')
 396                 goto invalid_stop_date;
 397               else
 398                 str = endp + 1;
 399               time->era_entries[idx].stop_date[1] -= 1;
 400
 401               time->era_entries[idx].stop_date[2] = strtol (str, &endp, 10);
 402               if (endp == str)
 403                 {
 404                 invalid_stop_date:
 405                   if (!be_quiet)
 406                     WITH_CUR_LOCALE (error (0, 0, _("\
 407 %s: invalid stopping date in string %Zd in `era' field"),
 408                                             "LC_TIME", idx + 1));
 409                   (void) strsep (&str, ":");
 410                 }
 411               else if (*endp != ':')
 412                 {
 413                 garbage_stop_date:
 414                   if (!be_quiet)
 415                     WITH_CUR_LOCALE (error (0, 0, _("\
 416 %s: garbage at end of stopping date in string %Zd in `era' field"),
 417                                             "LC_TIME", idx + 1));
 418                   (void) strsep (&str, ":");
 419                 }
 420               else
 421                 {
 422                   str = endp + 1;
 423
 424                   /* Check for valid value.  */
 425                   if ((time->era_entries[idx].stop_date[1] < 0
 426                        || time->era_entries[idx].stop_date[1] >= 12
 427                        || time->era_entries[idx].stop_date[2] < 0
 428                        || (time->era_entries[idx].stop_date[2]
 429                            > days_per_month[time->era_entries[idx].stop_date[1]])
 430                        || (time->era_entries[idx].stop_date[1] == 2
 431                            && time->era_entries[idx].stop_date[2] == 29
 432                            && !__isleap (time->era_entries[idx].stop_date[0])))
 433                       && !be_quiet)
 434                           WITH_CUR_LOCALE (error (0, 0, _("\
 435 %s: stopping date is invalid in string %Zd in `era' field"),
 436                                                   "LC_TIME", idx + 1));
 437                 }
 438             }
 439
 440           if (str == NULL || *str == '\0')
 441             {
 442               if (!be_quiet)
 443                 WITH_CUR_LOCALE (error (0, 0, _("\
 444 %s: missing era name in string %Zd in `era' field"), "LC_TIME", idx + 1));
 445               time->era_entries[idx].name =
 446                 time->era_entries[idx].format = "";
 447             }
 448           else
 449             {
 450               time->era_entries[idx].name = strsep (&str, ":");
 451
 452               if (str == NULL || *str == '\0')
 453                 {
 454                   if (!be_quiet)
 455                     WITH_CUR_LOCALE (error (0, 0, _("\
 456 %s: missing era format in string %Zd in `era' field"),
 457                                             "LC_TIME", idx + 1));
 458                   time->era_entries[idx].name =
 459                     time->era_entries[idx].format = "";
 460                 }
 461               else
 462                 time->era_entries[idx].format = str;
 463             }
 464
 465           /* Now generate the wide character name and format.  */
 466           wstr = wcschr ((wchar_t *) time->wera[idx], L':');/* end direction */
 467           wstr = wstr ? wcschr (wstr + 1, L':') : NULL; /* end offset */
 468           wstr = wstr ? wcschr (wstr + 1, L':') : NULL; /* end start */
 469           wstr = wstr ? wcschr (wstr + 1, L':') : NULL; /* end end */
 470           time->era_entries[idx].wname = (uint32_t *) wstr + 1;
 471           wstr = wstr ? wcschr (wstr + 1, L':') : NULL; /* end name */
 472           *wstr = L'\0';
 473           time->era_entries[idx].wformat = (uint32_t *) wstr + 1;
 474         }
 475     }
 476
 477   if (time->week_ndays == 0)
 478     time->week_ndays = 7;
 479
 480   if (time->week_1stday == 0)
 481     time->week_1stday = 19971130;
 482
 483   if (time->week_1stweek > time->week_ndays)
 484     WITH_CUR_LOCALE (error (0, 0, _("\
 485 %s: third operand for value of field `%s' must not be larger than %d"),
 486                             "LC_TIME", "week", 7));
 487
 488   if (time->first_weekday == '\0')
 489     /* The definition does not specify this so the default is used.  */
 490     time->first_weekday = 1;
 491   else if (time->first_weekday > time->week_ndays)
 492     WITH_CUR_LOCALE (error (0, 0, _("\
 493 %s: values of field `%s' must not be larger than %d"),
 494                             "LC_TIME", "first_weekday", 7));
 495
 496   if (time->first_workday == '\0')
 497     /* The definition does not specify this so the default is used.  */
 498     time->first_workday = 1;
 499   else if (time->first_workday > time->week_ndays)
 500     WITH_CUR_LOCALE (error (0, 0, _("\
 501 %s: values of field `%s' must not be larger than %d"),
 502                             "LC_TIME", "first_workday", 7));
 503
 504   if (time->cal_direction == '\0')
 505     /* The definition does not specify this so the default is used.  */
 506     time->cal_direction = 1;
 507   else if (time->cal_direction > 3)
 508     WITH_CUR_LOCALE (error (0, 0, _("\
 509 %s: values for field `%s' must not be larger than %d"),
 510                             "LC_TIME", "cal_direction", 3));
 511
 512   /* XXX We don't perform any tests on the timezone value since this is
 513      simply useless, stupid $&$!@...  */
 514   if (time->timezone == NULL)
 515     time->timezone = "";
 516
 517   if (time->date_fmt == NULL)
 518     time->date_fmt = "%a %b %e %H:%M:%S %Z %Y";
 519   if (time->wdate_fmt == NULL)
 520     time->wdate_fmt = (const uint32_t *) L"%a %b %e %H:%M:%S %Z %Y";
 521 }
 522
 523
 524 void
 525 time_output (struct localedef_t *locale, const struct charmap_t *charmap,
 526              const char *output_path)
 527 {
 528   struct locale_time_t *time = locale->categories[LC_TIME].time;
 529   struct iovec *iov = alloca (sizeof *iov
 530                               * (2 + _NL_ITEM_INDEX (_NL_NUM_LC_TIME)
 531                                  + time->num_era - 1
 532                                  + 2 * 99
 533                                  + 2 + time->num_era * 10 - 1));
 534   struct locale_file data;
 535   uint32_t idx[_NL_ITEM_INDEX (_NL_NUM_LC_TIME)];
 536   size_t cnt, last_idx, num, n;
 537
 538   data.magic = LIMAGIC (LC_TIME);
 539   data.n = _NL_ITEM_INDEX (_NL_NUM_LC_TIME);
 540   iov[0].iov_base = (void *) &data;
 541   iov[0].iov_len = sizeof (data);
 542
 543   iov[1].iov_base = (void *) idx;
 544   iov[1].iov_len = sizeof (idx);
 545
 546   idx[0] = iov[0].iov_len + iov[1].iov_len;
 547
 548   /* The ab'days.  */
 549   for (cnt = 0; cnt <= _NL_ITEM_INDEX (ABDAY_7); ++cnt)
 550     {
 551       iov[2 + cnt].iov_base =
 552         (void *) (time->abday[cnt - _NL_ITEM_INDEX (ABDAY_1)] ?: "");
 553       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 554       idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
 555     }
 556
 557   /* The days.  */
 558   for (; cnt <= _NL_ITEM_INDEX (DAY_7); ++cnt)
 559     {
 560       iov[2 + cnt].iov_base =
 561         (void *) (time->day[cnt - _NL_ITEM_INDEX (DAY_1)] ?: "");
 562       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 563       idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
 564     }
 565
 566   /* The ab'mons.  */
 567   for (; cnt <= _NL_ITEM_INDEX (ABMON_12); ++cnt)
 568     {
 569       iov[2 + cnt].iov_base =
 570         (void *) (time->abmon[cnt - _NL_ITEM_INDEX (ABMON_1)] ?: "");
 571       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 572       idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
 573     }
 574
 575   /* The mons.  */
 576   for (; cnt <= _NL_ITEM_INDEX (MON_12); ++cnt)
 577     {
 578       iov[2 + cnt].iov_base =
 579         (void *) (time->mon[cnt - _NL_ITEM_INDEX (MON_1)] ?: "");
 580       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 581       idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
 582     }
 583
 584   /* AM/PM.  */
 585   for (; cnt <= _NL_ITEM_INDEX (PM_STR); ++cnt)
 586     {
 587       iov[2 + cnt].iov_base =
 588         (void *) (time->am_pm[cnt - _NL_ITEM_INDEX (AM_STR)] ?: "");
 589       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 590       idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
 591     }
 592
 593   iov[2 + cnt].iov_base = (void *) (time->d_t_fmt ?: "");
 594   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 595   idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
 596   ++cnt;
 597
 598   iov[2 + cnt].iov_base = (void *) (time->d_fmt ?: "");
 599   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 600   idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
 601   ++cnt;
 602
 603   iov[2 + cnt].iov_base = (void *) (time->t_fmt ?: "");
 604   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 605   idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
 606   ++cnt;
 607
 608   iov[2 + cnt].iov_base = (void *) (time->t_fmt_ampm ?: "");
 609   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 610   idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
 611   last_idx = ++cnt;
 612
 613   idx[1 + last_idx] = idx[last_idx];
 614   for (num = 0; num < time->num_era; ++num, ++cnt)
 615     {
 616       iov[2 + cnt].iov_base = (void *) time->era[num];
 617       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 618       idx[1 + last_idx] += iov[2 + cnt].iov_len;
 619     }
 620   ++last_idx;
 621
 622   iov[2 + cnt].iov_base = (void *) (time->era_year ?: "");
 623   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 624   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 625   ++cnt;
 626   ++last_idx;
 627
 628   iov[2 + cnt].iov_base = (void *) (time->era_d_fmt ?: "");
 629   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 630   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 631   ++cnt;
 632   ++last_idx;
 633
 634   idx[1 + last_idx] = idx[last_idx];
 635   for (num = 0; num < 100; ++num, ++cnt)
 636     {
 637       iov[2 + cnt].iov_base = (void *) (time->alt_digits[num] ?: "");
 638       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 639       idx[1 + last_idx] += iov[2 + cnt].iov_len;
 640     }
 641   ++last_idx;
 642
 643   iov[2 + cnt].iov_base = (void *) (time->era_d_t_fmt ?: "");
 644   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 645   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 646   ++cnt;
 647   ++last_idx;
 648
 649   iov[2 + cnt].iov_base = (void *) (time->era_t_fmt ?: "");
 650   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 651   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 652   ++cnt;
 653   ++last_idx;
 654
 655
 656   /* We must align the following data.  */
 657   iov[2 + cnt].iov_base = (void *) "\0\0";
 658   iov[2 + cnt].iov_len = ((idx[last_idx] + 3) & ~3) - idx[last_idx];
 659   idx[last_idx] = (idx[last_idx] + 3) & ~3;
 660   ++cnt;
 661
 662   /* The `era' data in usable form.  */
 663   iov[2 + cnt].iov_base = (void *) &time->num_era;
 664   iov[2 + cnt].iov_len = sizeof (uint32_t);
 665   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 666   ++cnt;
 667   ++last_idx;
 668
 669   idx[1 + last_idx] = idx[last_idx];
 670   for (num = 0; num < time->num_era; ++num)
 671     {
 672       size_t l, l2;
 673
 674       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].direction;
 675       iov[2 + cnt].iov_len = sizeof (int32_t);
 676       ++cnt;
 677       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].offset;
 678       iov[2 + cnt].iov_len = sizeof (int32_t);
 679       ++cnt;
 680       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].start_date[0];
 681       iov[2 + cnt].iov_len = sizeof (int32_t);
 682       ++cnt;
 683       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].start_date[1];
 684       iov[2 + cnt].iov_len = sizeof (int32_t);
 685       ++cnt;
 686       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].start_date[2];
 687       iov[2 + cnt].iov_len = sizeof (int32_t);
 688       ++cnt;
 689       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].stop_date[0];
 690       iov[2 + cnt].iov_len = sizeof (int32_t);
 691       ++cnt;
 692       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].stop_date[1];
 693       iov[2 + cnt].iov_len = sizeof (int32_t);
 694       ++cnt;
 695       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].stop_date[2];
 696       iov[2 + cnt].iov_len = sizeof (int32_t);
 697       ++cnt;
 698
 699       l = ((char *) rawmemchr (time->era_entries[num].format, '\0')
 700            - time->era_entries[num].name) + 1;
 701       l2 = (l + 3) & ~3;
 702       iov[2 + cnt].iov_base = alloca (l2);
 703       memset (mempcpy (iov[2 + cnt].iov_base, time->era_entries[num].name, l),
 704               '\0', l2 - l);
 705       iov[2 + cnt].iov_len = l2;
 706       ++cnt;
 707
 708       idx[1 + last_idx] += 8 * sizeof (int32_t) + l2;
 709
 710       assert (idx[1 + last_idx] % 4 == 0);
 711
 712       iov[2 + cnt].iov_base = (void *) time->era_entries[num].wname;
 713       iov[2 + cnt].iov_len = ((wcschr ((wchar_t *) time->era_entries[num].wformat, L'\0')
 714                                - (wchar_t *) time->era_entries[num].wname + 1)
 715                               * sizeof (uint32_t));
 716       idx[1 + last_idx] += iov[2 + cnt].iov_len;
 717       ++cnt;
 718     }
 719   ++last_idx;
 720
 721   /* The wide character ab'days.  */
 722   for (n = 0; n < 7; ++n, ++cnt, ++last_idx)
 723     {
 724       iov[2 + cnt].iov_base =
 725         (void *) (time->wabday[n] ?: empty_wstr);
 726       iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 727                               * sizeof (uint32_t));
 728       idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 729     }
 730
 731   /* The wide character days.  */
 732   for (n = 0; n < 7; ++n, ++cnt, ++last_idx)
 733     {
 734       iov[2 + cnt].iov_base =
 735         (void *) (time->wday[n] ?: empty_wstr);
 736       iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 737                               * sizeof (uint32_t));
 738       idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 739     }
 740
 741   /* The wide character ab'mons.  */
 742   for (n = 0; n < 12; ++n, ++cnt, ++last_idx)
 743     {
 744       iov[2 + cnt].iov_base =
 745         (void *) (time->wabmon[n] ?: empty_wstr);
 746       iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 747                               * sizeof (uint32_t));
 748       idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 749     }
 750
 751   /* The wide character mons.  */
 752   for (n = 0; n < 12; ++n, ++cnt, ++last_idx)
 753     {
 754       iov[2 + cnt].iov_base =
 755         (void *) (time->wmon[n] ?: empty_wstr);
 756       iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 757                               * sizeof (uint32_t));
 758       idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 759     }
 760
 761   /* Wide character AM/PM.  */
 762   for (n = 0; n < 2; ++n, ++cnt, ++last_idx)
 763     {
 764       iov[2 + cnt].iov_base =
 765         (void *) (time->wam_pm[n] ?: empty_wstr);
 766       iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 767                               * sizeof (uint32_t));
 768       idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 769     }
 770
 771   iov[2 + cnt].iov_base = (void *) (time->wd_t_fmt ?: empty_wstr);
 772   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 773                           * sizeof (uint32_t));
 774   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 775   ++cnt;
 776   ++last_idx;
 777
 778   iov[2 + cnt].iov_base = (void *) (time->wd_fmt ?: empty_wstr);
 779   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 780                           * sizeof (uint32_t));
 781   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 782   ++cnt;
 783   ++last_idx;
 784
 785   iov[2 + cnt].iov_base = (void *) (time->wt_fmt ?: empty_wstr);
 786   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 787                           * sizeof (uint32_t));
 788   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 789   ++cnt;
 790   ++last_idx;
 791
 792   iov[2 + cnt].iov_base = (void *) (time->wt_fmt_ampm ?: empty_wstr);
 793   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 794                           * sizeof (uint32_t));
 795   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 796   ++cnt;
 797   ++last_idx;
 798
 799   iov[2 + cnt].iov_base = (void *) (time->wera_year ?: empty_wstr);
 800   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 801                           * sizeof (uint32_t));
 802   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 803   ++cnt;
 804   ++last_idx;
 805
 806   iov[2 + cnt].iov_base = (void *) (time->wera_d_fmt ?: empty_wstr);
 807   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 808                           * sizeof (uint32_t));
 809   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 810   ++cnt;
 811   ++last_idx;
 812
 813   idx[1 + last_idx] = idx[last_idx];
 814   for (num = 0; num < 100; ++num, ++cnt)
 815     {
 816       iov[2 + cnt].iov_base = (void *) (time->walt_digits[num]
 817                                         ?: empty_wstr);
 818       iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 819                               * sizeof (uint32_t));
 820       idx[1 + last_idx] += iov[2 + cnt].iov_len;
 821     }
 822   ++last_idx;
 823
 824   iov[2 + cnt].iov_base = (void *) (time->wera_d_t_fmt ?: empty_wstr);
 825   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 826                           * sizeof (uint32_t));
 827   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 828   ++cnt;
 829   ++last_idx;
 830
 831   iov[2 + cnt].iov_base = (void *) (time->wera_t_fmt ?: empty_wstr);
 832   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 833                           * sizeof (uint32_t));
 834   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 835   ++cnt;
 836   ++last_idx;
 837
 838   iov[2 + cnt].iov_base = (void *) &time->week_ndays;
 839   iov[2 + cnt].iov_len = 1;
 840   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 841   ++cnt;
 842   ++last_idx;
 843
 844   /* We must align the following data.  */
 845   iov[2 + cnt].iov_base = (void *) "\0\0";
 846   iov[2 + cnt].iov_len = ((idx[last_idx] + 3) & ~3) - idx[last_idx];
 847   idx[last_idx] = (idx[last_idx] + 3) & ~3;
 848   ++cnt;
 849
 850   iov[2 + cnt].iov_base = (void *) &time->week_1stday;
 851   iov[2 + cnt].iov_len = sizeof(uint32_t);
 852   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 853   ++cnt;
 854   ++last_idx;
 855
 856   iov[2 + cnt].iov_base = (void *) &time->week_1stweek;
 857   iov[2 + cnt].iov_len = 1;
 858   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 859   ++cnt;
 860   ++last_idx;
 861
 862   iov[2 + cnt].iov_base = (void *) &time->first_weekday;
 863   iov[2 + cnt].iov_len = 1;
 864   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 865   ++cnt;
 866   ++last_idx;
 867
 868   iov[2 + cnt].iov_base = (void *) &time->first_workday;
 869   iov[2 + cnt].iov_len = 1;
 870   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 871   ++cnt;
 872   ++last_idx;
 873
 874   iov[2 + cnt].iov_base = (void *) &time->cal_direction;
 875   iov[2 + cnt].iov_len = 1;
 876   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 877   ++cnt;
 878   ++last_idx;
 879
 880   iov[2 + cnt].iov_base = (void *) time->timezone;
 881   iov[2 + cnt].iov_len = strlen (time->timezone) + 1;
 882   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 883   ++cnt;
 884   ++last_idx;
 885
 886   iov[2 + cnt].iov_base = (void *) time->date_fmt;
 887   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 888   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 889   ++cnt;
 890   ++last_idx;
 891
 892   iov[2 + cnt].iov_base = (void *) time->wdate_fmt;
 893   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 894                           * sizeof (uint32_t));
 895   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 896   ++cnt;
 897   ++last_idx;
 898
 899   iov[2 + cnt].iov_base = (void *) charmap->code_set_name;
 900   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 901   ++cnt;
 902   ++last_idx;
 903
 904   assert (cnt == (_NL_ITEM_INDEX (_NL_NUM_LC_TIME)
 905                   + time->num_era - 1
 906                   + 2 * 99
 907                   + 2 + time->num_era * 10 - 1));
 908   assert (last_idx  == _NL_ITEM_INDEX (_NL_NUM_LC_TIME));
 909
 910   write_locale_data (output_path, LC_TIME, "LC_TIME", 2 + cnt, iov);
 911 }
 912
 913
 914 /* The parser for the LC_TIME section of the locale definition.  */
 915 void
 916 time_read (struct linereader *ldfile, struct localedef_t *result,
 917            const struct charmap_t *charmap, const char *repertoire_name,
 918            int ignore_content)
 919 {
 920   struct repertoire_t *repertoire = NULL;
 921   struct locale_time_t *time;
 922   struct token *now;
 923   enum token_t nowtok;
 924   size_t cnt;
 925
 926   /* Get the repertoire we have to use.  */
 927   if (repertoire_name != NULL)
 928     repertoire = repertoire_read (repertoire_name);
 929
 930   /* The rest of the line containing `LC_TIME' must be free.  */
 931   lr_ignore_rest (ldfile, 1);
 932
 933
 934   do
 935     {
 936       now = lr_token (ldfile, charmap, result, repertoire, verbose);
 937       nowtok = now->tok;
 938     }
 939   while (nowtok == tok_eol);
 940
 941   /* If we see `copy' now we are almost done.  */
 942   if (nowtok == tok_copy)
 943     {
 944       handle_copy (ldfile, charmap, repertoire_name, result, tok_lc_time,
 945                    LC_TIME, "LC_TIME", ignore_content);
 946       return;
 947     }
 948
 949   /* Prepare the data structures.  */
 950   time_startup (ldfile, result, ignore_content);
 951   time = result->categories[LC_TIME].time;
 952
 953   while (1)
 954     {
 955       /* Of course we don't proceed beyond the end of file.  */
 956       if (nowtok == tok_eof)
 957         break;
 958
 959       /* Ingore empty lines.  */
 960       if (nowtok == tok_eol)
 961         {
 962           now = lr_token (ldfile, charmap, result, repertoire, verbose);
 963           nowtok = now->tok;
 964           continue;
 965         }
 966
 967       switch (nowtok)
 968         {
 969 #define STRARR_ELEM(cat, min, max) \
 970         case tok_##cat:                                                       \
 971           /* Ignore the rest of the line if we don't need the input of        \
 972              this line.  */                                                   \
 973           if (ignore_content)                                                 \
 974             {                                                                 \
 975               lr_ignore_rest (ldfile, 0);                                     \
 976               break;                                                          \
 977             }                                                                 \
 978                                                                               \
 979           for (cnt = 0; cnt < max; ++cnt)                                     \
 980             {                                                                 \
 981               now = lr_token (ldfile, charmap, result, repertoire, verbose);  \
 982               if (now->tok == tok_eol)                                        \
 983                 {                                                             \
 984                   if (cnt < min)                                              \
 985                     lr_error (ldfile, _("%s: too few values for field `%s'"), \
 986                               "LC_TIME", #cat);                               \
 987                   if (!ignore_content)                                        \
 988                     do                                                        \
 989                       {                                                       \
 990                         time->cat[cnt] = "";                                  \
 991                         time->w##cat[cnt] = empty_wstr;                       \
 992                       }                                                       \
 993                     while (++cnt < max);                                      \
 994                   break;                                                      \
 995                 }                                                             \
 996               else if (now->tok != tok_string)                                \
 997                 goto err_label;                                               \
 998               else if (!ignore_content && (now->val.str.startmb == NULL       \
 999                                            || now->val.str.startwc == NULL))  \
1000                 {                                                             \
1001                   lr_error (ldfile, _("%s: unknown character in field `%s'"), \
1002                             "LC_TIME", #cat);                                 \
1003                   time->cat[cnt] = "";                                        \
1004                   time->w##cat[cnt] = empty_wstr;                             \
1005                 }                                                             \
1006               else if (!ignore_content)                                       \
1007                 {                                                             \
1008                   time->cat[cnt] = now->val.str.startmb;                      \
1009                   time->w##cat[cnt] = now->val.str.startwc;                   \
1010                 }                                                             \
1011                                                                               \
1012               /* Match the semicolon.  */                                     \
1013               now = lr_token (ldfile, charmap, result, repertoire, verbose);  \
1014               if (now->tok != tok_semicolon && now->tok != tok_eol)           \
1015                 break;                                                        \
1016             }                                                                 \
1017           if (now->tok != tok_eol)                                            \
1018             {                                                                 \
1019               while (!ignore_content && cnt < min)                            \
1020                 {                                                             \
1021                   time->cat[cnt] = "";                                        \
1022                   time->w##cat[cnt++] = empty_wstr;                           \
1023                 }                                                             \
1024                                                                               \
1025               if (now->tok == tok_semicolon)                                  \
1026                 {                                                             \
1027                   now = lr_token (ldfile, charmap, result, repertoire,        \
1028                                   verbose);                                   \
1029                   if (now->tok == tok_eol)                                    \
1030                     lr_error (ldfile, _("extra trailing semicolon"));         \
1031                   else if (now->tok == tok_string)                            \
1032                     {                                                         \
1033                       lr_error (ldfile, _("\
1034 %s: too many values for field `%s'"),                                         \
1035                                 "LC_TIME", #cat);                             \
1036                       lr_ignore_rest (ldfile, 0);                             \
1037                     }                                                         \
1038                   else                                                        \
1039                     goto err_label;                                           \
1040                 }                                                             \
1041               else                                                            \
1042                 goto err_label;                                               \
1043             }                                                                 \
1044           time->cat##_defined = 1;                                            \
1045           break
1046
1047           STRARR_ELEM (abday, 7, 7);
1048           STRARR_ELEM (day, 7, 7);
1049           STRARR_ELEM (abmon, 12, 12);
1050           STRARR_ELEM (mon, 12, 12);
1051           STRARR_ELEM (am_pm, 2, 2);
1052           STRARR_ELEM (alt_digits, 0, 100);
1053
1054         case tok_era:
1055           /* Ignore the rest of the line if we don't need the input of
1056              this line.  */
1057           if (ignore_content)
1058             {
1059               lr_ignore_rest (ldfile, 0);
1060               break;
1061             }
1062           do
1063             {
1064               now = lr_token (ldfile, charmap, result, repertoire, verbose);
1065               if (now->tok != tok_string)
1066                 goto err_label;
1067               if (!ignore_content && (now->val.str.startmb == NULL
1068                                       || now->val.str.startwc == NULL))
1069                 {
1070                   lr_error (ldfile, _("%s: unknown character in field `%s'"),
1071                             "LC_TIME", "era");
1072                   lr_ignore_rest (ldfile, 0);
1073                   break;
1074                 }
1075               if (!ignore_content)
1076                 {
1077                   time->era = xrealloc (time->era,
1078                                         (time->num_era + 1) * sizeof (char *));
1079                   time->era[time->num_era] = now->val.str.startmb;
1080
1081                   time->wera = xrealloc (time->wera,
1082                                          (time->num_era + 1)
1083                                          * sizeof (char *));
1084                   time->wera[time->num_era++] = now->val.str.startwc;
1085                 }
1086               now = lr_token (ldfile, charmap, result, repertoire, verbose);
1087               if (now->tok != tok_eol && now->tok != tok_semicolon)
1088                 goto err_label;
1089             }
1090           while (now->tok == tok_semicolon);
1091           break;
1092
1093 #define STR_ELEM(cat) \
1094         case tok_##cat:                                                       \
1095           /* Ignore the rest of the line if we don't need the input of        \
1096              this line.  */                                                   \
1097           if (ignore_content)                                                 \
1098             {                                                                 \
1099               lr_ignore_rest (ldfile, 0);                                     \
1100               break;                                                          \
1101             }                                                                 \
1102                                                                               \
1103           now = lr_token (ldfile, charmap, result, repertoire, verbose);      \
1104           if (now->tok != tok_string)                                         \
1105             goto err_label;                                                   \
1106           else if (time->cat != NULL)                                         \
1107             lr_error (ldfile, _("\
1108 %s: field `%s' declared more than once"), "LC_TIME", #cat);                   \
1109           else if (!ignore_content && (now->val.str.startmb == NULL           \
1110                                        || now->val.str.startwc == NULL))      \
1111             {                                                                 \
1112               lr_error (ldfile, _("%s: unknown character in field `%s'"),     \
1113                         "LC_TIME", #cat);                                     \
1114               time->cat = "";                                                 \
1115               time->w##cat = empty_wstr;                                      \
1116             }                                                                 \
1117           else if (!ignore_content)                                           \
1118             {                                                                 \
1119               time->cat = now->val.str.startmb;                               \
1120               time->w##cat = now->val.str.startwc;                            \
1121             }                                                                 \
1122           break
1123
1124           STR_ELEM (d_t_fmt);
1125           STR_ELEM (d_fmt);
1126           STR_ELEM (t_fmt);
1127           STR_ELEM (t_fmt_ampm);
1128           STR_ELEM (era_year);
1129           STR_ELEM (era_d_t_fmt);
1130           STR_ELEM (era_d_fmt);
1131           STR_ELEM (era_t_fmt);
1132           STR_ELEM (timezone);
1133           STR_ELEM (date_fmt);
1134
1135 #define INT_ELEM(cat) \
1136         case tok_##cat:                                                       \
1137           /* Ignore the rest of the line if we don't need the input of        \
1138              this line.  */                                                   \
1139           if (ignore_content)                                                 \
1140             {                                                                 \
1141               lr_ignore_rest (ldfile, 0);                                     \
1142               break;                                                          \
1143             }                                                                 \
1144                                                                               \
1145           now = lr_token (ldfile, charmap, result, repertoire, verbose);      \
1146           if (now->tok != tok_number)                                         \
1147             goto err_label;                                                   \
1148           else if (time->cat != 0)                                            \
1149             lr_error (ldfile, _("%s: field `%s' declared more than once"),    \
1150                       "LC_TIME", #cat);                                       \
1151           else if (!ignore_content)                                           \
1152             time->cat = now->val.num;                                         \
1153           break
1154
1155           INT_ELEM (first_weekday);
1156           INT_ELEM (first_workday);
1157           INT_ELEM (cal_direction);
1158
1159         case tok_week:
1160           /* Ignore the rest of the line if we don't need the input of
1161              this line.  */
1162           if (ignore_content)
1163             {
1164               lr_ignore_rest (ldfile, 0);
1165               break;
1166             }
1167
1168           now = lr_token (ldfile, charmap, result, repertoire, verbose);
1169           if (now->tok != tok_number)
1170             goto err_label;
1171           time->week_ndays = now->val.num;
1172
1173           now = lr_token (ldfile, charmap, result, repertoire, verbose);
1174           if (now->tok != tok_semicolon)
1175             goto err_label;
1176
1177           now = lr_token (ldfile, charmap, result, repertoire, verbose);
1178           if (now->tok != tok_number)
1179             goto err_label;
1180           time->week_1stday = now->val.num;
1181
1182           now = lr_token (ldfile, charmap, result, repertoire, verbose);
1183           if (now->tok != tok_semicolon)
1184             goto err_label;
1185
1186           now = lr_token (ldfile, charmap, result, repertoire, verbose);
1187           if (now->tok != tok_number)
1188             goto err_label;
1189           time->week_1stweek = now->val.num;
1190
1191           lr_ignore_rest (ldfile,  1);
1192           break;
1193
1194         case tok_end:
1195           /* Next we assume `LC_TIME'.  */
1196           now = lr_token (ldfile, charmap, result, repertoire, verbose);
1197           if (now->tok == tok_eof)
1198             break;
1199           if (now->tok == tok_eol)
1200             lr_error (ldfile, _("%s: incomplete `END' line"), "LC_TIME");
1201           else if (now->tok != tok_lc_time)
1202             lr_error (ldfile, _("\
1203 %1$s: definition does not end with `END %1$s'"), "LC_TIME");
1204           lr_ignore_rest (ldfile, now->tok == tok_lc_time);
1205           return;
1206
1207         default:
1208         err_label:
1209           SYNTAX_ERROR (_("%s: syntax error"), "LC_TIME");
1210         }
1211
1212       /* Prepare for the next round.  */
1213       now = lr_token (ldfile, charmap, result, repertoire, verbose);
1214       nowtok = now->tok;
1215     }
1216
1217   /* When we come here we reached the end of the file.  */
1218   lr_error (ldfile, _("%s: premature end of file"), "LC_TIME");
1219 }