mirror of
https://sourceware.org/git/glibc.git
synced 2024-11-29 16:21:07 +00:00
f16491eb8e
The error and warning handling in localedef, locale, and iconv
is a bit of a mess.
We use ugly constructs like this:
WITH_CUR_LOCALE (error (1, errno, gettext ("\
cannot read character map directory `%s'"), directory));
to issue errors, and read error_message_count directly from the
error API to detect errors. The problem with that is that the
code also uses error to print warnings, and informative messages.
All of this leads to problems where just having warnings will
produce an exit status as-if errors had been seen.
To fix this situation I have adopted the following high-level
changes:
* All errors are counted distinctly.
* All warnings are counted distinctly.
* All informative messages are not counted.
* Increasing verbosity cannot generate *more* errors, and
it previously did for errors conditional on verbose,
this is now fixed.
* Increasing verbosity *can* generate *more* warnings.
* Making the output quiet cannot generate *fewer* errors,
and it previously did for errors conditional on be_quiet,
this is now fixed.
* Each of error, warning, and informative message has it's
own function to call defined in record-status.h, and they
are: record_error, record_warning, and record_verbose.
* The record_error function always records an error, but
conditional on be_quiet may not print it.
* The record_warning function always records a warning,
but conditional on be_quiet may not print it.
* The record_verbose function only prints the verbose
message if verbose is true and be_quiet is false.
This has allowed the following fix:
* Previously any warnings were being treated as errors
because they incremented error_message_count, but now
we properly return an exit status of 1 if there are
warnings but output was generated.
All of this allows localedef to correctly decide if errors,
or warnings were present, and produce the correct exit code.
The locale and iconv programs now also use record-status.h
and we have removed the WITH_CUR_LOCALE hack, and instead
have internal push_locale/pop_locale functions centralized
in the record routines.
Signed-off-by: Carlos O'Donell <carlos@redhat.com>
952 lines
29 KiB
C
952 lines
29 KiB
C
/* Copyright (C) 1995-2017 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)
|
|
{
|
|
record_warning (_("\
|
|
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 (! nothing) \
|
|
record_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 (! nothing) \
|
|
record_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 != '-')
|
|
{
|
|
record_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 != ':')
|
|
{
|
|
record_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)
|
|
{
|
|
record_error (0, 0, _("\
|
|
%s: invalid number for offset in string %Zd in `era' field"),
|
|
"LC_TIME", idx + 1);
|
|
(void) strsep (&str, ":");
|
|
}
|
|
else if (*endp != ':')
|
|
{
|
|
record_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:
|
|
record_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:
|
|
record_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]))))
|
|
record_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:
|
|
record_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:
|
|
record_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]))))
|
|
record_error (0, 0, _("\
|
|
%s: invalid stopping date in string %Zd in `era' field"),
|
|
"LC_TIME", idx + 1);
|
|
}
|
|
}
|
|
|
|
if (str == NULL || *str == '\0')
|
|
{
|
|
record_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')
|
|
{
|
|
record_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"";
|
|
}
|
|
}
|
|
|
|
/* Set up defaults based on ISO 30112 WD10 [2014]. */
|
|
if (time->week_ndays == 0)
|
|
time->week_ndays = 7;
|
|
|
|
if (time->week_1stday == 0)
|
|
time->week_1stday = 19971130;
|
|
|
|
if (time->week_1stweek == 0)
|
|
time->week_1stweek = 7;
|
|
|
|
if (time->week_1stweek > time->week_ndays)
|
|
record_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)
|
|
record_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)
|
|
record_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)
|
|
record_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 locale_file file;
|
|
size_t num, n;
|
|
|
|
init_locale_data (&file, _NL_ITEM_INDEX (_NL_NUM_LC_TIME));
|
|
|
|
/* The ab'days. */
|
|
for (n = 0; n < 7; ++n)
|
|
add_locale_string (&file, time->abday[n] ?: "");
|
|
|
|
/* The days. */
|
|
for (n = 0; n < 7; ++n)
|
|
add_locale_string (&file, time->day[n] ?: "");
|
|
|
|
/* The ab'mons. */
|
|
for (n = 0; n < 12; ++n)
|
|
add_locale_string (&file, time->abmon[n] ?: "");
|
|
|
|
/* The mons. */
|
|
for (n = 0; n < 12; ++n)
|
|
add_locale_string (&file, time->mon[n] ?: "");
|
|
|
|
/* AM/PM. */
|
|
for (n = 0; n < 2; ++n)
|
|
add_locale_string (&file, time->am_pm[n]);
|
|
|
|
add_locale_string (&file, time->d_t_fmt ?: "");
|
|
add_locale_string (&file, time->d_fmt ?: "");
|
|
add_locale_string (&file, time->t_fmt ?: "");
|
|
add_locale_string (&file, time->t_fmt_ampm ?: "");
|
|
|
|
start_locale_structure (&file);
|
|
for (num = 0; num < time->num_era; ++num)
|
|
add_locale_string (&file, time->era[num]);
|
|
end_locale_structure (&file);
|
|
|
|
add_locale_string (&file, time->era_year ?: "");
|
|
add_locale_string (&file, time->era_d_fmt ?: "");
|
|
|
|
start_locale_structure (&file);
|
|
for (num = 0; num < 100; ++num)
|
|
add_locale_string (&file, time->alt_digits[num] ?: "");
|
|
end_locale_structure (&file);
|
|
|
|
add_locale_string (&file, time->era_d_t_fmt ?: "");
|
|
add_locale_string (&file, time->era_t_fmt ?: "");
|
|
add_locale_uint32 (&file, time->num_era);
|
|
|
|
start_locale_structure (&file);
|
|
for (num = 0; num < time->num_era; ++num)
|
|
{
|
|
add_locale_uint32 (&file, time->era_entries[num].direction);
|
|
add_locale_uint32 (&file, time->era_entries[num].offset);
|
|
add_locale_uint32 (&file, time->era_entries[num].start_date[0]);
|
|
add_locale_uint32 (&file, time->era_entries[num].start_date[1]);
|
|
add_locale_uint32 (&file, time->era_entries[num].start_date[2]);
|
|
add_locale_uint32 (&file, time->era_entries[num].stop_date[0]);
|
|
add_locale_uint32 (&file, time->era_entries[num].stop_date[1]);
|
|
add_locale_uint32 (&file, time->era_entries[num].stop_date[2]);
|
|
add_locale_string (&file, time->era_entries[num].name);
|
|
add_locale_string (&file, time->era_entries[num].format);
|
|
add_locale_wstring (&file, time->era_entries[num].wname);
|
|
add_locale_wstring (&file, time->era_entries[num].wformat);
|
|
}
|
|
end_locale_structure (&file);
|
|
|
|
/* The wide character ab'days. */
|
|
for (n = 0; n < 7; ++n)
|
|
add_locale_wstring (&file, time->wabday[n] ?: empty_wstr);
|
|
|
|
/* The wide character days. */
|
|
for (n = 0; n < 7; ++n)
|
|
add_locale_wstring (&file, time->wday[n] ?: empty_wstr);
|
|
|
|
/* The wide character ab'mons. */
|
|
for (n = 0; n < 12; ++n)
|
|
add_locale_wstring (&file, time->wabmon[n] ?: empty_wstr);
|
|
|
|
/* The wide character mons. */
|
|
for (n = 0; n < 12; ++n)
|
|
add_locale_wstring (&file, time->wmon[n] ?: empty_wstr);
|
|
|
|
/* Wide character AM/PM. */
|
|
for (n = 0; n < 2; ++n)
|
|
add_locale_wstring (&file, time->wam_pm[n] ?: empty_wstr);
|
|
|
|
add_locale_wstring (&file, time->wd_t_fmt ?: empty_wstr);
|
|
add_locale_wstring (&file, time->wd_fmt ?: empty_wstr);
|
|
add_locale_wstring (&file, time->wt_fmt ?: empty_wstr);
|
|
add_locale_wstring (&file, time->wt_fmt_ampm ?: empty_wstr);
|
|
add_locale_wstring (&file, time->wera_year ?: empty_wstr);
|
|
add_locale_wstring (&file, time->wera_d_fmt ?: empty_wstr);
|
|
|
|
start_locale_structure (&file);
|
|
for (num = 0; num < 100; ++num)
|
|
add_locale_wstring (&file, time->walt_digits[num] ?: empty_wstr);
|
|
end_locale_structure (&file);
|
|
|
|
add_locale_wstring (&file, time->wera_d_t_fmt ?: empty_wstr);
|
|
add_locale_wstring (&file, time->wera_t_fmt ?: empty_wstr);
|
|
add_locale_char (&file, time->week_ndays);
|
|
add_locale_uint32 (&file, time->week_1stday);
|
|
add_locale_char (&file, time->week_1stweek);
|
|
add_locale_char (&file, time->first_weekday);
|
|
add_locale_char (&file, time->first_workday);
|
|
add_locale_char (&file, time->cal_direction);
|
|
add_locale_string (&file, time->timezone);
|
|
add_locale_string (&file, time->date_fmt);
|
|
add_locale_wstring (&file, time->wdate_fmt);
|
|
add_locale_string (&file, charmap->code_set_name);
|
|
write_locale_data (output_path, LC_TIME, "LC_TIME", &file);
|
|
}
|
|
|
|
|
|
/* 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");
|
|
}
|