locale/programs/ld-time.c

   1 /* Copyright (C) 1995-2005, 2006 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           if (wstr != NULL)
 472             {
 473               wstr = wcschr (wstr + 1, L':');   /* end name */
 474               *wstr = L'\0';
 475               time->era_entries[idx].wformat = (uint32_t *) wstr + 1;
 476             }
 477           else
 478             time->era_entries[idx].wformat = NULL;
 479         }
 480     }
 481
 482   if (time->week_ndays == 0)
 483     time->week_ndays = 7;
 484
 485   if (time->week_1stday == 0)
 486     time->week_1stday = 19971130;
 487
 488   if (time->week_1stweek > time->week_ndays)
 489     WITH_CUR_LOCALE (error (0, 0, _("\
 490 %s: third operand for value of field `%s' must not be larger than %d"),
 491                             "LC_TIME", "week", 7));
 492
 493   if (time->first_weekday == '\0')
 494     /* The definition does not specify this so the default is used.  */
 495     time->first_weekday = 1;
 496   else if (time->first_weekday > time->week_ndays)
 497     WITH_CUR_LOCALE (error (0, 0, _("\
 498 %s: values of field `%s' must not be larger than %d"),
 499                             "LC_TIME", "first_weekday", 7));
 500
 501   if (time->first_workday == '\0')
 502     /* The definition does not specify this so the default is used.  */
 503     time->first_workday = 1;
 504   else if (time->first_workday > time->week_ndays)
 505     WITH_CUR_LOCALE (error (0, 0, _("\
 506 %s: values of field `%s' must not be larger than %d"),
 507                             "LC_TIME", "first_workday", 7));
 508
 509   if (time->cal_direction == '\0')
 510     /* The definition does not specify this so the default is used.  */
 511     time->cal_direction = 1;
 512   else if (time->cal_direction > 3)
 513     WITH_CUR_LOCALE (error (0, 0, _("\
 514 %s: values for field `%s' must not be larger than %d"),
 515                             "LC_TIME", "cal_direction", 3));
 516
 517   /* XXX We don't perform any tests on the timezone value since this is
 518      simply useless, stupid $&$!@...  */
 519   if (time->timezone == NULL)
 520     time->timezone = "";
 521
 522   if (time->date_fmt == NULL)
 523     time->date_fmt = "%a %b %e %H:%M:%S %Z %Y";
 524   if (time->wdate_fmt == NULL)
 525     time->wdate_fmt = (const uint32_t *) L"%a %b %e %H:%M:%S %Z %Y";
 526 }
 527
 528
 529 void
 530 time_output (struct localedef_t *locale, const struct charmap_t *charmap,
 531              const char *output_path)
 532 {
 533   struct locale_time_t *time = locale->categories[LC_TIME].time;
 534   struct iovec *iov = alloca (sizeof *iov
 535                               * (2 + _NL_ITEM_INDEX (_NL_NUM_LC_TIME)
 536                                  + time->num_era - 1
 537                                  + 2 * 99
 538                                  + 2 + time->num_era * 10 - 1));
 539   struct locale_file data;
 540   uint32_t idx[_NL_ITEM_INDEX (_NL_NUM_LC_TIME)];
 541   size_t cnt, last_idx, num, n;
 542
 543   data.magic = LIMAGIC (LC_TIME);
 544   data.n = _NL_ITEM_INDEX (_NL_NUM_LC_TIME);
 545   iov[0].iov_base = (void *) &data;
 546   iov[0].iov_len = sizeof (data);
 547
 548   iov[1].iov_base = (void *) idx;
 549   iov[1].iov_len = sizeof (idx);
 550
 551   idx[0] = iov[0].iov_len + iov[1].iov_len;
 552
 553   /* The ab'days.  */
 554   for (cnt = 0; cnt <= _NL_ITEM_INDEX (ABDAY_7); ++cnt)
 555     {
 556       iov[2 + cnt].iov_base =
 557         (void *) (time->abday[cnt - _NL_ITEM_INDEX (ABDAY_1)] ?: "");
 558       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 559       idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
 560     }
 561
 562   /* The days.  */
 563   for (; cnt <= _NL_ITEM_INDEX (DAY_7); ++cnt)
 564     {
 565       iov[2 + cnt].iov_base =
 566         (void *) (time->day[cnt - _NL_ITEM_INDEX (DAY_1)] ?: "");
 567       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 568       idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
 569     }
 570
 571   /* The ab'mons.  */
 572   for (; cnt <= _NL_ITEM_INDEX (ABMON_12); ++cnt)
 573     {
 574       iov[2 + cnt].iov_base =
 575         (void *) (time->abmon[cnt - _NL_ITEM_INDEX (ABMON_1)] ?: "");
 576       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 577       idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
 578     }
 579
 580   /* The mons.  */
 581   for (; cnt <= _NL_ITEM_INDEX (MON_12); ++cnt)
 582     {
 583       iov[2 + cnt].iov_base =
 584         (void *) (time->mon[cnt - _NL_ITEM_INDEX (MON_1)] ?: "");
 585       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 586       idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
 587     }
 588
 589   /* AM/PM.  */
 590   for (; cnt <= _NL_ITEM_INDEX (PM_STR); ++cnt)
 591     {
 592       iov[2 + cnt].iov_base =
 593         (void *) (time->am_pm[cnt - _NL_ITEM_INDEX (AM_STR)] ?: "");
 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     }
 597
 598   iov[2 + cnt].iov_base = (void *) (time->d_t_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->d_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 ?: "");
 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   ++cnt;
 612
 613   iov[2 + cnt].iov_base = (void *) (time->t_fmt_ampm ?: "");
 614   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 615   idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
 616   last_idx = ++cnt;
 617
 618   idx[1 + last_idx] = idx[last_idx];
 619   for (num = 0; num < time->num_era; ++num, ++cnt)
 620     {
 621       iov[2 + cnt].iov_base = (void *) time->era[num];
 622       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 623       idx[1 + last_idx] += iov[2 + cnt].iov_len;
 624     }
 625   ++last_idx;
 626
 627   iov[2 + cnt].iov_base = (void *) (time->era_year ?: "");
 628   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 629   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 630   ++cnt;
 631   ++last_idx;
 632
 633   iov[2 + cnt].iov_base = (void *) (time->era_d_fmt ?: "");
 634   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 635   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 636   ++cnt;
 637   ++last_idx;
 638
 639   idx[1 + last_idx] = idx[last_idx];
 640   for (num = 0; num < 100; ++num, ++cnt)
 641     {
 642       iov[2 + cnt].iov_base = (void *) (time->alt_digits[num] ?: "");
 643       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 644       idx[1 + last_idx] += iov[2 + cnt].iov_len;
 645     }
 646   ++last_idx;
 647
 648   iov[2 + cnt].iov_base = (void *) (time->era_d_t_fmt ?: "");
 649   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 650   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 651   ++cnt;
 652   ++last_idx;
 653
 654   iov[2 + cnt].iov_base = (void *) (time->era_t_fmt ?: "");
 655   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 656   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 657   ++cnt;
 658   ++last_idx;
 659
 660
 661   /* We must align the following data.  */
 662   iov[2 + cnt].iov_base = (void *) "\0\0";
 663   iov[2 + cnt].iov_len = ((idx[last_idx] + 3) & ~3) - idx[last_idx];
 664   idx[last_idx] = (idx[last_idx] + 3) & ~3;
 665   ++cnt;
 666
 667   /* The `era' data in usable form.  */
 668   iov[2 + cnt].iov_base = (void *) &time->num_era;
 669   iov[2 + cnt].iov_len = sizeof (uint32_t);
 670   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 671   ++cnt;
 672   ++last_idx;
 673
 674   idx[1 + last_idx] = idx[last_idx];
 675   for (num = 0; num < time->num_era; ++num)
 676     {
 677       size_t l, l2;
 678
 679       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].direction;
 680       iov[2 + cnt].iov_len = sizeof (int32_t);
 681       ++cnt;
 682       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].offset;
 683       iov[2 + cnt].iov_len = sizeof (int32_t);
 684       ++cnt;
 685       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].start_date[0];
 686       iov[2 + cnt].iov_len = sizeof (int32_t);
 687       ++cnt;
 688       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].start_date[1];
 689       iov[2 + cnt].iov_len = sizeof (int32_t);
 690       ++cnt;
 691       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].start_date[2];
 692       iov[2 + cnt].iov_len = sizeof (int32_t);
 693       ++cnt;
 694       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].stop_date[0];
 695       iov[2 + cnt].iov_len = sizeof (int32_t);
 696       ++cnt;
 697       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].stop_date[1];
 698       iov[2 + cnt].iov_len = sizeof (int32_t);
 699       ++cnt;
 700       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].stop_date[2];
 701       iov[2 + cnt].iov_len = sizeof (int32_t);
 702       ++cnt;
 703
 704       l = ((char *) rawmemchr (time->era_entries[num].format, '\0')
 705            - time->era_entries[num].name) + 1;
 706       l2 = (l + 3) & ~3;
 707       iov[2 + cnt].iov_base = alloca (l2);
 708       memset (mempcpy (iov[2 + cnt].iov_base, time->era_entries[num].name, l),
 709               '\0', l2 - l);
 710       iov[2 + cnt].iov_len = l2;
 711       ++cnt;
 712
 713       idx[1 + last_idx] += 8 * sizeof (int32_t) + l2;
 714
 715       assert (idx[1 + last_idx] % 4 == 0);
 716
 717       iov[2 + cnt].iov_base = (void *) time->era_entries[num].wname;
 718       iov[2 + cnt].iov_len = ((wcschr ((wchar_t *) time->era_entries[num].wformat, L'\0')
 719                                - (wchar_t *) time->era_entries[num].wname + 1)
 720                               * sizeof (uint32_t));
 721       idx[1 + last_idx] += iov[2 + cnt].iov_len;
 722       ++cnt;
 723     }
 724   ++last_idx;
 725
 726   /* The wide character ab'days.  */
 727   for (n = 0; n < 7; ++n, ++cnt, ++last_idx)
 728     {
 729       iov[2 + cnt].iov_base =
 730         (void *) (time->wabday[n] ?: empty_wstr);
 731       iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 732                               * sizeof (uint32_t));
 733       idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 734     }
 735
 736   /* The wide character days.  */
 737   for (n = 0; n < 7; ++n, ++cnt, ++last_idx)
 738     {
 739       iov[2 + cnt].iov_base =
 740         (void *) (time->wday[n] ?: empty_wstr);
 741       iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 742                               * sizeof (uint32_t));
 743       idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 744     }
 745
 746   /* The wide character ab'mons.  */
 747   for (n = 0; n < 12; ++n, ++cnt, ++last_idx)
 748     {
 749       iov[2 + cnt].iov_base =
 750         (void *) (time->wabmon[n] ?: empty_wstr);
 751       iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 752                               * sizeof (uint32_t));
 753       idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 754     }
 755
 756   /* The wide character mons.  */
 757   for (n = 0; n < 12; ++n, ++cnt, ++last_idx)
 758     {
 759       iov[2 + cnt].iov_base =
 760         (void *) (time->wmon[n] ?: empty_wstr);
 761       iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 762                               * sizeof (uint32_t));
 763       idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 764     }
 765
 766   /* Wide character AM/PM.  */
 767   for (n = 0; n < 2; ++n, ++cnt, ++last_idx)
 768     {
 769       iov[2 + cnt].iov_base =
 770         (void *) (time->wam_pm[n] ?: empty_wstr);
 771       iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 772                               * sizeof (uint32_t));
 773       idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 774     }
 775
 776   iov[2 + cnt].iov_base = (void *) (time->wd_t_fmt ?: empty_wstr);
 777   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 778                           * sizeof (uint32_t));
 779   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 780   ++cnt;
 781   ++last_idx;
 782
 783   iov[2 + cnt].iov_base = (void *) (time->wd_fmt ?: empty_wstr);
 784   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 785                           * sizeof (uint32_t));
 786   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 787   ++cnt;
 788   ++last_idx;
 789
 790   iov[2 + cnt].iov_base = (void *) (time->wt_fmt ?: empty_wstr);
 791   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 792                           * sizeof (uint32_t));
 793   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 794   ++cnt;
 795   ++last_idx;
 796
 797   iov[2 + cnt].iov_base = (void *) (time->wt_fmt_ampm ?: empty_wstr);
 798   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 799                           * sizeof (uint32_t));
 800   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 801   ++cnt;
 802   ++last_idx;
 803
 804   iov[2 + cnt].iov_base = (void *) (time->wera_year ?: empty_wstr);
 805   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 806                           * sizeof (uint32_t));
 807   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 808   ++cnt;
 809   ++last_idx;
 810
 811   iov[2 + cnt].iov_base = (void *) (time->wera_d_fmt ?: empty_wstr);
 812   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 813                           * sizeof (uint32_t));
 814   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 815   ++cnt;
 816   ++last_idx;
 817
 818   idx[1 + last_idx] = idx[last_idx];
 819   for (num = 0; num < 100; ++num, ++cnt)
 820     {
 821       iov[2 + cnt].iov_base = (void *) (time->walt_digits[num]
 822                                         ?: empty_wstr);
 823       iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 824                               * sizeof (uint32_t));
 825       idx[1 + last_idx] += iov[2 + cnt].iov_len;
 826     }
 827   ++last_idx;
 828
 829   iov[2 + cnt].iov_base = (void *) (time->wera_d_t_fmt ?: empty_wstr);
 830   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 831                           * sizeof (uint32_t));
 832   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 833   ++cnt;
 834   ++last_idx;
 835
 836   iov[2 + cnt].iov_base = (void *) (time->wera_t_fmt ?: empty_wstr);
 837   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 838                           * sizeof (uint32_t));
 839   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 840   ++cnt;
 841   ++last_idx;
 842
 843   iov[2 + cnt].iov_base = (void *) &time->week_ndays;
 844   iov[2 + cnt].iov_len = 1;
 845   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 846   ++cnt;
 847   ++last_idx;
 848
 849   /* We must align the following data.  */
 850   iov[2 + cnt].iov_base = (void *) "\0\0";
 851   iov[2 + cnt].iov_len = ((idx[last_idx] + 3) & ~3) - idx[last_idx];
 852   idx[last_idx] = (idx[last_idx] + 3) & ~3;
 853   ++cnt;
 854
 855   iov[2 + cnt].iov_base = (void *) &time->week_1stday;
 856   iov[2 + cnt].iov_len = sizeof(uint32_t);
 857   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 858   ++cnt;
 859   ++last_idx;
 860
 861   iov[2 + cnt].iov_base = (void *) &time->week_1stweek;
 862   iov[2 + cnt].iov_len = 1;
 863   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 864   ++cnt;
 865   ++last_idx;
 866
 867   iov[2 + cnt].iov_base = (void *) &time->first_weekday;
 868   iov[2 + cnt].iov_len = 1;
 869   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 870   ++cnt;
 871   ++last_idx;
 872
 873   iov[2 + cnt].iov_base = (void *) &time->first_workday;
 874   iov[2 + cnt].iov_len = 1;
 875   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 876   ++cnt;
 877   ++last_idx;
 878
 879   iov[2 + cnt].iov_base = (void *) &time->cal_direction;
 880   iov[2 + cnt].iov_len = 1;
 881   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 882   ++cnt;
 883   ++last_idx;
 884
 885   iov[2 + cnt].iov_base = (void *) time->timezone;
 886   iov[2 + cnt].iov_len = strlen (time->timezone) + 1;
 887   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 888   ++cnt;
 889   ++last_idx;
 890
 891   iov[2 + cnt].iov_base = (void *) time->date_fmt;
 892   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 893   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 894   ++cnt;
 895   ++last_idx;
 896
 897   iov[2 + cnt].iov_base = (void *) time->wdate_fmt;
 898   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
 899                           * sizeof (uint32_t));
 900   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
 901   ++cnt;
 902   ++last_idx;
 903
 904   iov[2 + cnt].iov_base = (void *) charmap->code_set_name;
 905   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
 906   ++cnt;
 907   ++last_idx;
 908
 909   assert (cnt == (_NL_ITEM_INDEX (_NL_NUM_LC_TIME)
 910                   + time->num_era - 1
 911                   + 2 * 99
 912                   + 2 + time->num_era * 10 - 1));
 913   assert (last_idx  == _NL_ITEM_INDEX (_NL_NUM_LC_TIME));
 914
 915   write_locale_data (output_path, LC_TIME, "LC_TIME", 2 + cnt, iov);
 916 }
 917
 918
 919 /* The parser for the LC_TIME section of the locale definition.  */
 920 void
 921 time_read (struct linereader *ldfile, struct localedef_t *result,
 922            const struct charmap_t *charmap, const char *repertoire_name,
 923            int ignore_content)
 924 {
 925   struct repertoire_t *repertoire = NULL;
 926   struct locale_time_t *time;
 927   struct token *now;
 928   enum token_t nowtok;
 929   size_t cnt;
 930
 931   /* Get the repertoire we have to use.  */
 932   if (repertoire_name != NULL)
 933     repertoire = repertoire_read (repertoire_name);
 934
 935   /* The rest of the line containing `LC_TIME' must be free.  */
 936   lr_ignore_rest (ldfile, 1);
 937
 938
 939   do
 940     {
 941       now = lr_token (ldfile, charmap, result, repertoire, verbose);
 942       nowtok = now->tok;
 943     }
 944   while (nowtok == tok_eol);
 945
 946   /* If we see `copy' now we are almost done.  */
 947   if (nowtok == tok_copy)
 948     {
 949       handle_copy (ldfile, charmap, repertoire_name, result, tok_lc_time,
 950                    LC_TIME, "LC_TIME", ignore_content);
 951       return;
 952     }
 953
 954   /* Prepare the data structures.  */
 955   time_startup (ldfile, result, ignore_content);
 956   time = result->categories[LC_TIME].time;
 957
 958   while (1)
 959     {
 960       /* Of course we don't proceed beyond the end of file.  */
 961       if (nowtok == tok_eof)
 962         break;
 963
 964       /* Ingore empty lines.  */
 965       if (nowtok == tok_eol)
 966         {
 967           now = lr_token (ldfile, charmap, result, repertoire, verbose);
 968           nowtok = now->tok;
 969           continue;
 970         }
 971
 972       switch (nowtok)
 973         {
 974 #define STRARR_ELEM(cat, min, max) \
 975         case tok_##cat:                                                       \
 976           /* Ignore the rest of the line if we don't need the input of        \
 977              this line.  */                                                   \
 978           if (ignore_content)                                                 \
 979             {                                                                 \
 980               lr_ignore_rest (ldfile, 0);                                     \
 981               break;                                                          \
 982             }                                                                 \
 983                                                                               \
 984           for (cnt = 0; cnt < max; ++cnt)                                     \
 985             {                                                                 \
 986               now = lr_token (ldfile, charmap, result, repertoire, verbose);  \
 987               if (now->tok == tok_eol)                                        \
 988                 {                                                             \
 989                   if (cnt < min)                                              \
 990                     lr_error (ldfile, _("%s: too few values for field `%s'"), \
 991                               "LC_TIME", #cat);                               \
 992                   if (!ignore_content)                                        \
 993                     do                                                        \
 994                       {                                                       \
 995                         time->cat[cnt] = "";                                  \
 996                         time->w##cat[cnt] = empty_wstr;                       \
 997                       }                                                       \
 998                     while (++cnt < max);                                      \
 999                   break;                                                      \
1000                 }                                                             \
1001               else if (now->tok != tok_string)                                \
1002                 goto err_label;                                               \
1003               else if (!ignore_content && (now->val.str.startmb == NULL       \
1004                                            || now->val.str.startwc == NULL))  \
1005                 {                                                             \
1006                   lr_error (ldfile, _("%s: unknown character in field `%s'"), \
1007                             "LC_TIME", #cat);                                 \
1008                   time->cat[cnt] = "";                                        \
1009                   time->w##cat[cnt] = empty_wstr;                             \
1010                 }                                                             \
1011               else if (!ignore_content)                                       \
1012                 {                                                             \
1013                   time->cat[cnt] = now->val.str.startmb;                      \
1014                   time->w##cat[cnt] = now->val.str.startwc;                   \
1015                 }                                                             \
1016                                                                               \
1017               /* Match the semicolon.  */                                     \
1018               now = lr_token (ldfile, charmap, result, repertoire, verbose);  \
1019               if (now->tok != tok_semicolon && now->tok != tok_eol)           \
1020                 break;                                                        \
1021             }                                                                 \
1022           if (now->tok != tok_eol)                                            \
1023             {                                                                 \
1024               while (!ignore_content && cnt < min)                            \
1025                 {                                                             \
1026                   time->cat[cnt] = "";                                        \
1027                   time->w##cat[cnt++] = empty_wstr;                           \
1028                 }                                                             \
1029                                                                               \
1030               if (now->tok == tok_semicolon)                                  \
1031                 {                                                             \
1032                   now = lr_token (ldfile, charmap, result, repertoire,        \
1033                                   verbose);                                   \
1034                   if (now->tok == tok_eol)                                    \
1035                     lr_error (ldfile, _("extra trailing semicolon"));         \
1036                   else if (now->tok == tok_string)                            \
1037                     {                                                         \
1038                       lr_error (ldfile, _("\
1039 %s: too many values for field `%s'"),                                         \
1040                                 "LC_TIME", #cat);                             \
1041                       lr_ignore_rest (ldfile, 0);                             \
1042                     }                                                         \
1043                   else                                                        \
1044                     goto err_label;                                           \
1045                 }                                                             \
1046               else                                                            \
1047                 goto err_label;                                               \
1048             }                                                                 \
1049           time->cat##_defined = 1;                                            \
1050           break
1051
1052           STRARR_ELEM (abday, 7, 7);
1053           STRARR_ELEM (day, 7, 7);
1054           STRARR_ELEM (abmon, 12, 12);
1055           STRARR_ELEM (mon, 12, 12);
1056           STRARR_ELEM (am_pm, 2, 2);
1057           STRARR_ELEM (alt_digits, 0, 100);
1058
1059         case tok_era:
1060           /* Ignore the rest of the line if we don't need the input of
1061              this line.  */
1062           if (ignore_content)
1063             {
1064               lr_ignore_rest (ldfile, 0);
1065               break;
1066             }
1067           do
1068             {
1069               now = lr_token (ldfile, charmap, result, repertoire, verbose);
1070               if (now->tok != tok_string)
1071                 goto err_label;
1072               if (!ignore_content && (now->val.str.startmb == NULL
1073                                       || now->val.str.startwc == NULL))
1074                 {
1075                   lr_error (ldfile, _("%s: unknown character in field `%s'"),
1076                             "LC_TIME", "era");
1077                   lr_ignore_rest (ldfile, 0);
1078                   break;
1079                 }
1080               if (!ignore_content)
1081                 {
1082                   time->era = xrealloc (time->era,
1083                                         (time->num_era + 1) * sizeof (char *));
1084                   time->era[time->num_era] = now->val.str.startmb;
1085
1086                   time->wera = xrealloc (time->wera,
1087                                          (time->num_era + 1)
1088                                          * sizeof (char *));
1089                   time->wera[time->num_era++] = now->val.str.startwc;
1090                 }
1091               now = lr_token (ldfile, charmap, result, repertoire, verbose);
1092               if (now->tok != tok_eol && now->tok != tok_semicolon)
1093                 goto err_label;
1094             }
1095           while (now->tok == tok_semicolon);
1096           break;
1097
1098 #define STR_ELEM(cat) \
1099         case tok_##cat:                                                       \
1100           /* Ignore the rest of the line if we don't need the input of        \
1101              this line.  */                                                   \
1102           if (ignore_content)                                                 \
1103             {                                                                 \
1104               lr_ignore_rest (ldfile, 0);                                     \
1105               break;                                                          \
1106             }                                                                 \
1107                                                                               \
1108           now = lr_token (ldfile, charmap, result, repertoire, verbose);      \
1109           if (now->tok != tok_string)                                         \
1110             goto err_label;                                                   \
1111           else if (time->cat != NULL)                                         \
1112             lr_error (ldfile, _("\
1113 %s: field `%s' declared more than once"), "LC_TIME", #cat);                   \
1114           else if (!ignore_content && (now->val.str.startmb == NULL           \
1115                                        || now->val.str.startwc == NULL))      \
1116             {                                                                 \
1117               lr_error (ldfile, _("%s: unknown character in field `%s'"),     \
1118                         "LC_TIME", #cat);                                     \
1119               time->cat = "";                                                 \
1120               time->w##cat = empty_wstr;                                      \
1121             }                                                                 \
1122           else if (!ignore_content)                                           \
1123             {                                                                 \
1124               time->cat = now->val.str.startmb;                               \
1125               time->w##cat = now->val.str.startwc;                            \
1126             }                                                                 \
1127           break
1128
1129           STR_ELEM (d_t_fmt);
1130           STR_ELEM (d_fmt);
1131           STR_ELEM (t_fmt);
1132           STR_ELEM (t_fmt_ampm);
1133           STR_ELEM (era_year);
1134           STR_ELEM (era_d_t_fmt);
1135           STR_ELEM (era_d_fmt);
1136           STR_ELEM (era_t_fmt);
1137           STR_ELEM (timezone);
1138           STR_ELEM (date_fmt);
1139
1140 #define INT_ELEM(cat) \
1141         case tok_##cat:                                                       \
1142           /* Ignore the rest of the line if we don't need the input of        \
1143              this line.  */                                                   \
1144           if (ignore_content)                                                 \
1145             {                                                                 \
1146               lr_ignore_rest (ldfile, 0);                                     \
1147               break;                                                          \
1148             }                                                                 \
1149                                                                               \
1150           now = lr_token (ldfile, charmap, result, repertoire, verbose);      \
1151           if (now->tok != tok_number)                                         \
1152             goto err_label;                                                   \
1153           else if (time->cat != 0)                                            \
1154             lr_error (ldfile, _("%s: field `%s' declared more than once"),    \
1155                       "LC_TIME", #cat);                                       \
1156           else if (!ignore_content)                                           \
1157             time->cat = now->val.num;                                         \
1158           break
1159
1160           INT_ELEM (first_weekday);
1161           INT_ELEM (first_workday);
1162           INT_ELEM (cal_direction);
1163
1164         case tok_week:
1165           /* Ignore the rest of the line if we don't need the input of
1166              this line.  */
1167           if (ignore_content)
1168             {
1169               lr_ignore_rest (ldfile, 0);
1170               break;
1171             }
1172
1173           now = lr_token (ldfile, charmap, result, repertoire, verbose);
1174           if (now->tok != tok_number)
1175             goto err_label;
1176           time->week_ndays = now->val.num;
1177
1178           now = lr_token (ldfile, charmap, result, repertoire, verbose);
1179           if (now->tok != tok_semicolon)
1180             goto err_label;
1181
1182           now = lr_token (ldfile, charmap, result, repertoire, verbose);
1183           if (now->tok != tok_number)
1184             goto err_label;
1185           time->week_1stday = now->val.num;
1186
1187           now = lr_token (ldfile, charmap, result, repertoire, verbose);
1188           if (now->tok != tok_semicolon)
1189             goto err_label;
1190
1191           now = lr_token (ldfile, charmap, result, repertoire, verbose);
1192           if (now->tok != tok_number)
1193             goto err_label;
1194           time->week_1stweek = now->val.num;
1195
1196           lr_ignore_rest (ldfile,  1);
1197           break;
1198
1199         case tok_end:
1200           /* Next we assume `LC_TIME'.  */
1201           now = lr_token (ldfile, charmap, result, repertoire, verbose);
1202           if (now->tok == tok_eof)
1203             break;
1204           if (now->tok == tok_eol)
1205             lr_error (ldfile, _("%s: incomplete `END' line"), "LC_TIME");
1206           else if (now->tok != tok_lc_time)
1207             lr_error (ldfile, _("\
1208 %1$s: definition does not end with `END %1$s'"), "LC_TIME");
1209           lr_ignore_rest (ldfile, now->tok == tok_lc_time);
1210           return;
1211
1212         default:
1213         err_label:
1214           SYNTAX_ERROR (_("%s: syntax error"), "LC_TIME");
1215         }
1216
1217       /* Prepare for the next round.  */
1218       now = lr_token (ldfile, charmap, result, repertoire, verbose);
1219       nowtok = now->tok;
1220     }
1221
1222   /* When we come here we reached the end of the file.  */
1223   lr_error (ldfile, _("%s: premature end of file"), "LC_TIME");
1224 }