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