locale/programs/ld-time.c

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