Permalink
Cannot retrieve contributors at this time
Name already in use
A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
glibc/locale/programs/ld-time.c
Go to fileThis commit does not belong to any branch on this repository, and may belong to a fork outside of the repository.
1238 lines (1099 sloc)
37.5 KB
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| /* Copyright (C) 1995-2013 Free Software Foundation, Inc. | |
| This file is part of the GNU C Library. | |
| Contributed by Ulrich Drepper <drepper@gnu.org>, 1995. | |
| This program is free software; you can redistribute it and/or modify | |
| it under the terms of the GNU General Public License as published | |
| by the Free Software Foundation; version 2 of the License, or | |
| (at your option) any later version. | |
| This program is distributed in the hope that it will be useful, | |
| but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| GNU General Public License for more details. | |
| You should have received a copy of the GNU General Public License | |
| along with this program; if not, see <http://www.gnu.org/licenses/>. */ | |
| #ifdef HAVE_CONFIG_H | |
| # include <config.h> | |
| #endif | |
| #include <byteswap.h> | |
| #include <langinfo.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <wchar.h> | |
| #include <stdint.h> | |
| #include <sys/uio.h> | |
| #include <assert.h> | |
| #include "localedef.h" | |
| #include "linereader.h" | |
| #include "localeinfo.h" | |
| #include "locfile.h" | |
| /* Entry describing an entry of the era specification. */ | |
| struct era_data | |
| { | |
| int32_t direction; | |
| int32_t offset; | |
| int32_t start_date[3]; | |
| int32_t stop_date[3]; | |
| const char *name; | |
| const char *format; | |
| uint32_t *wname; | |
| uint32_t *wformat; | |
| }; | |
| /* The real definition of the struct for the LC_TIME locale. */ | |
| struct locale_time_t | |
| { | |
| const char *abday[7]; | |
| const uint32_t *wabday[7]; | |
| int abday_defined; | |
| const char *day[7]; | |
| const uint32_t *wday[7]; | |
| int day_defined; | |
| const char *abmon[12]; | |
| const uint32_t *wabmon[12]; | |
| int abmon_defined; | |
| const char *mon[12]; | |
| const uint32_t *wmon[12]; | |
| int mon_defined; | |
| const char *am_pm[2]; | |
| const uint32_t *wam_pm[2]; | |
| int am_pm_defined; | |
| const char *d_t_fmt; | |
| const uint32_t *wd_t_fmt; | |
| const char *d_fmt; | |
| const uint32_t *wd_fmt; | |
| const char *t_fmt; | |
| const uint32_t *wt_fmt; | |
| const char *t_fmt_ampm; | |
| const uint32_t *wt_fmt_ampm; | |
| const char **era; | |
| const uint32_t **wera; | |
| uint32_t num_era; | |
| const char *era_year; | |
| const uint32_t *wera_year; | |
| const char *era_d_t_fmt; | |
| const uint32_t *wera_d_t_fmt; | |
| const char *era_t_fmt; | |
| const uint32_t *wera_t_fmt; | |
| const char *era_d_fmt; | |
| const uint32_t *wera_d_fmt; | |
| const char *alt_digits[100]; | |
| const uint32_t *walt_digits[100]; | |
| const char *date_fmt; | |
| const uint32_t *wdate_fmt; | |
| int alt_digits_defined; | |
| unsigned char week_ndays; | |
| uint32_t week_1stday; | |
| unsigned char week_1stweek; | |
| unsigned char first_weekday; | |
| unsigned char first_workday; | |
| unsigned char cal_direction; | |
| const char *timezone; | |
| const uint32_t *wtimezone; | |
| struct era_data *era_entries; | |
| }; | |
| /* This constant is used to represent an empty wide character string. */ | |
| static const uint32_t empty_wstr[1] = { 0 }; | |
| static void | |
| time_startup (struct linereader *lr, struct localedef_t *locale, | |
| int ignore_content) | |
| { | |
| if (!ignore_content) | |
| locale->categories[LC_TIME].time = | |
| (struct locale_time_t *) xcalloc (1, sizeof (struct locale_time_t)); | |
| if (lr != NULL) | |
| { | |
| lr->translate_strings = 1; | |
| lr->return_widestr = 1; | |
| } | |
| } | |
| void | |
| time_finish (struct localedef_t *locale, const struct charmap_t *charmap) | |
| { | |
| struct locale_time_t *time = locale->categories[LC_TIME].time; | |
| int nothing = 0; | |
| /* Now resolve copying and also handle completely missing definitions. */ | |
| if (time == NULL) | |
| { | |
| /* First see whether we were supposed to copy. If yes, find the | |
| actual definition. */ | |
| if (locale->copy_name[LC_TIME] != NULL) | |
| { | |
| /* Find the copying locale. This has to happen transitively since | |
| the locale we are copying from might also copying another one. */ | |
| struct localedef_t *from = locale; | |
| do | |
| from = find_locale (LC_TIME, from->copy_name[LC_TIME], | |
| from->repertoire_name, charmap); | |
| while (from->categories[LC_TIME].time == NULL | |
| && from->copy_name[LC_TIME] != NULL); | |
| time = locale->categories[LC_TIME].time | |
| = from->categories[LC_TIME].time; | |
| } | |
| /* If there is still no definition issue an warning and create an | |
| empty one. */ | |
| if (time == NULL) | |
| { | |
| if (! be_quiet) | |
| WITH_CUR_LOCALE (error (0, 0, _("\ | |
| No definition for %s category found"), "LC_TIME")); | |
| time_startup (NULL, locale, 0); | |
| time = locale->categories[LC_TIME].time; | |
| nothing = 1; | |
| } | |
| } | |
| #define noparen(arg1, argn...) arg1, ##argn | |
| #define TESTARR_ELEM(cat, val) \ | |
| if (!time->cat##_defined) \ | |
| { \ | |
| const char *initval[] = { noparen val }; \ | |
| unsigned int i; \ | |
| \ | |
| if (! be_quiet && ! nothing) \ | |
| WITH_CUR_LOCALE (error (0, 0, _("%s: field `%s' not defined"), \ | |
| "LC_TIME", #cat)); \ | |
| \ | |
| for (i = 0; i < sizeof (initval) / sizeof (initval[0]); ++i) \ | |
| time->cat[i] = initval[i]; \ | |
| } | |
| TESTARR_ELEM (abday, ( "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" )); | |
| TESTARR_ELEM (day, ( "Sunday", "Monday", "Tuesday", "Wednesday", | |
| "Thursday", "Friday", "Saturday" )); | |
| TESTARR_ELEM (abmon, ( "Jan", "Feb", "Mar", "Apr", "May", "Jun", | |
| "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" )); | |
| TESTARR_ELEM (mon, ( "January", "February", "March", "April", | |
| "May", "June", "July", "August", | |
| "September", "October", "November", "December" )); | |
| TESTARR_ELEM (am_pm, ( "AM", "PM" )); | |
| #define TEST_ELEM(cat, initval) \ | |
| if (time->cat == NULL) \ | |
| { \ | |
| if (! be_quiet && ! nothing) \ | |
| WITH_CUR_LOCALE (error (0, 0, _("%s: field `%s' not defined"), \ | |
| "LC_TIME", #cat)); \ | |
| \ | |
| time->cat = initval; \ | |
| } | |
| TEST_ELEM (d_t_fmt, "%a %b %e %H:%M:%S %Y"); | |
| TEST_ELEM (d_fmt, "%m/%d/%y"); | |
| TEST_ELEM (t_fmt, "%H:%M:%S"); | |
| /* According to C.Y.Alexis Cheng <alexis@vnet.ibm.com> the T_FMT_AMPM | |
| field is optional. */ | |
| if (time->t_fmt_ampm == NULL) | |
| { | |
| if (time->am_pm[0][0] == '\0' && time->am_pm[1][0] == '\0') | |
| { | |
| /* No AM/PM strings defined, use the 24h format as default. */ | |
| time->t_fmt_ampm = time->t_fmt; | |
| time->wt_fmt_ampm = time->wt_fmt; | |
| } | |
| else | |
| { | |
| time->t_fmt_ampm = "%I:%M:%S %p"; | |
| time->wt_fmt_ampm = (const uint32_t *) L"%I:%M:%S %p"; | |
| } | |
| } | |
| /* Now process the era entries. */ | |
| if (time->num_era != 0) | |
| { | |
| const int days_per_month[12] = { 31, 29, 31, 30, 31, 30, | |
| 31, 31, 30, 31 ,30, 31 }; | |
| size_t idx; | |
| wchar_t *wstr; | |
| time->era_entries = | |
| (struct era_data *) xmalloc (time->num_era | |
| * sizeof (struct era_data)); | |
| for (idx = 0; idx < time->num_era; ++idx) | |
| { | |
| size_t era_len = strlen (time->era[idx]); | |
| char *str = xmalloc ((era_len + 1 + 3) & ~3); | |
| char *endp; | |
| memcpy (str, time->era[idx], era_len + 1); | |
| /* First character must be + or - for the direction. */ | |
| if (*str != '+' && *str != '-') | |
| { | |
| if (!be_quiet) | |
| WITH_CUR_LOCALE (error (0, 0, _("\ | |
| %s: direction flag in string %Zd in `era' field is not '+' nor '-'"), | |
| "LC_TIME", idx + 1)); | |
| /* Default arbitrarily to '+'. */ | |
| time->era_entries[idx].direction = '+'; | |
| } | |
| else | |
| time->era_entries[idx].direction = *str; | |
| if (*++str != ':') | |
| { | |
| if (!be_quiet) | |
| WITH_CUR_LOCALE (error (0, 0, _("\ | |
| %s: direction flag in string %Zd in `era' field is not a single character"), | |
| "LC_TIME", idx + 1)); | |
| (void) strsep (&str, ":"); | |
| } | |
| else | |
| ++str; | |
| /* Now the offset year. */ | |
| time->era_entries[idx].offset = strtol (str, &endp, 10); | |
| if (endp == str) | |
| { | |
| if (!be_quiet) | |
| WITH_CUR_LOCALE (error (0, 0, _("\ | |
| %s: invalid number for offset in string %Zd in `era' field"), | |
| "LC_TIME", idx + 1)); | |
| (void) strsep (&str, ":"); | |
| } | |
| else if (*endp != ':') | |
| { | |
| if (!be_quiet) | |
| WITH_CUR_LOCALE (error (0, 0, _("\ | |
| %s: garbage at end of offset value in string %Zd in `era' field"), | |
| "LC_TIME", idx + 1)); | |
| (void) strsep (&str, ":"); | |
| } | |
| else | |
| str = endp + 1; | |
| /* Next is the starting date in ISO format. */ | |
| if (strncmp (str, "-*", 2) == 0) | |
| { | |
| time->era_entries[idx].start_date[0] = | |
| time->era_entries[idx].start_date[1] = | |
| time->era_entries[idx].start_date[2] = 0x80000000; | |
| if (str[2] != ':') | |
| goto garbage_start_date; | |
| str += 3; | |
| } | |
| else if (strncmp (str, "+*", 2) == 0) | |
| { | |
| time->era_entries[idx].start_date[0] = | |
| time->era_entries[idx].start_date[1] = | |
| time->era_entries[idx].start_date[2] = 0x7fffffff; | |
| if (str[2] != ':') | |
| goto garbage_start_date; | |
| str += 3; | |
| } | |
| else | |
| { | |
| time->era_entries[idx].start_date[0] = strtol (str, &endp, 10); | |
| if (endp == str || *endp != '/') | |
| goto invalid_start_date; | |
| else | |
| str = endp + 1; | |
| time->era_entries[idx].start_date[0] -= 1900; | |
| /* year -1 represent 1 B.C. (not -1 A.D.) */ | |
| if (time->era_entries[idx].start_date[0] < -1900) | |
| ++time->era_entries[idx].start_date[0]; | |
| time->era_entries[idx].start_date[1] = strtol (str, &endp, 10); | |
| if (endp == str || *endp != '/') | |
| goto invalid_start_date; | |
| else | |
| str = endp + 1; | |
| time->era_entries[idx].start_date[1] -= 1; | |
| time->era_entries[idx].start_date[2] = strtol (str, &endp, 10); | |
| if (endp == str) | |
| { | |
| invalid_start_date: | |
| if (!be_quiet) | |
| WITH_CUR_LOCALE (error (0, 0, _("\ | |
| %s: invalid starting date in string %Zd in `era' field"), | |
| "LC_TIME", idx + 1)); | |
| (void) strsep (&str, ":"); | |
| } | |
| else if (*endp != ':') | |
| { | |
| garbage_start_date: | |
| if (!be_quiet) | |
| WITH_CUR_LOCALE (error (0, 0, _("\ | |
| %s: garbage at end of starting date in string %Zd in `era' field "), | |
| "LC_TIME", idx + 1)); | |
| (void) strsep (&str, ":"); | |
| } | |
| else | |
| { | |
| str = endp + 1; | |
| /* Check for valid value. */ | |
| if ((time->era_entries[idx].start_date[1] < 0 | |
| || time->era_entries[idx].start_date[1] >= 12 | |
| || time->era_entries[idx].start_date[2] < 0 | |
| || (time->era_entries[idx].start_date[2] | |
| > days_per_month[time->era_entries[idx].start_date[1]]) | |
| || (time->era_entries[idx].start_date[1] == 2 | |
| && time->era_entries[idx].start_date[2] == 29 | |
| && !__isleap (time->era_entries[idx].start_date[0]))) | |
| && !be_quiet) | |
| WITH_CUR_LOCALE (error (0, 0, _("\ | |
| %s: starting date is invalid in string %Zd in `era' field"), | |
| "LC_TIME", idx + 1)); | |
| } | |
| } | |
| /* Next is the stopping date in ISO format. */ | |
| if (strncmp (str, "-*", 2) == 0) | |
| { | |
| time->era_entries[idx].stop_date[0] = | |
| time->era_entries[idx].stop_date[1] = | |
| time->era_entries[idx].stop_date[2] = 0x80000000; | |
| if (str[2] != ':') | |
| goto garbage_stop_date; | |
| str += 3; | |
| } | |
| else if (strncmp (str, "+*", 2) == 0) | |
| { | |
| time->era_entries[idx].stop_date[0] = | |
| time->era_entries[idx].stop_date[1] = | |
| time->era_entries[idx].stop_date[2] = 0x7fffffff; | |
| if (str[2] != ':') | |
| goto garbage_stop_date; | |
| str += 3; | |
| } | |
| else | |
| { | |
| time->era_entries[idx].stop_date[0] = strtol (str, &endp, 10); | |
| if (endp == str || *endp != '/') | |
| goto invalid_stop_date; | |
| else | |
| str = endp + 1; | |
| time->era_entries[idx].stop_date[0] -= 1900; | |
| /* year -1 represent 1 B.C. (not -1 A.D.) */ | |
| if (time->era_entries[idx].stop_date[0] < -1900) | |
| ++time->era_entries[idx].stop_date[0]; | |
| time->era_entries[idx].stop_date[1] = strtol (str, &endp, 10); | |
| if (endp == str || *endp != '/') | |
| goto invalid_stop_date; | |
| else | |
| str = endp + 1; | |
| time->era_entries[idx].stop_date[1] -= 1; | |
| time->era_entries[idx].stop_date[2] = strtol (str, &endp, 10); | |
| if (endp == str) | |
| { | |
| invalid_stop_date: | |
| if (!be_quiet) | |
| WITH_CUR_LOCALE (error (0, 0, _("\ | |
| %s: invalid stopping date in string %Zd in `era' field"), | |
| "LC_TIME", idx + 1)); | |
| (void) strsep (&str, ":"); | |
| } | |
| else if (*endp != ':') | |
| { | |
| garbage_stop_date: | |
| if (!be_quiet) | |
| WITH_CUR_LOCALE (error (0, 0, _("\ | |
| %s: garbage at end of stopping date in string %Zd in `era' field"), | |
| "LC_TIME", idx + 1)); | |
| (void) strsep (&str, ":"); | |
| } | |
| else | |
| { | |
| str = endp + 1; | |
| /* Check for valid value. */ | |
| if ((time->era_entries[idx].stop_date[1] < 0 | |
| || time->era_entries[idx].stop_date[1] >= 12 | |
| || time->era_entries[idx].stop_date[2] < 0 | |
| || (time->era_entries[idx].stop_date[2] | |
| > days_per_month[time->era_entries[idx].stop_date[1]]) | |
| || (time->era_entries[idx].stop_date[1] == 2 | |
| && time->era_entries[idx].stop_date[2] == 29 | |
| && !__isleap (time->era_entries[idx].stop_date[0]))) | |
| && !be_quiet) | |
| WITH_CUR_LOCALE (error (0, 0, _("\ | |
| %s: invalid stopping date in string %Zd in `era' field"), | |
| "LC_TIME", idx + 1)); | |
| } | |
| } | |
| if (str == NULL || *str == '\0') | |
| { | |
| if (!be_quiet) | |
| WITH_CUR_LOCALE (error (0, 0, _("\ | |
| %s: missing era name in string %Zd in `era' field"), "LC_TIME", idx + 1)); | |
| time->era_entries[idx].name = | |
| time->era_entries[idx].format = ""; | |
| } | |
| else | |
| { | |
| time->era_entries[idx].name = strsep (&str, ":"); | |
| if (str == NULL || *str == '\0') | |
| { | |
| if (!be_quiet) | |
| WITH_CUR_LOCALE (error (0, 0, _("\ | |
| %s: missing era format in string %Zd in `era' field"), | |
| "LC_TIME", idx + 1)); | |
| time->era_entries[idx].name = | |
| time->era_entries[idx].format = ""; | |
| } | |
| else | |
| time->era_entries[idx].format = str; | |
| } | |
| /* Now generate the wide character name and format. */ | |
| wstr = wcschr ((wchar_t *) time->wera[idx], L':');/* end direction */ | |
| wstr = wstr ? wcschr (wstr + 1, L':') : NULL; /* end offset */ | |
| wstr = wstr ? wcschr (wstr + 1, L':') : NULL; /* end start */ | |
| wstr = wstr ? wcschr (wstr + 1, L':') : NULL; /* end end */ | |
| if (wstr != NULL) | |
| { | |
| time->era_entries[idx].wname = (uint32_t *) wstr + 1; | |
| wstr = wcschr (wstr + 1, L':'); /* end name */ | |
| if (wstr != NULL) | |
| { | |
| *wstr = L'\0'; | |
| time->era_entries[idx].wformat = (uint32_t *) wstr + 1; | |
| } | |
| else | |
| time->era_entries[idx].wname = | |
| time->era_entries[idx].wformat = (uint32_t *) L""; | |
| } | |
| else | |
| time->era_entries[idx].wname = | |
| time->era_entries[idx].wformat = (uint32_t *) L""; | |
| } | |
| } | |
| if (time->week_ndays == 0) | |
| time->week_ndays = 7; | |
| if (time->week_1stday == 0) | |
| time->week_1stday = 19971130; | |
| if (time->week_1stweek > time->week_ndays) | |
| WITH_CUR_LOCALE (error (0, 0, _("\ | |
| %s: third operand for value of field `%s' must not be larger than %d"), | |
| "LC_TIME", "week", 7)); | |
| if (time->first_weekday == '\0') | |
| /* The definition does not specify this so the default is used. */ | |
| time->first_weekday = 1; | |
| else if (time->first_weekday > time->week_ndays) | |
| WITH_CUR_LOCALE (error (0, 0, _("\ | |
| %s: values for field `%s' must not be larger than %d"), | |
| "LC_TIME", "first_weekday", 7)); | |
| if (time->first_workday == '\0') | |
| /* The definition does not specify this so the default is used. */ | |
| time->first_workday = 2; | |
| else if (time->first_workday > time->week_ndays) | |
| WITH_CUR_LOCALE (error (0, 0, _("\ | |
| %s: values for field `%s' must not be larger than %d"), | |
| "LC_TIME", "first_workday", 7)); | |
| if (time->cal_direction == '\0') | |
| /* The definition does not specify this so the default is used. */ | |
| time->cal_direction = 1; | |
| else if (time->cal_direction > 3) | |
| WITH_CUR_LOCALE (error (0, 0, _("\ | |
| %s: values for field `%s' must not be larger than %d"), | |
| "LC_TIME", "cal_direction", 3)); | |
| /* XXX We don't perform any tests on the timezone value since this is | |
| simply useless, stupid $&$!@... */ | |
| if (time->timezone == NULL) | |
| time->timezone = ""; | |
| if (time->date_fmt == NULL) | |
| time->date_fmt = "%a %b %e %H:%M:%S %Z %Y"; | |
| if (time->wdate_fmt == NULL) | |
| time->wdate_fmt = (const uint32_t *) L"%a %b %e %H:%M:%S %Z %Y"; | |
| } | |
| void | |
| time_output (struct localedef_t *locale, const struct charmap_t *charmap, | |
| const char *output_path) | |
| { | |
| struct locale_time_t *time = locale->categories[LC_TIME].time; | |
| struct iovec *iov = alloca (sizeof *iov | |
| * (2 + _NL_ITEM_INDEX (_NL_NUM_LC_TIME) | |
| + time->num_era - 1 | |
| + 2 * 99 | |
| + 2 + time->num_era * 10)); | |
| struct locale_file data; | |
| uint32_t idx[_NL_ITEM_INDEX (_NL_NUM_LC_TIME)]; | |
| size_t cnt, last_idx, num, n; | |
| data.magic = LIMAGIC (LC_TIME); | |
| data.n = _NL_ITEM_INDEX (_NL_NUM_LC_TIME); | |
| iov[0].iov_base = (void *) &data; | |
| iov[0].iov_len = sizeof (data); | |
| iov[1].iov_base = (void *) idx; | |
| iov[1].iov_len = sizeof (idx); | |
| idx[0] = iov[0].iov_len + iov[1].iov_len; | |
| /* The ab'days. */ | |
| for (cnt = 0; cnt <= _NL_ITEM_INDEX (ABDAY_7); ++cnt) | |
| { | |
| iov[2 + cnt].iov_base = | |
| (void *) (time->abday[cnt - _NL_ITEM_INDEX (ABDAY_1)] ?: ""); | |
| iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1; | |
| idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len; | |
| } | |
| /* The days. */ | |
| for (; cnt <= _NL_ITEM_INDEX (DAY_7); ++cnt) | |
| { | |
| iov[2 + cnt].iov_base = | |
| (void *) (time->day[cnt - _NL_ITEM_INDEX (DAY_1)] ?: ""); | |
| iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1; | |
| idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len; | |
| } | |
| /* The ab'mons. */ | |
| for (; cnt <= _NL_ITEM_INDEX (ABMON_12); ++cnt) | |
| { | |
| iov[2 + cnt].iov_base = | |
| (void *) (time->abmon[cnt - _NL_ITEM_INDEX (ABMON_1)] ?: ""); | |
| iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1; | |
| idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len; | |
| } | |
| /* The mons. */ | |
| for (; cnt <= _NL_ITEM_INDEX (MON_12); ++cnt) | |
| { | |
| iov[2 + cnt].iov_base = | |
| (void *) (time->mon[cnt - _NL_ITEM_INDEX (MON_1)] ?: ""); | |
| iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1; | |
| idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len; | |
| } | |
| /* AM/PM. */ | |
| for (; cnt <= _NL_ITEM_INDEX (PM_STR); ++cnt) | |
| { | |
| iov[2 + cnt].iov_base = | |
| (void *) (time->am_pm[cnt - _NL_ITEM_INDEX (AM_STR)] ?: ""); | |
| iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1; | |
| idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len; | |
| } | |
| iov[2 + cnt].iov_base = (void *) (time->d_t_fmt ?: ""); | |
| iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1; | |
| idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| iov[2 + cnt].iov_base = (void *) (time->d_fmt ?: ""); | |
| iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1; | |
| idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| iov[2 + cnt].iov_base = (void *) (time->t_fmt ?: ""); | |
| iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1; | |
| idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| iov[2 + cnt].iov_base = (void *) (time->t_fmt_ampm ?: ""); | |
| iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1; | |
| idx[1 + cnt] = idx[cnt] + iov[2 + cnt].iov_len; | |
| last_idx = ++cnt; | |
| idx[1 + last_idx] = idx[last_idx]; | |
| for (num = 0; num < time->num_era; ++num, ++cnt) | |
| { | |
| iov[2 + cnt].iov_base = (void *) time->era[num]; | |
| iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1; | |
| idx[1 + last_idx] += iov[2 + cnt].iov_len; | |
| } | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) (time->era_year ?: ""); | |
| iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1; | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) (time->era_d_fmt ?: ""); | |
| iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1; | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| idx[1 + last_idx] = idx[last_idx]; | |
| for (num = 0; num < 100; ++num, ++cnt) | |
| { | |
| iov[2 + cnt].iov_base = (void *) (time->alt_digits[num] ?: ""); | |
| iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1; | |
| idx[1 + last_idx] += iov[2 + cnt].iov_len; | |
| } | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) (time->era_d_t_fmt ?: ""); | |
| iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1; | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) (time->era_t_fmt ?: ""); | |
| iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1; | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| /* We must align the following data. */ | |
| iov[2 + cnt].iov_base = (void *) "\0\0"; | |
| iov[2 + cnt].iov_len = ((idx[last_idx] + 3) & ~3) - idx[last_idx]; | |
| idx[last_idx] = (idx[last_idx] + 3) & ~3; | |
| ++cnt; | |
| /* The `era' data in usable form. */ | |
| iov[2 + cnt].iov_base = (void *) &time->num_era; | |
| iov[2 + cnt].iov_len = sizeof (uint32_t); | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| idx[1 + last_idx] = idx[last_idx]; | |
| for (num = 0; num < time->num_era; ++num) | |
| { | |
| size_t l, l2; | |
| iov[2 + cnt].iov_base = (void *) &time->era_entries[num].direction; | |
| iov[2 + cnt].iov_len = sizeof (int32_t); | |
| ++cnt; | |
| iov[2 + cnt].iov_base = (void *) &time->era_entries[num].offset; | |
| iov[2 + cnt].iov_len = sizeof (int32_t); | |
| ++cnt; | |
| iov[2 + cnt].iov_base = (void *) &time->era_entries[num].start_date[0]; | |
| iov[2 + cnt].iov_len = sizeof (int32_t); | |
| ++cnt; | |
| iov[2 + cnt].iov_base = (void *) &time->era_entries[num].start_date[1]; | |
| iov[2 + cnt].iov_len = sizeof (int32_t); | |
| ++cnt; | |
| iov[2 + cnt].iov_base = (void *) &time->era_entries[num].start_date[2]; | |
| iov[2 + cnt].iov_len = sizeof (int32_t); | |
| ++cnt; | |
| iov[2 + cnt].iov_base = (void *) &time->era_entries[num].stop_date[0]; | |
| iov[2 + cnt].iov_len = sizeof (int32_t); | |
| ++cnt; | |
| iov[2 + cnt].iov_base = (void *) &time->era_entries[num].stop_date[1]; | |
| iov[2 + cnt].iov_len = sizeof (int32_t); | |
| ++cnt; | |
| iov[2 + cnt].iov_base = (void *) &time->era_entries[num].stop_date[2]; | |
| iov[2 + cnt].iov_len = sizeof (int32_t); | |
| ++cnt; | |
| l = ((char *) rawmemchr (time->era_entries[num].format, '\0') | |
| - time->era_entries[num].name) + 1; | |
| l2 = (l + 3) & ~3; | |
| iov[2 + cnt].iov_base = alloca (l2); | |
| memset (mempcpy (iov[2 + cnt].iov_base, time->era_entries[num].name, l), | |
| '\0', l2 - l); | |
| iov[2 + cnt].iov_len = l2; | |
| ++cnt; | |
| idx[1 + last_idx] += 8 * sizeof (int32_t) + l2; | |
| assert (idx[1 + last_idx] % 4 == 0); | |
| iov[2 + cnt].iov_base = (void *) time->era_entries[num].wname; | |
| iov[2 + cnt].iov_len = ((wcschr ((wchar_t *) time->era_entries[num].wformat, L'\0') | |
| - (wchar_t *) time->era_entries[num].wname + 1) | |
| * sizeof (uint32_t)); | |
| idx[1 + last_idx] += iov[2 + cnt].iov_len; | |
| ++cnt; | |
| } | |
| ++last_idx; | |
| /* The wide character ab'days. */ | |
| for (n = 0; n < 7; ++n, ++cnt, ++last_idx) | |
| { | |
| iov[2 + cnt].iov_base = | |
| (void *) (time->wabday[n] ?: empty_wstr); | |
| iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1) | |
| * sizeof (uint32_t)); | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| } | |
| /* The wide character days. */ | |
| for (n = 0; n < 7; ++n, ++cnt, ++last_idx) | |
| { | |
| iov[2 + cnt].iov_base = | |
| (void *) (time->wday[n] ?: empty_wstr); | |
| iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1) | |
| * sizeof (uint32_t)); | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| } | |
| /* The wide character ab'mons. */ | |
| for (n = 0; n < 12; ++n, ++cnt, ++last_idx) | |
| { | |
| iov[2 + cnt].iov_base = | |
| (void *) (time->wabmon[n] ?: empty_wstr); | |
| iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1) | |
| * sizeof (uint32_t)); | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| } | |
| /* The wide character mons. */ | |
| for (n = 0; n < 12; ++n, ++cnt, ++last_idx) | |
| { | |
| iov[2 + cnt].iov_base = | |
| (void *) (time->wmon[n] ?: empty_wstr); | |
| iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1) | |
| * sizeof (uint32_t)); | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| } | |
| /* Wide character AM/PM. */ | |
| for (n = 0; n < 2; ++n, ++cnt, ++last_idx) | |
| { | |
| iov[2 + cnt].iov_base = | |
| (void *) (time->wam_pm[n] ?: empty_wstr); | |
| iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1) | |
| * sizeof (uint32_t)); | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| } | |
| iov[2 + cnt].iov_base = (void *) (time->wd_t_fmt ?: empty_wstr); | |
| iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1) | |
| * sizeof (uint32_t)); | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) (time->wd_fmt ?: empty_wstr); | |
| iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1) | |
| * sizeof (uint32_t)); | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) (time->wt_fmt ?: empty_wstr); | |
| iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1) | |
| * sizeof (uint32_t)); | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) (time->wt_fmt_ampm ?: empty_wstr); | |
| iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1) | |
| * sizeof (uint32_t)); | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) (time->wera_year ?: empty_wstr); | |
| iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1) | |
| * sizeof (uint32_t)); | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) (time->wera_d_fmt ?: empty_wstr); | |
| iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1) | |
| * sizeof (uint32_t)); | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| idx[1 + last_idx] = idx[last_idx]; | |
| for (num = 0; num < 100; ++num, ++cnt) | |
| { | |
| iov[2 + cnt].iov_base = (void *) (time->walt_digits[num] | |
| ?: empty_wstr); | |
| iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1) | |
| * sizeof (uint32_t)); | |
| idx[1 + last_idx] += iov[2 + cnt].iov_len; | |
| } | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) (time->wera_d_t_fmt ?: empty_wstr); | |
| iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1) | |
| * sizeof (uint32_t)); | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) (time->wera_t_fmt ?: empty_wstr); | |
| iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1) | |
| * sizeof (uint32_t)); | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) &time->week_ndays; | |
| iov[2 + cnt].iov_len = 1; | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| /* We must align the following data. */ | |
| iov[2 + cnt].iov_base = (void *) "\0\0"; | |
| iov[2 + cnt].iov_len = ((idx[last_idx] + 3) & ~3) - idx[last_idx]; | |
| idx[last_idx] = (idx[last_idx] + 3) & ~3; | |
| ++cnt; | |
| iov[2 + cnt].iov_base = (void *) &time->week_1stday; | |
| iov[2 + cnt].iov_len = sizeof(uint32_t); | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) &time->week_1stweek; | |
| iov[2 + cnt].iov_len = 1; | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) &time->first_weekday; | |
| iov[2 + cnt].iov_len = 1; | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) &time->first_workday; | |
| iov[2 + cnt].iov_len = 1; | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) &time->cal_direction; | |
| iov[2 + cnt].iov_len = 1; | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) time->timezone; | |
| iov[2 + cnt].iov_len = strlen (time->timezone) + 1; | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) time->date_fmt; | |
| iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1; | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| /* We must align the following data. */ | |
| iov[2 + cnt].iov_base = (void *) "\0\0"; | |
| iov[2 + cnt].iov_len = -idx[last_idx] & 3; | |
| idx[last_idx] += -idx[last_idx] & 3; | |
| ++cnt; | |
| iov[2 + cnt].iov_base = (void *) time->wdate_fmt; | |
| iov[2 + cnt].iov_len = ((wcslen (iov[2 + cnt].iov_base) + 1) | |
| * sizeof (uint32_t)); | |
| idx[1 + last_idx] = idx[last_idx] + iov[2 + cnt].iov_len; | |
| ++cnt; | |
| ++last_idx; | |
| iov[2 + cnt].iov_base = (void *) charmap->code_set_name; | |
| iov[2 + cnt].iov_len = strlen (iov[2 + cnt].iov_base) + 1; | |
| ++cnt; | |
| ++last_idx; | |
| assert (cnt == (_NL_ITEM_INDEX (_NL_NUM_LC_TIME) | |
| + time->num_era - 1 | |
| + 2 * 99 | |
| + 2 + time->num_era * 10)); | |
| assert (last_idx == _NL_ITEM_INDEX (_NL_NUM_LC_TIME)); | |
| write_locale_data (output_path, LC_TIME, "LC_TIME", 2 + cnt, iov); | |
| } | |
| /* The parser for the LC_TIME section of the locale definition. */ | |
| void | |
| time_read (struct linereader *ldfile, struct localedef_t *result, | |
| const struct charmap_t *charmap, const char *repertoire_name, | |
| int ignore_content) | |
| { | |
| struct repertoire_t *repertoire = NULL; | |
| struct locale_time_t *time; | |
| struct token *now; | |
| enum token_t nowtok; | |
| size_t cnt; | |
| /* Get the repertoire we have to use. */ | |
| if (repertoire_name != NULL) | |
| repertoire = repertoire_read (repertoire_name); | |
| /* The rest of the line containing `LC_TIME' must be free. */ | |
| lr_ignore_rest (ldfile, 1); | |
| do | |
| { | |
| now = lr_token (ldfile, charmap, result, repertoire, verbose); | |
| nowtok = now->tok; | |
| } | |
| while (nowtok == tok_eol); | |
| /* If we see `copy' now we are almost done. */ | |
| if (nowtok == tok_copy) | |
| { | |
| handle_copy (ldfile, charmap, repertoire_name, result, tok_lc_time, | |
| LC_TIME, "LC_TIME", ignore_content); | |
| return; | |
| } | |
| /* Prepare the data structures. */ | |
| time_startup (ldfile, result, ignore_content); | |
| time = result->categories[LC_TIME].time; | |
| while (1) | |
| { | |
| /* Of course we don't proceed beyond the end of file. */ | |
| if (nowtok == tok_eof) | |
| break; | |
| /* Ingore empty lines. */ | |
| if (nowtok == tok_eol) | |
| { | |
| now = lr_token (ldfile, charmap, result, repertoire, verbose); | |
| nowtok = now->tok; | |
| continue; | |
| } | |
| switch (nowtok) | |
| { | |
| #define STRARR_ELEM(cat, min, max) \ | |
| case tok_##cat: \ | |
| /* Ignore the rest of the line if we don't need the input of \ | |
| this line. */ \ | |
| if (ignore_content) \ | |
| { \ | |
| lr_ignore_rest (ldfile, 0); \ | |
| break; \ | |
| } \ | |
| \ | |
| for (cnt = 0; cnt < max; ++cnt) \ | |
| { \ | |
| now = lr_token (ldfile, charmap, result, repertoire, verbose); \ | |
| if (now->tok == tok_eol) \ | |
| { \ | |
| if (cnt < min) \ | |
| lr_error (ldfile, _("%s: too few values for field `%s'"), \ | |
| "LC_TIME", #cat); \ | |
| if (!ignore_content) \ | |
| do \ | |
| { \ | |
| time->cat[cnt] = ""; \ | |
| time->w##cat[cnt] = empty_wstr; \ | |
| } \ | |
| while (++cnt < max); \ | |
| break; \ | |
| } \ | |
| else if (now->tok != tok_string) \ | |
| goto err_label; \ | |
| else if (!ignore_content && (now->val.str.startmb == NULL \ | |
| || now->val.str.startwc == NULL)) \ | |
| { \ | |
| lr_error (ldfile, _("%s: unknown character in field `%s'"), \ | |
| "LC_TIME", #cat); \ | |
| time->cat[cnt] = ""; \ | |
| time->w##cat[cnt] = empty_wstr; \ | |
| } \ | |
| else if (!ignore_content) \ | |
| { \ | |
| time->cat[cnt] = now->val.str.startmb; \ | |
| time->w##cat[cnt] = now->val.str.startwc; \ | |
| } \ | |
| \ | |
| /* Match the semicolon. */ \ | |
| now = lr_token (ldfile, charmap, result, repertoire, verbose); \ | |
| if (now->tok != tok_semicolon && now->tok != tok_eol) \ | |
| break; \ | |
| } \ | |
| if (now->tok != tok_eol) \ | |
| { \ | |
| while (!ignore_content && cnt < min) \ | |
| { \ | |
| time->cat[cnt] = ""; \ | |
| time->w##cat[cnt++] = empty_wstr; \ | |
| } \ | |
| \ | |
| if (now->tok == tok_semicolon) \ | |
| { \ | |
| now = lr_token (ldfile, charmap, result, repertoire, \ | |
| verbose); \ | |
| if (now->tok == tok_eol) \ | |
| lr_error (ldfile, _("extra trailing semicolon")); \ | |
| else if (now->tok == tok_string) \ | |
| { \ | |
| lr_error (ldfile, _("\ | |
| %s: too many values for field `%s'"), \ | |
| "LC_TIME", #cat); \ | |
| lr_ignore_rest (ldfile, 0); \ | |
| } \ | |
| else \ | |
| goto err_label; \ | |
| } \ | |
| else \ | |
| goto err_label; \ | |
| } \ | |
| time->cat##_defined = 1; \ | |
| break | |
| STRARR_ELEM (abday, 7, 7); | |
| STRARR_ELEM (day, 7, 7); | |
| STRARR_ELEM (abmon, 12, 12); | |
| STRARR_ELEM (mon, 12, 12); | |
| STRARR_ELEM (am_pm, 2, 2); | |
| STRARR_ELEM (alt_digits, 0, 100); | |
| case tok_era: | |
| /* Ignore the rest of the line if we don't need the input of | |
| this line. */ | |
| if (ignore_content) | |
| { | |
| lr_ignore_rest (ldfile, 0); | |
| break; | |
| } | |
| do | |
| { | |
| now = lr_token (ldfile, charmap, result, repertoire, verbose); | |
| if (now->tok != tok_string) | |
| goto err_label; | |
| if (!ignore_content && (now->val.str.startmb == NULL | |
| || now->val.str.startwc == NULL)) | |
| { | |
| lr_error (ldfile, _("%s: unknown character in field `%s'"), | |
| "LC_TIME", "era"); | |
| lr_ignore_rest (ldfile, 0); | |
| break; | |
| } | |
| if (!ignore_content) | |
| { | |
| time->era = xrealloc (time->era, | |
| (time->num_era + 1) * sizeof (char *)); | |
| time->era[time->num_era] = now->val.str.startmb; | |
| time->wera = xrealloc (time->wera, | |
| (time->num_era + 1) | |
| * sizeof (char *)); | |
| time->wera[time->num_era++] = now->val.str.startwc; | |
| } | |
| now = lr_token (ldfile, charmap, result, repertoire, verbose); | |
| if (now->tok != tok_eol && now->tok != tok_semicolon) | |
| goto err_label; | |
| } | |
| while (now->tok == tok_semicolon); | |
| break; | |
| #define STR_ELEM(cat) \ | |
| case tok_##cat: \ | |
| /* Ignore the rest of the line if we don't need the input of \ | |
| this line. */ \ | |
| if (ignore_content) \ | |
| { \ | |
| lr_ignore_rest (ldfile, 0); \ | |
| break; \ | |
| } \ | |
| \ | |
| now = lr_token (ldfile, charmap, result, repertoire, verbose); \ | |
| if (now->tok != tok_string) \ | |
| goto err_label; \ | |
| else if (time->cat != NULL) \ | |
| lr_error (ldfile, _("\ | |
| %s: field `%s' declared more than once"), "LC_TIME", #cat); \ | |
| else if (!ignore_content && (now->val.str.startmb == NULL \ | |
| || now->val.str.startwc == NULL)) \ | |
| { \ | |
| lr_error (ldfile, _("%s: unknown character in field `%s'"), \ | |
| "LC_TIME", #cat); \ | |
| time->cat = ""; \ | |
| time->w##cat = empty_wstr; \ | |
| } \ | |
| else if (!ignore_content) \ | |
| { \ | |
| time->cat = now->val.str.startmb; \ | |
| time->w##cat = now->val.str.startwc; \ | |
| } \ | |
| break | |
| STR_ELEM (d_t_fmt); | |
| STR_ELEM (d_fmt); | |
| STR_ELEM (t_fmt); | |
| STR_ELEM (t_fmt_ampm); | |
| STR_ELEM (era_year); | |
| STR_ELEM (era_d_t_fmt); | |
| STR_ELEM (era_d_fmt); | |
| STR_ELEM (era_t_fmt); | |
| STR_ELEM (timezone); | |
| STR_ELEM (date_fmt); | |
| #define INT_ELEM(cat) \ | |
| case tok_##cat: \ | |
| /* Ignore the rest of the line if we don't need the input of \ | |
| this line. */ \ | |
| if (ignore_content) \ | |
| { \ | |
| lr_ignore_rest (ldfile, 0); \ | |
| break; \ | |
| } \ | |
| \ | |
| now = lr_token (ldfile, charmap, result, repertoire, verbose); \ | |
| if (now->tok != tok_number) \ | |
| goto err_label; \ | |
| else if (time->cat != 0) \ | |
| lr_error (ldfile, _("%s: field `%s' declared more than once"), \ | |
| "LC_TIME", #cat); \ | |
| else if (!ignore_content) \ | |
| time->cat = now->val.num; \ | |
| break | |
| INT_ELEM (first_weekday); | |
| INT_ELEM (first_workday); | |
| INT_ELEM (cal_direction); | |
| case tok_week: | |
| /* Ignore the rest of the line if we don't need the input of | |
| this line. */ | |
| if (ignore_content) | |
| { | |
| lr_ignore_rest (ldfile, 0); | |
| break; | |
| } | |
| now = lr_token (ldfile, charmap, result, repertoire, verbose); | |
| if (now->tok != tok_number) | |
| goto err_label; | |
| time->week_ndays = now->val.num; | |
| now = lr_token (ldfile, charmap, result, repertoire, verbose); | |
| if (now->tok != tok_semicolon) | |
| goto err_label; | |
| now = lr_token (ldfile, charmap, result, repertoire, verbose); | |
| if (now->tok != tok_number) | |
| goto err_label; | |
| time->week_1stday = now->val.num; | |
| now = lr_token (ldfile, charmap, result, repertoire, verbose); | |
| if (now->tok != tok_semicolon) | |
| goto err_label; | |
| now = lr_token (ldfile, charmap, result, repertoire, verbose); | |
| if (now->tok != tok_number) | |
| goto err_label; | |
| time->week_1stweek = now->val.num; | |
| lr_ignore_rest (ldfile, 1); | |
| break; | |
| case tok_end: | |
| /* Next we assume `LC_TIME'. */ | |
| now = lr_token (ldfile, charmap, result, repertoire, verbose); | |
| if (now->tok == tok_eof) | |
| break; | |
| if (now->tok == tok_eol) | |
| lr_error (ldfile, _("%s: incomplete `END' line"), "LC_TIME"); | |
| else if (now->tok != tok_lc_time) | |
| lr_error (ldfile, _("\ | |
| %1$s: definition does not end with `END %1$s'"), "LC_TIME"); | |
| lr_ignore_rest (ldfile, now->tok == tok_lc_time); | |
| return; | |
| default: | |
| err_label: | |
| SYNTAX_ERROR (_("%s: syntax error"), "LC_TIME"); | |
| } | |
| /* Prepare for the next round. */ | |
| now = lr_token (ldfile, charmap, result, repertoire, verbose); | |
| nowtok = now->tok; | |
| } | |
| /* When we come here we reached the end of the file. */ | |
| lr_error (ldfile, _("%s: premature end of file"), "LC_TIME"); | |
| } |