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