6245b0f05e87b8c0ec538926059daa744551f586
[kopensolaris-gnu/glibc.git] / locale / programs / ld-time.c
1 /* Copyright (C) 1995-1999, 2000, 2001 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    The GNU C Library is free software; you can redistribute it and/or
6    modify it under the terms of the GNU Lesser General Public
7    License as published by the Free Software Foundation; either
8    version 2.1 of the License, or (at your option) any later version.
9
10    The GNU C Library 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 GNU
13    Lesser General Public License for more details.
14
15    You should have received a copy of the GNU Lesser General Public
16    License along with the GNU C Library; if not, write to the Free
17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
18    02111-1307 USA.  */
19
20 #ifdef HAVE_CONFIG_H
21 # include <config.h>
22 #endif
23
24 #include <byteswap.h>
25 #include <langinfo.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <wchar.h>
29 #include <sys/uio.h>
30
31 #include <assert.h>
32
33 #include "linereader.h"
34 #include "localedef.h"
35 #include "localeinfo.h"
36 #include "locfile.h"
37
38
39 /* Entry describing an entry of the era specification.  */
40 struct era_data
41 {
42   int32_t direction;
43   int32_t offset;
44   int32_t start_date[3];
45   int32_t stop_date[3];
46   const char *name;
47   const char *format;
48   uint32_t *wname;
49   uint32_t *wformat;
50 };
51
52
53 /* The real definition of the struct for the LC_TIME locale.  */
54 struct locale_time_t
55 {
56   const char *abday[7];
57   const uint32_t *wabday[7];
58   int abday_defined;
59   const char *day[7];
60   const uint32_t *wday[7];
61   int day_defined;
62   const char *abmon[12];
63   const uint32_t *wabmon[12];
64   int abmon_defined;
65   const char *mon[12];
66   const uint32_t *wmon[12];
67   int mon_defined;
68   const char *am_pm[2];
69   const uint32_t *wam_pm[2];
70   int am_pm_defined;
71   const char *d_t_fmt;
72   const uint32_t *wd_t_fmt;
73   const char *d_fmt;
74   const uint32_t *wd_fmt;
75   const char *t_fmt;
76   const uint32_t *wt_fmt;
77   const char *t_fmt_ampm;
78   const uint32_t *wt_fmt_ampm;
79   const char **era;
80   const uint32_t **wera;
81   uint32_t num_era;
82   const char *era_year;
83   const uint32_t *wera_year;
84   const char *era_d_t_fmt;
85   const uint32_t *wera_d_t_fmt;
86   const char *era_t_fmt;
87   const uint32_t *wera_t_fmt;
88   const char *era_d_fmt;
89   const uint32_t *wera_d_fmt;
90   const char *alt_digits[100];
91   const uint32_t *walt_digits[100];
92   const char *date_fmt;
93   const uint32_t *wdate_fmt;
94   int alt_digits_defined;
95   unsigned char week_ndays;
96   uint32_t week_1stday;
97   unsigned char week_1stweek;
98   unsigned char first_weekday;
99   unsigned char first_workday;
100   unsigned char cal_direction;
101   const char *timezone;
102   const uint32_t *wtimezone;
103
104   struct era_data *era_entries;
105 };
106
107
108 /* This constant is used to represent an empty wide character string.  */
109 static const uint32_t empty_wstr[1] = { 0 };
110
111
112 static void
113 time_startup (struct linereader *lr, struct localedef_t *locale,
114               int ignore_content)
115 {
116   if (!ignore_content)
117     locale->categories[LC_TIME].time =
118       (struct locale_time_t *) xcalloc (1, sizeof (struct locale_time_t));
119
120   if (lr != NULL)
121     {
122       lr->translate_strings = 1;
123       lr->return_widestr = 1;
124     }
125 }
126
127
128 void
129 time_finish (struct localedef_t *locale, struct charmap_t *charmap)
130 {
131   struct locale_time_t *time = locale->categories[LC_TIME].time;
132   int nothing = 0;
133
134   /* Now resolve copying and also handle completely missing definitions.  */
135   if (time == NULL)
136     {
137       /* First see whether we were supposed to copy.  If yes, find the
138          actual definition.  */
139       if (locale->copy_name[LC_TIME] != NULL)
140         {
141           /* Find the copying locale.  This has to happen transitively since
142              the locale we are copying from might also copying another one.  */
143           struct localedef_t *from = locale;
144
145           do
146             from = find_locale (LC_TIME, from->copy_name[LC_TIME],
147                                 from->repertoire_name, charmap);
148           while (from->categories[LC_TIME].time == NULL
149                  && from->copy_name[LC_TIME] != NULL);
150
151           time = locale->categories[LC_TIME].time
152             = from->categories[LC_TIME].time;
153         }
154
155       /* If there is still no definition issue an warning and create an
156          empty one.  */
157       if (time == NULL)
158         {
159           if (! be_quiet)
160             error (0, 0, _("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       int i;                                                                  \
173                                                                               \
174       if (! be_quiet && ! nothing)                                            \
175         error (0, 0, _("%s: field `%s' not defined"), "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         error (0, 0, _("%s: field `%s' not defined"), "LC_TIME", #cat);       \
196                                                                               \
197       time->cat = initval;                                                    \
198     }
199
200   TEST_ELEM (d_t_fmt, "%a %b %e %H:%M:%S %Y");
201   TEST_ELEM (d_fmt, "%m/%d/%y");
202   TEST_ELEM (t_fmt, "%H:%M:%S");
203
204   /* According to C.Y.Alexis Cheng <alexis@vnet.ibm.com> the T_FMT_AMPM
205      field is optional.  */
206   if (time->t_fmt_ampm == NULL)
207     {
208       if (time->am_pm[0][0] == '\0' && time->am_pm[1][0] == '\0')
209         {
210           /* No AM/PM strings defined, use the 24h format as default.  */
211           time->t_fmt_ampm = time->t_fmt;
212           time->wt_fmt_ampm = time->wt_fmt;
213         }
214       else
215         {
216           time->t_fmt_ampm = "%I:%M:%S %p";
217           time->wt_fmt_ampm = (const uint32_t *) L"%I:%M:%S %p";
218         }
219     }
220
221   /* Now process the era entries.  */
222   if (time->num_era != 0)
223     {
224       const int days_per_month[12] = { 31, 29, 31, 30, 31, 30,
225                                        31, 31, 30, 31 ,30, 31 };
226       size_t idx;
227       wchar_t *wstr;
228
229       time->era_entries =
230         (struct era_data *) xmalloc (time->num_era
231                                      * sizeof (struct era_data));
232
233       for (idx = 0; idx < time->num_era; ++idx)
234         {
235           size_t era_len = strlen (time->era[idx]);
236           char *str = xmalloc ((era_len + 1 + 3) & ~3);
237           char *endp;
238
239           memcpy (str, time->era[idx], era_len + 1);
240
241           /* First character must be + or - for the direction.  */
242           if (*str != '+' && *str != '-')
243             {
244               if (!be_quiet)
245                 error (0, 0,
246                        _("%s: direction flag in string %Zd in `era' field"
247                          " 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                 error (0, 0,
258                        _("%s: direction flag in string %Zd in `era' field"
259                          " 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                 error (0, 0, _("%s: invalid number for offset in string %Zd in"
272                                " `era' field"),
273                        "LC_TIME", idx + 1);
274               (void) strsep (&str, ":");
275             }
276           else if (*endp != ':')
277             {
278               if (!be_quiet)
279                 error (0, 0, _("%s: garbage at end of offset value in"
280                                " 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                     error (0, 0, _("%s: invalid starting date in string %Zd in"
331                                    " `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                     error (0, 0, _("%s: garbage at end of starting date "
340                                    "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                           error (0, 0, _("%s: starting date is invalid in"
359                                          " 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                     error (0, 0, _("%s: invalid stopping date in string %Zd in"
408                                    " `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                     error (0, 0, _("%s: garbage at end of stopping date "
417                                    "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                           error (0, 0, _("%s: stopping date is invalid in"
436                                          " 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                 error (0, 0, _("%s: missing era name in string %Zd in `era'"
445                                " 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                     error (0, 0, _("%s: missing era format in string %Zd"
457                                    " 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           time->era_entries[idx].wname = (uint32_t *) wstr + 1;
472           wstr = wstr ? wcschr (wstr + 1, L':') : NULL; /* end name */
473           *wstr = L'\0';
474           time->era_entries[idx].wformat = (uint32_t *) wstr + 1;
475         }
476     }
477
478   if (time->week_ndays == 0)
479     time->week_ndays = 7;
480
481   if (time->week_1stday == 0)
482     time->week_1stday = 19971130;
483
484   if (time->week_1stweek > time->week_ndays)
485     error (0, 0, _("\
486 %s: third operand for value of field `%s' must not be larger than %d"),
487            "LC_TIME", "week", 7);
488
489   if (time->first_weekday == '\0')
490     /* The definition does not specify this so the default is used.  */
491     time->first_weekday = 1;
492   else if (time->first_weekday > time->week_ndays)
493     error (0, 0, _("\
494 %s: values of field `%s' must not be larger than %d"),
495            "LC_TIME", "first_weekday", 7);
496
497   if (time->first_workday == '\0')
498     /* The definition does not specify this so the default is used.  */
499     time->first_workday = 1;
500   else if (time->first_workday > time->week_ndays)
501     error (0, 0, _("\
502 %s: values of field `%s' must not be larger than %d"),
503            "LC_TIME", "first_workday", 7);
504
505   if (time->cal_direction == '\0')
506     /* The definition does not specify this so the default is used.  */
507     time->cal_direction = 1;
508   else if (time->cal_direction > 3)
509     error (0, 0, _("\
510 %s: values for field `%s' must not be larger than %d"),
511            "LC_TIME", "cal_direction", 3);
512
513   /* XXX We don't perform any tests on the timezone value since this is
514      simply useless, stupid $&$!@...  */
515   if (time->timezone == NULL)
516     time->timezone = "";
517
518   if (time->date_fmt == NULL)
519     time->date_fmt = "%a %b %e %H:%M:%S %Z %Y";
520   if (time->wdate_fmt == NULL)
521     time->wdate_fmt = (const uint32_t *) L"%a %b %e %H:%M:%S %Z %Y";
522 }
523
524
525 void
526 time_output (struct localedef_t *locale, struct charmap_t *charmap,
527              const char *output_path)
528 {
529   struct locale_time_t *time = locale->categories[LC_TIME].time;
530   struct iovec iov[2 + _NL_ITEM_INDEX (_NL_NUM_LC_TIME)
531                   + time->num_era - 1
532                   + 2 * 99
533                   + 2 + time->num_era * 10 - 1];
534   struct locale_file data;
535   uint32_t idx[_NL_ITEM_INDEX (_NL_NUM_LC_TIME)];
536   size_t cnt, last_idx, num, n;
537
538   data.magic = LIMAGIC (LC_TIME);
539   data.n = _NL_ITEM_INDEX (_NL_NUM_LC_TIME);
540   iov[0].iov_base = (void *) &data;
541   iov[0].iov_len = sizeof (data);
542
543   iov[1].iov_base = (void *) idx;
544   iov[1].iov_len = sizeof (idx);
545
546   idx[0] = iov[0].iov_len + iov[1].iov_len;
547
548   /* The ab'days.  */
549   for (cnt = 0; cnt <= _NL_ITEM_INDEX (ABDAY_7); ++cnt)
550     {
551       iov[2 + cnt].iov_base =
552         (void *) (time->abday[cnt - _NL_ITEM_INDEX (ABDAY_1)] ?: "");
553       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
554       idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
555     }
556
557   /* The days.  */
558   for (; cnt <= _NL_ITEM_INDEX (DAY_7); ++cnt)
559     {
560       iov[2 + cnt].iov_base =
561         (void *) (time->day[cnt - _NL_ITEM_INDEX (DAY_1)] ?: "");
562       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
563       idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
564     }
565
566   /* The ab'mons.  */
567   for (; cnt <= _NL_ITEM_INDEX (ABMON_12); ++cnt)
568     {
569       iov[2 + cnt].iov_base =
570         (void *) (time->abmon[cnt - _NL_ITEM_INDEX (ABMON_1)] ?: "");
571       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
572       idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
573     }
574
575   /* The mons.  */
576   for (; cnt <= _NL_ITEM_INDEX (MON_12); ++cnt)
577     {
578       iov[2 + cnt].iov_base =
579         (void *) (time->mon[cnt - _NL_ITEM_INDEX (MON_1)] ?: "");
580       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
581       idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
582     }
583
584   /* AM/PM.  */
585   for (; cnt <= _NL_ITEM_INDEX (PM_STR); ++cnt)
586     {
587       iov[2 + cnt].iov_base =
588         (void *) (time->am_pm[cnt - _NL_ITEM_INDEX (AM_STR)] ?: "");
589       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
590       idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
591     }
592
593   iov[2 + cnt].iov_base = (void *) (time->d_t_fmt ?: "");
594   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
595   idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
596   ++cnt;
597
598   iov[2 + cnt].iov_base = (void *) (time->d_fmt ?: "");
599   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
600   idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
601   ++cnt;
602
603   iov[2 + cnt].iov_base = (void *) (time->t_fmt ?: "");
604   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
605   idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
606   ++cnt;
607
608   iov[2 + cnt].iov_base = (void *) (time->t_fmt_ampm ?: "");
609   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
610   idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len;
611   last_idx = ++cnt;
612
613   idx[1 + last_idx] = idx[last_idx];
614   for (num = 0; num < time->num_era; ++num, ++cnt)
615     {
616       iov[2 + cnt].iov_base = (void *) time->era[num];
617       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
618       idx[1 + last_idx] += iov[2 + cnt].iov_len;
619     }
620   ++last_idx;
621
622   iov[2 + cnt].iov_base = (void *) (time->era_year ?: "");
623   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
624   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
625   ++cnt;
626   ++last_idx;
627
628   iov[2 + cnt].iov_base = (void *) (time->era_d_fmt ?: "");
629   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
630   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
631   ++cnt;
632   ++last_idx;
633
634   idx[1 + last_idx] = idx[last_idx];
635   for (num = 0; num < 100; ++num, ++cnt)
636     {
637       iov[2 + cnt].iov_base = (void *) (time->alt_digits[num] ?: "");
638       iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
639       idx[1 + last_idx] += iov[2 + cnt].iov_len;
640     }
641   ++last_idx;
642
643   iov[2 + cnt].iov_base = (void *) (time->era_d_t_fmt ?: "");
644   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
645   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
646   ++cnt;
647   ++last_idx;
648
649   iov[2 + cnt].iov_base = (void *) (time->era_t_fmt ?: "");
650   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
651   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
652   ++cnt;
653   ++last_idx;
654
655
656   /* We must align the following data.  */
657   iov[2 + cnt].iov_base = (void *) "\0\0";
658   iov[2 + cnt].iov_len = ((idx[last_idx] + 3) & ~3) - idx[last_idx];
659   idx[last_idx] = (idx[last_idx] + 3) & ~3;
660   ++cnt;
661
662   /* The `era' data in usable form.  */
663   iov[2 + cnt].iov_base = (void *) &time->num_era;
664   iov[2 + cnt].iov_len = sizeof (uint32_t);
665   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
666   ++cnt;
667   ++last_idx;
668
669   idx[1 + last_idx] = idx[last_idx];
670   for (num = 0; num < time->num_era; ++num)
671     {
672       size_t l;
673
674       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].direction;
675       iov[2 + cnt].iov_len = sizeof (int32_t);
676       ++cnt;
677       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].offset;
678       iov[2 + cnt].iov_len = sizeof (int32_t);
679       ++cnt;
680       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].start_date[0];
681       iov[2 + cnt].iov_len = sizeof (int32_t);
682       ++cnt;
683       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].start_date[1];
684       iov[2 + cnt].iov_len = sizeof (int32_t);
685       ++cnt;
686       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].start_date[2];
687       iov[2 + cnt].iov_len = sizeof (int32_t);
688       ++cnt;
689       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].stop_date[0];
690       iov[2 + cnt].iov_len = sizeof (int32_t);
691       ++cnt;
692       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].stop_date[1];
693       iov[2 + cnt].iov_len = sizeof (int32_t);
694       ++cnt;
695       iov[2 + cnt].iov_base = (void *) &time->era_entries[num].stop_date[2];
696       iov[2 + cnt].iov_len = sizeof (int32_t);
697       ++cnt;
698
699       l = (strchr (time->era_entries[num].format, '\0')
700            - time->era_entries[num].name) + 1;
701       l = (l + 3) & ~3;
702       iov[2 + cnt].iov_base = (void *) time->era_entries[num].name;
703       iov[2 + cnt].iov_len = l;
704       ++cnt;
705
706       idx[1 + last_idx] += 8 * sizeof (int32_t) + l;
707
708       assert (idx[1 + last_idx] % 4 == 0);
709
710       iov[2 + cnt].iov_base = (void *) time->era_entries[num].wname;
711       iov[2 + cnt].iov_len = ((wcschr ((wchar_t *) time->era_entries[num].wformat, L'\0')
712                                - (wchar_t *) time->era_entries[num].wname + 1)
713                               * sizeof (uint32_t));
714       idx[1 + last_idx] += iov[2 + cnt].iov_len;
715       ++cnt;
716     }
717   ++last_idx;
718
719   /* The wide character ab'days.  */
720   for (n = 0; n < 7; ++n, ++cnt, ++last_idx)
721     {
722       iov[2 + cnt].iov_base =
723         (void *) (time->wabday[n] ?: empty_wstr);
724       iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
725                               * sizeof (uint32_t));
726       idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
727     }
728
729   /* The wide character days.  */
730   for (n = 0; n < 7; ++n, ++cnt, ++last_idx)
731     {
732       iov[2 + cnt].iov_base =
733         (void *) (time->wday[n] ?: empty_wstr);
734       iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
735                               * sizeof (uint32_t));
736       idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
737     }
738
739   /* The wide character ab'mons.  */
740   for (n = 0; n < 12; ++n, ++cnt, ++last_idx)
741     {
742       iov[2 + cnt].iov_base =
743         (void *) (time->wabmon[n] ?: empty_wstr);
744       iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
745                               * sizeof (uint32_t));
746       idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
747     }
748
749   /* The wide character mons.  */
750   for (n = 0; n < 12; ++n, ++cnt, ++last_idx)
751     {
752       iov[2 + cnt].iov_base =
753         (void *) (time->wmon[n] ?: empty_wstr);
754       iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
755                               * sizeof (uint32_t));
756       idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
757     }
758
759   /* Wide character AM/PM.  */
760   for (n = 0; n < 2; ++n, ++cnt, ++last_idx)
761     {
762       iov[2 + cnt].iov_base =
763         (void *) (time->wam_pm[n] ?: empty_wstr);
764       iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
765                               * sizeof (uint32_t));
766       idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
767     }
768
769   iov[2 + cnt].iov_base = (void *) (time->wd_t_fmt ?: empty_wstr);
770   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
771                           * sizeof (uint32_t));
772   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
773   ++cnt;
774   ++last_idx;
775
776   iov[2 + cnt].iov_base = (void *) (time->wd_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->wt_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_ampm ?: 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->wera_year ?: 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_d_fmt ?: 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   idx[1 + last_idx] = idx[last_idx];
812   for (num = 0; num < 100; ++num, ++cnt)
813     {
814       iov[2 + cnt].iov_base = (void *) (time->walt_digits[num]
815                                         ?: empty_wstr);
816       iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
817                               * sizeof (uint32_t));
818       idx[1 + last_idx] += iov[2 + cnt].iov_len;
819     }
820   ++last_idx;
821
822   iov[2 + cnt].iov_base = (void *) (time->wera_d_t_fmt ?: empty_wstr);
823   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
824                           * sizeof (uint32_t));
825   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
826   ++cnt;
827   ++last_idx;
828
829   iov[2 + cnt].iov_base = (void *) (time->wera_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->week_ndays;
837   iov[2 + cnt].iov_len = 1;
838   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
839   ++cnt;
840   ++last_idx;
841
842   /* We must align the following data.  */
843   iov[2 + cnt].iov_base = (void *) "\0\0";
844   iov[2 + cnt].iov_len = ((idx[last_idx] + 3) & ~3) - idx[last_idx];
845   idx[last_idx] = (idx[last_idx] + 3) & ~3;
846   ++cnt;
847
848   iov[2 + cnt].iov_base = (void *) &time->week_1stday;
849   iov[2 + cnt].iov_len = sizeof(uint32_t);
850   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
851   ++cnt;
852   ++last_idx;
853
854   iov[2 + cnt].iov_base = (void *) &time->week_1stweek;
855   iov[2 + cnt].iov_len = 1;
856   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
857   ++cnt;
858   ++last_idx;
859
860   iov[2 + cnt].iov_base = (void *) &time->first_weekday;
861   iov[2 + cnt].iov_len = 1;
862   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
863   ++cnt;
864   ++last_idx;
865
866   iov[2 + cnt].iov_base = (void *) &time->first_workday;
867   iov[2 + cnt].iov_len = 1;
868   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
869   ++cnt;
870   ++last_idx;
871
872   iov[2 + cnt].iov_base = (void *) &time->cal_direction;
873   iov[2 + cnt].iov_len = 1;
874   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
875   ++cnt;
876   ++last_idx;
877
878   iov[2 + cnt].iov_base = (void *) time->timezone;
879   iov[2 + cnt].iov_len = strlen (time->timezone) + 1;
880   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
881   ++cnt;
882   ++last_idx;
883
884   iov[2 + cnt].iov_base = (void *) time->date_fmt;
885   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
886   idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len;
887   ++cnt;
888   ++last_idx;
889
890   iov[2 + cnt].iov_base = (void *) time->wdate_fmt;
891   iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1)
892                           * sizeof (uint32_t));
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 *) charmap->code_set_name;
898   iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1;
899   ++cnt;
900   ++last_idx;
901
902   assert (cnt == (_NL_ITEM_INDEX (_NL_NUM_LC_TIME)
903                   + time->num_era - 1
904                   + 2 * 99
905                   + 2 + time->num_era * 10 - 1));
906   assert (last_idx  == _NL_ITEM_INDEX (_NL_NUM_LC_TIME));
907
908   write_locale_data (output_path, "LC_TIME", 2 + cnt, iov);
909 }
910
911
912 /* The parser for the LC_TIME section of the locale definition.  */
913 void
914 time_read (struct linereader *ldfile, struct localedef_t *result,
915            struct charmap_t *charmap, const char *repertoire_name,
916            int ignore_content)
917 {
918   struct repertoire_t *repertoire = NULL;
919   struct locale_time_t *time;
920   struct token *now;
921   enum token_t nowtok;
922   size_t cnt;
923
924   /* Get the repertoire we have to use.  */
925   if (repertoire_name != NULL)
926     repertoire = repertoire_read (repertoire_name);
927
928   /* The rest of the line containing `LC_TIME' must be free.  */
929   lr_ignore_rest (ldfile, 1);
930
931
932   do
933     {
934       now = lr_token (ldfile, charmap, repertoire, verbose);
935       nowtok = now->tok;
936     }
937   while (nowtok == tok_eol);
938
939   /* If we see `copy' now we are almost done.  */
940   if (nowtok == tok_copy)
941     {
942       handle_copy (ldfile, charmap, repertoire_name, result, tok_lc_time,
943                    LC_TIME, "LC_TIME", ignore_content);
944       return;
945     }
946
947   /* Prepare the data structures.  */
948   time_startup (ldfile, result, ignore_content);
949   time = result->categories[LC_TIME].time;
950
951   while (1)
952     {
953       /* Of course we don't proceed beyond the end of file.  */
954       if (nowtok == tok_eof)
955         break;
956
957       /* Ingore empty lines.  */
958       if (nowtok == tok_eol)
959         {
960           now = lr_token (ldfile, charmap, repertoire, verbose);
961           nowtok = now->tok;
962           continue;
963         }
964
965       switch (nowtok)
966         {
967 #define STRARR_ELEM(cat, min, max) \
968         case tok_##cat:                                                       \
969           /* Ignore the rest of the line if we don't need the input of        \
970              this line.  */                                                   \
971           if (ignore_content)                                                 \
972             {                                                                 \
973               lr_ignore_rest (ldfile, 0);                                     \
974               break;                                                          \
975             }                                                                 \
976                                                                               \
977           for (cnt = 0; cnt < max; ++cnt)                                     \
978             {                                                                 \
979               now = lr_token (ldfile, charmap, repertoire, verbose);          \
980               if (now->tok == tok_eol)                                        \
981                 {                                                             \
982                   if (cnt < min)                                              \
983                     lr_error (ldfile, _("%s: too few values for field `%s'"), \
984                               "LC_TIME", #cat);                               \
985                   if (!ignore_content)                                        \
986                     do                                                        \
987                       {                                                       \
988                         time->cat[cnt] = "";                                  \
989                         time->w##cat[cnt] = empty_wstr;                       \
990                       }                                                       \
991                     while (++cnt < max);                                      \
992                   break;                                                      \
993                 }                                                             \
994               else if (now->tok != tok_string)                                \
995                 goto err_label;                                               \
996               else if (!ignore_content && (now->val.str.startmb == NULL       \
997                                            || now->val.str.startwc == NULL))  \
998                 {                                                             \
999                   lr_error (ldfile, _("%s: unknown character in field `%s'"), \
1000                             "LC_TIME", #cat);                                 \
1001                   time->cat[cnt] = "";                                        \
1002                   time->w##cat[cnt] = empty_wstr;                             \
1003                 }                                                             \
1004               else if (!ignore_content)                                       \
1005                 {                                                             \
1006                   time->cat[cnt] = now->val.str.startmb;                      \
1007                   time->w##cat[cnt] = now->val.str.startwc;                   \
1008                 }                                                             \
1009                                                                               \
1010               /* Match the semicolon.  */                                     \
1011               now = lr_token (ldfile, charmap, repertoire, verbose);          \
1012               if (now->tok != tok_semicolon && now->tok != tok_eol)           \
1013                 break;                                                        \
1014             }                                                                 \
1015           if (now->tok != tok_eol)                                            \
1016             {                                                                 \
1017               while (!ignore_content && cnt < min)                            \
1018                 {                                                             \
1019                   time->cat[cnt] = "";                                        \
1020                   time->w##cat[cnt++] = empty_wstr;                           \
1021                 }                                                             \
1022                                                                               \
1023               if (now->tok == tok_semicolon)                                  \
1024                 {                                                             \
1025                   now = lr_token (ldfile, charmap, repertoire, verbose);      \
1026                   if (now->tok == tok_eol)                                    \
1027                     lr_error (ldfile, _("extra trailing semicolon"));         \
1028                   else if (now->tok == tok_string)                            \
1029                     {                                                         \
1030                       lr_error (ldfile, _("\
1031 %s: too many values for field `%s'"),                                         \
1032                                 "LC_TIME", #cat);                             \
1033                       lr_ignore_rest (ldfile, 0);                             \
1034                     }                                                         \
1035                   else                                                        \
1036                     goto err_label;                                           \
1037                 }                                                             \
1038               else                                                            \
1039                 goto err_label;                                               \
1040             }                                                                 \
1041           time->cat##_defined = 1;                                            \
1042           break
1043
1044           STRARR_ELEM (abday, 7, 7);
1045           STRARR_ELEM (day, 7, 7);
1046           STRARR_ELEM (abmon, 12, 12);
1047           STRARR_ELEM (mon, 12, 12);
1048           STRARR_ELEM (am_pm, 2, 2);
1049           STRARR_ELEM (alt_digits, 0, 100);
1050
1051         case tok_era:
1052           /* Ignore the rest of the line if we don't need the input of
1053              this line.  */
1054           if (ignore_content)
1055             {
1056               lr_ignore_rest (ldfile, 0);
1057               break;
1058             }
1059           do
1060             {
1061               now = lr_token (ldfile, charmap, repertoire, verbose);
1062               if (now->tok != tok_string)
1063                 goto err_label;
1064               if (!ignore_content && (now->val.str.startmb == NULL
1065                                       || now->val.str.startwc == NULL))
1066                 {
1067                   lr_error (ldfile, _("%s: unknown character in field `%s'"),
1068                             "LC_TIME", "era");
1069                   lr_ignore_rest (ldfile, 0);
1070                   break;
1071                 }
1072               if (!ignore_content)
1073                 {
1074                   time->era = xrealloc (time->era,
1075                                         (time->num_era + 1) * sizeof (char *));
1076                   time->era[time->num_era] = now->val.str.startmb;
1077
1078                   time->wera = xrealloc (time->wera,
1079                                          (time->num_era + 1)
1080                                          * sizeof (char *));
1081                   time->wera[time->num_era++] = now->val.str.startwc;
1082                 }
1083               now = lr_token (ldfile, charmap, repertoire, verbose);
1084               if (now->tok != tok_eol && now->tok != tok_semicolon)
1085                 goto err_label;
1086             }
1087           while (now->tok == tok_semicolon);
1088           break;
1089
1090 #define STR_ELEM(cat) \
1091         case tok_##cat:                                                       \
1092           /* Ignore the rest of the line if we don't need the input of        \
1093              this line.  */                                                   \
1094           if (ignore_content)                                                 \
1095             {                                                                 \
1096               lr_ignore_rest (ldfile, 0);                                     \
1097               break;                                                          \
1098             }                                                                 \
1099                                                                               \
1100           now = lr_token (ldfile, charmap, repertoire, verbose);              \
1101           if (now->tok != tok_string)                                         \
1102             goto err_label;                                                   \
1103           else if (time->cat != NULL)                                         \
1104             lr_error (ldfile, _("\
1105 %s: field `%s' declared more than once"), "LC_TIME", #cat);                   \
1106           else if (!ignore_content && (now->val.str.startmb == NULL           \
1107                                        || now->val.str.startwc == NULL))      \
1108             {                                                                 \
1109               lr_error (ldfile, _("%s: unknown character in field `%s'"),     \
1110                         "LC_TIME", #cat);                                     \
1111               time->cat = "";                                                 \
1112               time->w##cat = empty_wstr;                                      \
1113             }                                                                 \
1114           else if (!ignore_content)                                           \
1115             {                                                                 \
1116               time->cat = now->val.str.startmb;                               \
1117               time->w##cat = now->val.str.startwc;                            \
1118             }                                                                 \
1119           break
1120
1121           STR_ELEM (d_t_fmt);
1122           STR_ELEM (d_fmt);
1123           STR_ELEM (t_fmt);
1124           STR_ELEM (t_fmt_ampm);
1125           STR_ELEM (era_year);
1126           STR_ELEM (era_d_t_fmt);
1127           STR_ELEM (era_d_fmt);
1128           STR_ELEM (era_t_fmt);
1129           STR_ELEM (timezone);
1130           STR_ELEM (date_fmt);
1131
1132 #define INT_ELEM(cat) \
1133         case tok_##cat:                                                       \
1134           /* Ignore the rest of the line if we don't need the input of        \
1135              this line.  */                                                   \
1136           if (ignore_content)                                                 \
1137             {                                                                 \
1138               lr_ignore_rest (ldfile, 0);                                     \
1139               break;                                                          \
1140             }                                                                 \
1141                                                                               \
1142           now = lr_token (ldfile, charmap, repertoire, verbose);              \
1143           if (now->tok != tok_number)                                         \
1144             goto err_label;                                                   \
1145           else if (time->cat != 0)                                            \
1146             lr_error (ldfile, _("%s: field `%s' declared more than once"),    \
1147                       "LC_TIME", #cat);                                       \
1148           else if (!ignore_content)                                           \
1149             time->cat = now->val.num;                                         \
1150           break
1151
1152           INT_ELEM (first_weekday);
1153           INT_ELEM (first_workday);
1154           INT_ELEM (cal_direction);
1155
1156         case tok_week:
1157           /* Ignore the rest of the line if we don't need the input of
1158              this line.  */
1159           if (ignore_content)
1160             {
1161               lr_ignore_rest (ldfile, 0);
1162               break;
1163             }
1164
1165           now = lr_token (ldfile, charmap, repertoire, verbose);
1166           if (now->tok != tok_number)
1167             goto err_label;
1168           time->week_ndays = now->val.num;
1169
1170           now = lr_token (ldfile, charmap, repertoire, verbose);
1171           if (now->tok != tok_semicolon)
1172             goto err_label;
1173
1174           now = lr_token (ldfile, charmap, repertoire, verbose);
1175           if (now->tok != tok_number)
1176             goto err_label;
1177           time->week_1stday = now->val.num;
1178
1179           now = lr_token (ldfile, charmap, repertoire, verbose);
1180           if (now->tok != tok_semicolon)
1181             goto err_label;
1182
1183           now = lr_token (ldfile, charmap, repertoire, verbose);
1184           if (now->tok != tok_number)
1185             goto err_label;
1186           time->week_1stweek = now->val.num;
1187
1188           lr_ignore_rest (ldfile,  1);
1189           break;
1190
1191         case tok_end:
1192           /* Next we assume `LC_TIME'.  */
1193           now = lr_token (ldfile, charmap, repertoire, verbose);
1194           if (now->tok == tok_eof)
1195             break;
1196           if (now->tok == tok_eol)
1197             lr_error (ldfile, _("%s: incomplete `END' line"), "LC_TIME");
1198           else if (now->tok != tok_lc_time)
1199             lr_error (ldfile, _("\
1200 %1$s: definition does not end with `END %1$s'"), "LC_TIME");
1201           lr_ignore_rest (ldfile, now->tok == tok_lc_time);
1202           return;
1203
1204         default:
1205         err_label:
1206           SYNTAX_ERROR (_("%s: syntax error"), "LC_TIME");
1207         }
1208
1209       /* Prepare for the next round.  */
1210       now = lr_token (ldfile, charmap, repertoire, verbose);
1211       nowtok = now->tok;
1212     }
1213
1214   /* When we come here we reached the end of the file.  */
1215   lr_error (ldfile, _("%s: premature end of file"), "LC_TIME");
1216 }