mirror of
https://sourceware.org/git/glibc.git
synced 2024-10-03 20:47:42 +00:00
75cd5204dd
* time/strftime.c: Use canonical autoconf nugget for time.h+sys/time.h include. Mon Apr 29 02:48:26 1996 Ulrich Drepper <drepper@cygnus.com> * ctype/ctype-info.c: (__ctype_width): New variable. (__ctype_names): Initialize correctly without offset. * locale/C-collate.c, locale/C-ctype.c, locale/C-messages.c, locale/C-monetary.c, locale/C-numeric.c, locale/C-time.c: Change copyright. * locale/C-ctype.c (_nl_C_LC_CTYPE_class32): Correct endianess for initialization value. * locale/lc-ctype.c (current): Add parameter for offset. (__ctype32_b, __ctype_width): Add initialization for these variables. * locale/programs/charmap.c: Finish support for WIDTH information. (new_width): New function. * locale/programs/charset.h (width_rule): new data structure. (charset_t): Add elements for width information. * locale/programs/ld-ctype.c (locale_ctype_t): Add element for width information. (allocate_arrays): Add new argument for charset. (ctype_finish): Make sure all characters named in charset width table are known to name table. (ctype_output): Correct handling of class and map name information and write out width information. (find_idx): Prepare for being called with NULL pointer as TABLE argument. This means only allocate name entry. (allocate_arrays): Correct handling of array element -1. Because EOF == -1 the value of element 127 must *not* be mirrored here. Fill width information from charset tables. * locale/programs/localedef.c (main): Correct loop over all categories after change of order from Thu Mar 28 14:22:51 1996. Add new charset argument to call of `write_all_categories'. * locale/programs/locales.h (ctype_finish, ctype_output): New charset argument. * locale/programs/locfile.c (write_all_categories): Call `ctype_output' with additional argument charset. * posix/getconf.c (vars): Add _POSIX_SYNC_IO, _POSIX_ASYNC_IO, and _POSIX_PRIO_IO definitions. * posix/posix2_lim.h: Add definition of _POSIX2_CHARCLASS_NAME_MAX and CHARCLASS_NAME_MAX. * posix/unistd.h: Document _POSIX_SYNC_IO, _POSIX_ASYNC_IO, and _POSIX_PRIO_IO. * stdlib/grouping.h: Prepare for use in wide string functions. * stdlib/stdlib.h: Correct prototypes for __strto*_internal functions. * stdlib/strtod.c: Extend for use as `wcsto{f,d,ld}'. * stdlib/strtol.c: Extend for use as `wcsto{l,ul,q,uq}'. * string/strcoll.c: Extend for use as `wcscoll'. * string/strxfrm.c: Extend for use as `wcsxfrm'. * sysdeps/generic/confname.h: Add definition of _PC_SYNC_IO, _PC_ASYNC_IO, _PC_PRIO_IO and _SC_CHARCLASS_NAME_MAX. * sysdeps/generic/stpncpy.c: Correct return value. * sysdeps/posix/fpathconf.c: Add handling of _PC_SYNC_IO, _PC_ASYNC_IO, and _PC_PRIO_IO. * sysdeps/posix/sysconf.c: Add handling of _SC_REALTIME_SIGNALS, _SC_PRIORITY_SCHEDULING, _SC_TIMERS, _SC_ASYNCHRONOUS_IO, _SC_PRIORITIZED_IO, _SC_SYNCHRONIZED_IO, _SC_FSYNC, _SC_MAPPED_FILES, _SC_MEMLOCK, _SC_MEMLOCK_RANGE, _SC_MEMORY_PROTECTION, _SC_MESSAGE_PASSING, _SC_SEMAPHORES, _SC_SHARED_MEMORY_OBJECTS, and _SC_CHARCLASS_NAME_MAX. * sysdeps/stub/sysconf.c: Ditto. * sysdeps/unix/sysv/sysv4/sysconf.c: Ditto. * sysdeps/unix/sysv/linux/Dist: Add sys/sysctl.h. * sysdeps/unix/sysv/linux/Makefile [subdir == misc] (sysdep_routines): Add s_sysctl and sysctl. * sysdeps/unix/sysv/linux/sys/mman.h: Add declaration of mremap. * sysdeps/unix/sysv/linux/sys/socket.h: New file. Wrapper around kernel header. * sysdeps/unix/sysv/linux/sys/sysctl.h: New file. Define interface to `sysctl' function. * sysdeps/unix/sysv/linux/syscalls.list: Add mremap and _sysctl. * sysdeps/unix/sysv/linux/sysconf.c: Add handling of _SC_CHARCLASS_NAME_MAX. * sysdeps/unix/sysv/linux/sysctl.c: new file. Implement caller of _sysctl system call. * sysvipc/Makefile (routines): Add ftok. * sysvipc/ftok.c: use variable `proj_id' not `id'. Patch by David Mosberger-Tang. * wcsmbs/Makefile (routines): Add wcpcpy, wcpncpy, wcstol, wcstoul, wcstoq, wcstouq, wcstod, wcstold, wcstof, wcscoll, wcsxfrm, wcwidth, and wcswidth. * wcsmbs/wchar.h: Add declarations for wcpcpy, wcpncpy, wcstol, wcstoul, wcstoq, wcstouq, wcstod, wcstold, wcstof, wcscoll, wcsxfrm, wcwidth, and wcswidth. Declare internal interfaces for wcsto* functions. [OPTIMIZE]: Define inline functions for wcsto* functions to call internal interface functions. * wcsmbs/wcpcpy.c, wcsmbs/wcpncpy.c: New files. Implement non- standard function equivalent to stpcpy/stpncpy. * wcsmbs/wcscoll.c: Implement `wcscoll' function by using `strcoll' implementation. * wcsmbs/wcscpy.c, wcsmbs/wcsncpy.c: Use wint_t instead of wchar_t. * wcsmbs/wcstod.c: Implement `wcstod' function by using `strtod' implementation. * wcsmbs/wcstof.c: Same for `wcstof'. * wcsmbs/wcstold.c: Same for `strtold'. * wcsmbs/wcstol.c: Implement `wcstol' function by using `strtol' implementation. * wcsmbs/wcstoq.c: Same for `wcstoq'. * wcsmbs/wcstoul.c: Same for `wcstoul'. * wcsmbs/wcstouq.c: Same for `wcstouq'. * wcsmbs/wcswidth.c: Implement `wcswidth' function from X/Open CAE. * wcsmbs/wcwidth.c: Ditto for `wcwidth'. * wcsmbs/wcwidth.h: Common function for definitions of above two functions. * wcsmbs/wcsxfrm.c: Implement `wcsxfrm function by using `strxfrm implementation. * wctype/wctype.c: Remove case for `wctype_t' being 16 bit type. * wctype/wctype.h (wint_t): Protect against multiple definition. (wctype_t): Always define as `unsigned long int'. * wctype.h: New file. Wrapper around wctype/wctype.h. * hurd/hurdstartup.c (_hurd_split_args): Function removed. (_hurd_startup): Use argz functions. * hurd/hurdexec.c: Use argz functions.
982 lines
24 KiB
C
982 lines
24 KiB
C
/* Copyright (C) 1996 Free Software Foundation, Inc.
|
|
This file is part of the GNU C Library.
|
|
Contributed by Ulrich Drepper, <drepper@gnu.ai.mit.edu>.
|
|
|
|
The GNU C Library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public License as
|
|
published by the Free Software Foundation; either version 2 of the
|
|
License, or (at your option) any later version.
|
|
|
|
The GNU C Library 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
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public
|
|
License along with the GNU C Library; see the file COPYING.LIB. If
|
|
not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
Boston, MA 02111-1307, USA. */
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
# include <config.h>
|
|
#endif
|
|
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <locale.h>
|
|
#include <malloc.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <unistd.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/uio.h>
|
|
|
|
#include "locfile.h"
|
|
#include "linereader.h"
|
|
#include "localeinfo.h"
|
|
#include "locales.h"
|
|
|
|
|
|
/* Uncomment the following line in the production version. */
|
|
/* #define NDEBUG 1 */
|
|
#include <assert.h>
|
|
|
|
/* Define the lookup function. */
|
|
#include "locfile-kw.h"
|
|
|
|
|
|
/* Some useful macros. */
|
|
#define MIN(a, b) (__extension__ ({ typeof (a) _a = (a); \
|
|
typeof (b) _b = (b); \
|
|
_a < _b ? _a : _b; }))
|
|
|
|
|
|
void *xmalloc (size_t __n);
|
|
char *xstrdup (const char *__str);
|
|
|
|
struct localedef_t *
|
|
locfile_read (const char *filename, struct charset_t *charset)
|
|
{
|
|
struct linereader *ldfile;
|
|
struct localedef_t *result;
|
|
int state;
|
|
enum token_t expected_tok = tok_none;
|
|
const char *expected_str = NULL;
|
|
enum token_t ctype_tok_sym = tok_none;
|
|
const char *ctype_tok_str = NULL;
|
|
int copy_category = 0;
|
|
int cnt;
|
|
|
|
/* Allocate space for result. */
|
|
result = (struct localedef_t *) xmalloc (sizeof (struct localedef_t));
|
|
memset (result, '\0', sizeof (struct localedef_t));
|
|
|
|
ldfile = lr_open (filename, locfile_hash);
|
|
if (ldfile == NULL)
|
|
{
|
|
if (filename[0] != '/')
|
|
{
|
|
char path[strlen (filename) + 1 + sizeof (LOCSRCDIR)];
|
|
|
|
stpcpy (stpcpy (stpcpy (path, LOCSRCDIR), "/"), filename);
|
|
ldfile = lr_open (path, locfile_hash);
|
|
}
|
|
|
|
if (ldfile == NULL)
|
|
{
|
|
result->failed = 1;
|
|
return result;
|
|
}
|
|
}
|
|
|
|
#define HANDLE_COPY(category, token, string) \
|
|
if (nowtok == tok_copy) \
|
|
{ \
|
|
copy_category = category; \
|
|
expected_tok = token; \
|
|
expected_str = string; \
|
|
state = 8; \
|
|
continue; \
|
|
} \
|
|
++state
|
|
|
|
#define LOCALE_PROLOG(token, string) \
|
|
if (nowtok == tok_eol) \
|
|
/* Ignore empty lines. */ \
|
|
continue; \
|
|
if (nowtok == tok_end) \
|
|
{ \
|
|
expected_tok = token; \
|
|
expected_str = string; \
|
|
state = 4; \
|
|
continue; \
|
|
} \
|
|
if (nowtok == tok_copy) \
|
|
goto only_copy;
|
|
|
|
|
|
#define READ_STRING(fn, errlabel) \
|
|
do \
|
|
{ \
|
|
arg = lr_token (ldfile, charset); \
|
|
if (arg->tok != tok_string) \
|
|
goto errlabel; \
|
|
fn (ldfile, result, nowtok, arg, charset); \
|
|
lr_ignore_rest (ldfile, 1); \
|
|
} \
|
|
while (0)
|
|
|
|
#define READ_STRING_LIST(fn, errlabel) \
|
|
do \
|
|
{ \
|
|
arg = lr_token (ldfile, charset); \
|
|
while (arg->tok == tok_string) \
|
|
{ \
|
|
fn (ldfile, result, nowtok, arg, charset); \
|
|
arg = lr_token (ldfile, charset); \
|
|
if (arg->tok != tok_semicolon) \
|
|
break; \
|
|
arg = lr_token (ldfile, charset); \
|
|
} \
|
|
if (arg->tok != tok_eol) \
|
|
goto errlabel; \
|
|
} \
|
|
while (0)
|
|
|
|
#define READ_NUMBER(fn, errlabel) \
|
|
do \
|
|
{ \
|
|
arg = lr_token (ldfile, charset); \
|
|
if (arg->tok != tok_minus1 && arg->tok != tok_number) \
|
|
goto errlabel; \
|
|
fn (ldfile, result, nowtok, arg, charset); \
|
|
lr_ignore_rest (ldfile, 1); \
|
|
} \
|
|
while (0)
|
|
|
|
#define READ_NUMBER_LIST(fn, errlabel) \
|
|
do \
|
|
{ \
|
|
arg = lr_token (ldfile, charset); \
|
|
while (arg->tok == tok_minus1 || arg->tok == tok_number) \
|
|
{ \
|
|
fn (ldfile, result, nowtok, arg, charset); \
|
|
arg = lr_token (ldfile, charset); \
|
|
if (arg->tok != tok_semicolon) \
|
|
break; \
|
|
arg = lr_token (ldfile, charset); \
|
|
} \
|
|
if (arg->tok != tok_eol) \
|
|
goto errlabel; \
|
|
} \
|
|
while (0)
|
|
|
|
#define SYNTAX_ERROR(string) \
|
|
lr_error (ldfile, string); \
|
|
lr_ignore_rest (ldfile, 0);
|
|
|
|
|
|
/* Parse locale definition file and store result in RESULT. */
|
|
state = 1;
|
|
while (1)
|
|
{
|
|
/* What's on? */
|
|
struct token *now = lr_token (ldfile, charset);
|
|
enum token_t nowtok = now->tok;
|
|
struct token *arg;
|
|
|
|
if (nowtok == tok_eof)
|
|
break;
|
|
|
|
switch (state)
|
|
{
|
|
case 1:
|
|
/* The beginning. We expect the special declarations, EOL or
|
|
the start of any locale. */
|
|
if (nowtok == tok_eol)
|
|
/* Ignore empty lines. */
|
|
continue;
|
|
|
|
switch (nowtok)
|
|
{
|
|
case tok_escape_char:
|
|
case tok_comment_char:
|
|
/* We need an argument. */
|
|
arg = lr_token (ldfile, charset);
|
|
|
|
if (arg->tok != tok_ident)
|
|
{
|
|
SYNTAX_ERROR (_("bad argument"));
|
|
continue;
|
|
}
|
|
|
|
if (arg->val.str.len != 1)
|
|
{
|
|
lr_error (ldfile, _("\
|
|
argument to `%s' must be a single character"),
|
|
nowtok == tok_escape_char ? "escape_char"
|
|
: "comment_char");
|
|
|
|
lr_ignore_rest (ldfile, 0);
|
|
continue;
|
|
}
|
|
|
|
if (nowtok == tok_escape_char)
|
|
ldfile->escape_char = *arg->val.str.start;
|
|
else
|
|
ldfile->comment_char = *arg->val.str.start;
|
|
break;
|
|
|
|
case tok_lc_ctype:
|
|
state = 2;
|
|
break;
|
|
|
|
case tok_lc_collate:
|
|
state = 10;
|
|
break;
|
|
|
|
case tok_lc_monetary:
|
|
state = 20;
|
|
break;
|
|
|
|
case tok_lc_numeric:
|
|
state = 30;
|
|
break;
|
|
|
|
case tok_lc_time:
|
|
state = 40;
|
|
break;
|
|
|
|
case tok_lc_messages:
|
|
state = 50;
|
|
break;
|
|
|
|
default:
|
|
SYNTAX_ERROR (_("\
|
|
syntax error: not inside a locale definition section"));
|
|
continue;
|
|
}
|
|
lr_ignore_rest (ldfile, 1);
|
|
continue;
|
|
|
|
case 2:
|
|
HANDLE_COPY (LC_CTYPE, tok_lc_ctype, "LC_CYTPE");
|
|
|
|
ctype_startup (ldfile, result, charset);
|
|
/* FALLTHROUGH */
|
|
|
|
case 3:
|
|
/* Here we accept all the character classes, tolower/toupper,
|
|
and following ANSI C:1995 self-defined classes. */
|
|
LOCALE_PROLOG (tok_lc_ctype, "LC_CTYPE");
|
|
|
|
if (nowtok == tok_charclass)
|
|
{
|
|
READ_STRING_LIST (ctype_class_new, bad_new_charclass);
|
|
continue;
|
|
bad_new_charclass:
|
|
SYNTAX_ERROR (_("\
|
|
syntax error in definition of new character class"));
|
|
continue;
|
|
}
|
|
|
|
if (nowtok == tok_charmap)
|
|
{
|
|
READ_STRING_LIST (ctype_map_new, bad_new_charmap);
|
|
continue;
|
|
bad_new_charmap:
|
|
SYNTAX_ERROR (_("\
|
|
syntax error in definition of new character map"));
|
|
continue;
|
|
}
|
|
|
|
if (nowtok == tok_upper || nowtok == tok_lower
|
|
|| nowtok == tok_alpha || nowtok == tok_digit
|
|
|| nowtok == tok_alnum || nowtok == tok_space
|
|
|| nowtok == tok_cntrl || nowtok == tok_punct
|
|
|| nowtok == tok_graph || nowtok == tok_print
|
|
|| nowtok == tok_xdigit || nowtok == tok_blank)
|
|
{
|
|
ctype_tok_sym = nowtok;
|
|
ctype_tok_str = NULL;
|
|
state = 5;
|
|
continue;
|
|
}
|
|
|
|
if (nowtok == tok_toupper|| nowtok == tok_tolower)
|
|
{
|
|
ctype_tok_sym = nowtok;
|
|
ctype_tok_str = NULL;
|
|
state = 6;
|
|
continue;
|
|
}
|
|
|
|
if (nowtok != tok_ident)
|
|
goto bad_charclass;
|
|
|
|
/* We possibly have a self-defined character class. */
|
|
if (ctype_is_charclass (ldfile, result, now->val.str.start))
|
|
{
|
|
ctype_tok_sym = nowtok;
|
|
ctype_tok_str = now->val.str.start;
|
|
state = 5;
|
|
continue;
|
|
}
|
|
|
|
/* ...or a self-defined character map. */
|
|
if (ctype_is_charmap (ldfile, result, now->val.str.start))
|
|
{
|
|
ctype_tok_sym = nowtok;
|
|
ctype_tok_str = now->val.str.start;
|
|
state = 6;
|
|
continue;
|
|
}
|
|
|
|
SYNTAX_ERROR (_("syntax error in definition of LC_CTYPE category"));
|
|
continue;
|
|
|
|
case 4:
|
|
/* Handle `END xxx'. */
|
|
if (nowtok != expected_tok)
|
|
lr_error (ldfile, _("\
|
|
`%1$s' definition does not end with `END %1$s'"), expected_str);
|
|
|
|
lr_ignore_rest (ldfile, nowtok == expected_tok);
|
|
state = 1;
|
|
continue;
|
|
|
|
case 5:
|
|
/* Here we expect a semicolon separated list of bsymbols. The
|
|
bit to be set in the word is given in CHARCLASS_BIT. */
|
|
arg = now;
|
|
|
|
ctype_class_start (ldfile, result, ctype_tok_sym, ctype_tok_str,
|
|
charset);
|
|
|
|
while (arg->tok != tok_eol)
|
|
{
|
|
/* Any token other than a bsymbol is an error. */
|
|
if (arg->tok != tok_bsymbol)
|
|
{
|
|
bad_charclass:
|
|
SYNTAX_ERROR (_("\
|
|
syntax error in character class definition"));
|
|
break;
|
|
}
|
|
|
|
/* Lookup value for token and write into array. */
|
|
ctype_class_from (ldfile, result, arg, charset);
|
|
|
|
arg = lr_token (ldfile, charset);
|
|
if (arg->tok == tok_semicolon)
|
|
arg = lr_token (ldfile, charset);
|
|
else if (arg->tok != tok_eol)
|
|
goto bad_charclass;
|
|
|
|
/* Look for ellipsis. */
|
|
if (arg->tok == tok_ellipsis)
|
|
{
|
|
arg = lr_token (ldfile, charset);
|
|
if (arg->tok != tok_semicolon)
|
|
goto bad_charclass;
|
|
|
|
arg = lr_token (ldfile, charset);
|
|
if (arg->tok != tok_bsymbol)
|
|
goto bad_charclass;
|
|
|
|
/* Write range starting at LAST to ARG->VAL. */
|
|
ctype_class_to (ldfile, result, arg, charset);
|
|
|
|
arg = lr_token (ldfile, charset);
|
|
if (arg->tok == tok_semicolon)
|
|
arg = lr_token (ldfile, charset);
|
|
else if (arg->tok != tok_eol)
|
|
goto bad_charclass;
|
|
}
|
|
}
|
|
|
|
/* Mark class as already seen. */
|
|
ctype_class_end (ldfile, result);
|
|
state = 3;
|
|
|
|
continue;
|
|
|
|
case 6:
|
|
/* Here we expect a list of character mappings. Note: the
|
|
first opening brace is already matched. */
|
|
ctype_map_start (ldfile, result, ctype_tok_sym, ctype_tok_str,
|
|
charset);
|
|
|
|
while (1)
|
|
{
|
|
/* Match ( bsymbol , bsymbol ) */
|
|
if (now->tok != tok_open_brace)
|
|
goto bad_charmap;
|
|
|
|
now = lr_token (ldfile, charset);
|
|
if (now->tok != tok_bsymbol)
|
|
{
|
|
bad_charmap:
|
|
SYNTAX_ERROR (_("\
|
|
syntax error in character mapping definition"));
|
|
state = 3;
|
|
break;
|
|
}
|
|
|
|
/* Lookup arg and assign to FROM. */
|
|
ctype_map_from (ldfile, result, now, charset);
|
|
|
|
now = lr_token (ldfile, charset);
|
|
if (now->tok != tok_comma)
|
|
goto bad_charmap;
|
|
|
|
now = lr_token (ldfile, charset);
|
|
if (now->tok != tok_bsymbol)
|
|
goto bad_charmap;
|
|
|
|
/* Lookup arg and assign to TO. */
|
|
ctype_map_to (ldfile, result, now, charset);
|
|
|
|
now = lr_token (ldfile, charset);
|
|
if (now->tok != tok_close_brace)
|
|
goto bad_charmap;
|
|
|
|
now = lr_token (ldfile, charset);
|
|
if (now->tok == tok_eol)
|
|
{
|
|
state = 3;
|
|
break;
|
|
}
|
|
if (now->tok != tok_semicolon)
|
|
goto bad_charmap;
|
|
|
|
now = lr_token (ldfile, charset);
|
|
}
|
|
|
|
ctype_map_end (ldfile, result);
|
|
continue;
|
|
|
|
case 8:
|
|
{
|
|
/* We have seen `copy'. First match the argument. */
|
|
int warned = 0;
|
|
|
|
if (nowtok != tok_string)
|
|
lr_error (ldfile, _("expect string argument for `copy'"));
|
|
else
|
|
def_to_process (now->val.str.start, 1 << copy_category);
|
|
|
|
lr_ignore_rest (ldfile, nowtok == tok_string);
|
|
|
|
/* The rest of the line must be empty
|
|
and the next keyword must be `END xxx'. */
|
|
|
|
while (lr_token (ldfile, charset)->tok != tok_end)
|
|
{
|
|
if (warned == 0)
|
|
{
|
|
only_copy:
|
|
lr_error (ldfile, _("\
|
|
no other keyword shall be specified when `copy' is used"));
|
|
warned = 1;
|
|
}
|
|
|
|
lr_ignore_rest (ldfile, 0);
|
|
}
|
|
|
|
state = 4;
|
|
}
|
|
continue;
|
|
|
|
case 10:
|
|
HANDLE_COPY (LC_COLLATE, tok_lc_collate, "LC_COLLATE");
|
|
|
|
collate_startup (ldfile, result, charset);
|
|
/* FALLTHROUGH */
|
|
|
|
case 11:
|
|
/* Process the LC_COLLATE section. We expect `END LC_COLLATE'
|
|
any of the collation specifications, or any bsymbol. */
|
|
LOCALE_PROLOG (tok_lc_collate, "LC_COLLATE");
|
|
|
|
if (nowtok == tok_order_start)
|
|
{
|
|
state = 12;
|
|
continue;
|
|
}
|
|
|
|
if (nowtok != tok_collating_element
|
|
&& nowtok != tok_collating_symbol)
|
|
{
|
|
bad_collation:
|
|
lr_error (ldfile, _("\
|
|
syntax error in collation definition"));
|
|
lr_ignore_rest (ldfile, 0);
|
|
continue;
|
|
}
|
|
|
|
/* Get argument. */
|
|
arg = lr_token (ldfile, charset);
|
|
if (arg->tok != tok_bsymbol)
|
|
{
|
|
lr_error (ldfile, _("\
|
|
collation symbol expected after `%s'"),
|
|
nowtok == tok_collating_element
|
|
? "collating-element" : "collating-symbol");
|
|
lr_ignore_rest (ldfile, 0);
|
|
continue;
|
|
}
|
|
|
|
if (nowtok == tok_collating_element)
|
|
{
|
|
/* Save to-value as new name. */
|
|
collate_element_to (ldfile, result, arg, charset);
|
|
|
|
arg = lr_token (ldfile, charset);
|
|
if (arg->tok != tok_from)
|
|
{
|
|
lr_error (ldfile, _("\
|
|
`from' expected after first argument to `collating-element'"));
|
|
lr_ignore_rest (ldfile, 0);
|
|
continue;
|
|
}
|
|
|
|
arg = lr_token (ldfile, charset);
|
|
if (arg->tok != tok_string)
|
|
{
|
|
lr_error (ldfile, _("\
|
|
from-value of `collating-element' must be a string"));
|
|
lr_ignore_rest (ldfile, 0);
|
|
continue;
|
|
}
|
|
|
|
/* Enter new collating element. */
|
|
collate_element_from (ldfile, result, arg, charset);
|
|
}
|
|
else
|
|
/* Enter new collating symbol into table. */
|
|
collate_symbol (ldfile, result, arg, charset);
|
|
|
|
lr_ignore_rest (ldfile, 1);
|
|
continue;
|
|
|
|
case 12:
|
|
/* We parse the rest of the line containing `order_start'.
|
|
In any case we continue with parsing the symbols. */
|
|
state = 13;
|
|
|
|
cnt = 0;
|
|
while (now->tok != tok_eol)
|
|
{
|
|
int collation_method = 0;
|
|
|
|
++cnt;
|
|
|
|
do
|
|
{
|
|
if (now->tok == tok_forward)
|
|
collation_method |= sort_forward;
|
|
else if (now->tok == tok_backward)
|
|
collation_method |= sort_backward;
|
|
else if (now->tok == tok_position)
|
|
collation_method |= sort_position;
|
|
else
|
|
{
|
|
lr_error (ldfile, _("unknown collation directive"));
|
|
lr_ignore_rest (ldfile, 0);
|
|
continue;
|
|
}
|
|
|
|
now = lr_token (ldfile, charset);
|
|
}
|
|
while (now->tok == tok_comma
|
|
&& (now == lr_token (ldfile, charset) != tok_none));
|
|
|
|
/* Check for consistency: forward and backwards are
|
|
mutually exclusive. */
|
|
if ((collation_method & sort_forward) != 0
|
|
&& (collation_method & sort_backward) != 0)
|
|
{
|
|
lr_error (ldfile, _("\
|
|
sorting order `forward' and `backward' are mutually exclusive"));
|
|
/* The recover clear the backward flag. */
|
|
collation_method &= ~sort_backward;
|
|
}
|
|
|
|
/* ??? I don't know whether this is correct but while
|
|
thinking about the `strcoll' functions I found that I
|
|
need a direction when performing position depended
|
|
collation. So I assume here that implicitly the
|
|
direction `forward' is given when `position' alone is
|
|
written. --drepper */
|
|
if (collation_method == sort_position)
|
|
collation_method |= sort_forward;
|
|
|
|
/* Enter info about next collation order. */
|
|
collate_new_order (ldfile, result, collation_method);
|
|
|
|
if (now->tok != tok_eol && now->tok != tok_semicolon)
|
|
{
|
|
lr_error (ldfile, _("\
|
|
syntax error in `order_start' directive"));
|
|
lr_ignore_rest (ldfile, 0);
|
|
break;
|
|
}
|
|
|
|
if (now->tok == tok_semicolon)
|
|
now = lr_token (ldfile, charset);
|
|
}
|
|
|
|
/* If no argument to `order_start' is given, one `forward'
|
|
argument is implicitely assumed. */
|
|
if (cnt == 0)
|
|
collate_new_order (ldfile, result, sort_forward);
|
|
|
|
|
|
/* We now know about all sorting rules. */
|
|
collate_build_arrays (ldfile, result);
|
|
|
|
continue;
|
|
|
|
case 13:
|
|
/* We read one symbol a line until `order_end' is found. */
|
|
{
|
|
static int last_correct = 1;
|
|
|
|
if (nowtok == tok_order_end)
|
|
{
|
|
state = 14;
|
|
lr_ignore_rest (ldfile, 1);
|
|
continue;
|
|
}
|
|
|
|
/* Ignore empty lines. */
|
|
if (nowtok == tok_eol)
|
|
continue;
|
|
|
|
if (nowtok != tok_bsymbol && nowtok != tok_undefined
|
|
&& nowtok != tok_ellipsis)
|
|
{
|
|
if (last_correct == 1)
|
|
{
|
|
lr_error (ldfile, _("\
|
|
syntax error in collating order definition"));
|
|
last_correct = 0;
|
|
}
|
|
lr_ignore_rest (ldfile, 0);
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
last_correct = 1;
|
|
|
|
/* Remember current token. */
|
|
if (collate_order_elem (ldfile, result, now, charset) < 0)
|
|
continue;
|
|
}
|
|
|
|
/* Read optional arguments. */
|
|
arg = lr_token (ldfile, charset);
|
|
while (arg->tok != tok_eol)
|
|
{
|
|
if (arg->tok != tok_ignore && arg->tok != tok_ellipsis
|
|
&& arg->tok != tok_bsymbol && arg->tok != tok_string)
|
|
break;
|
|
|
|
if (arg->tok == tok_ignore || arg->tok == tok_ellipsis
|
|
|| arg->tok == tok_string)
|
|
{
|
|
/* Call handler for simple weights. */
|
|
if (collate_simple_weight (ldfile, result, arg, charset)
|
|
< 0)
|
|
goto illegal_weight;
|
|
|
|
arg = lr_token (ldfile, charset);
|
|
}
|
|
else
|
|
do
|
|
{
|
|
/* Collect char. */
|
|
int ok = collate_weight_bsymbol (ldfile, result, arg,
|
|
charset);
|
|
if (ok < 0)
|
|
goto illegal_weight;
|
|
|
|
arg = lr_token (ldfile, charset);
|
|
}
|
|
while (arg->tok == tok_bsymbol);
|
|
|
|
/* Are there more weights? */
|
|
if (arg->tok != tok_semicolon)
|
|
break;
|
|
|
|
/* Yes, prepare next weight. */
|
|
if (collate_next_weight (ldfile, result) < 0)
|
|
goto illegal_weight;
|
|
|
|
arg = lr_token (ldfile, charset);
|
|
}
|
|
|
|
if (arg->tok != tok_eol)
|
|
{
|
|
SYNTAX_ERROR (_("syntax error in order specification"));
|
|
}
|
|
|
|
collate_end_weight (ldfile, result);
|
|
illegal_weight:
|
|
}
|
|
continue;
|
|
|
|
case 14:
|
|
/* Following to the `order_end' keyword we don't expect
|
|
anything but the `END'. */
|
|
if (nowtok == tok_eol)
|
|
continue;
|
|
|
|
if (nowtok != tok_end)
|
|
goto bad_collation;
|
|
|
|
expected_tok = tok_lc_collate;
|
|
expected_str = "LC_COLLATE";
|
|
state = 4;
|
|
|
|
ldfile->translate_strings = 1;
|
|
continue;
|
|
|
|
case 20:
|
|
HANDLE_COPY (LC_MONETARY, tok_lc_monetary, "LC_MONETARY");
|
|
|
|
monetary_startup (ldfile, result, charset);
|
|
/* FALLTHROUGH */
|
|
|
|
case 21:
|
|
LOCALE_PROLOG (tok_lc_monetary, "LC_MONETARY");
|
|
|
|
switch (nowtok)
|
|
{
|
|
case tok_int_curr_symbol:
|
|
case tok_currency_symbol:
|
|
case tok_mon_decimal_point:
|
|
case tok_mon_thousands_sep:
|
|
case tok_positive_sign:
|
|
case tok_negative_sign:
|
|
READ_STRING (monetary_add, bad_monetary);
|
|
break;
|
|
|
|
case tok_int_frac_digits:
|
|
case tok_frac_digits:
|
|
case tok_p_cs_precedes:
|
|
case tok_p_sep_by_space:
|
|
case tok_n_cs_precedes:
|
|
case tok_n_sep_by_space:
|
|
case tok_p_sign_posn:
|
|
case tok_n_sign_posn:
|
|
READ_NUMBER (monetary_add, bad_monetary);
|
|
break;
|
|
|
|
case tok_mon_grouping:
|
|
/* We have a semicolon separated list of integers. */
|
|
READ_NUMBER_LIST (monetary_add, bad_monetary);
|
|
break;
|
|
|
|
default:
|
|
bad_monetary:
|
|
SYNTAX_ERROR (_("syntax error in monetary locale definition"));
|
|
}
|
|
continue;
|
|
|
|
case 30:
|
|
HANDLE_COPY (LC_NUMERIC, tok_lc_numeric, "LC_NUMERIC");
|
|
|
|
numeric_startup (ldfile, result, charset);
|
|
/* FALLTHROUGH */
|
|
|
|
case 31:
|
|
LOCALE_PROLOG (tok_lc_numeric, "LC_NUMERIC");
|
|
|
|
switch (nowtok)
|
|
{
|
|
case tok_decimal_point:
|
|
case tok_thousands_sep:
|
|
READ_STRING (numeric_add, bad_numeric);
|
|
break;
|
|
|
|
case tok_grouping:
|
|
/* We have a semicolon separated list of integers. */
|
|
READ_NUMBER_LIST (numeric_add, bad_numeric);
|
|
break;
|
|
|
|
default:
|
|
bad_numeric:
|
|
SYNTAX_ERROR (_("syntax error in numeric locale definition"));
|
|
}
|
|
continue;
|
|
|
|
case 40:
|
|
HANDLE_COPY (LC_TIME, tok_lc_time, "LC_TIME");
|
|
|
|
time_startup (ldfile, result, charset);
|
|
/* FALLTHROUGH */
|
|
|
|
case 41:
|
|
LOCALE_PROLOG (tok_lc_time, "LC_TIME");
|
|
|
|
switch (nowtok)
|
|
{
|
|
case tok_abday:
|
|
case tok_day:
|
|
case tok_abmon:
|
|
case tok_mon:
|
|
case tok_am_pm:
|
|
case tok_alt_digits:
|
|
READ_STRING_LIST (time_add, bad_time);
|
|
continue;
|
|
|
|
case tok_d_t_fmt:
|
|
case tok_d_fmt:
|
|
case tok_t_fmt:
|
|
case tok_t_fmt_ampm:
|
|
case tok_era:
|
|
case tok_era_year:
|
|
case tok_era_d_t_fmt:
|
|
case tok_era_d_fmt:
|
|
case tok_era_t_fmt:
|
|
READ_STRING (time_add, bad_time);
|
|
break;
|
|
|
|
default:
|
|
bad_time:
|
|
SYNTAX_ERROR (_("syntax error in time locale definition"));
|
|
}
|
|
continue;
|
|
|
|
case 50:
|
|
HANDLE_COPY (LC_MESSAGES, tok_lc_messages, "LC_MESSAGES");
|
|
|
|
messages_startup (ldfile, result, charset);
|
|
/* FALLTHROUGH */
|
|
|
|
case 51:
|
|
LOCALE_PROLOG (tok_lc_messages, "LC_MESSAGES");
|
|
|
|
switch (nowtok)
|
|
{
|
|
case tok_yesexpr:
|
|
case tok_noexpr:
|
|
case tok_yesstr:
|
|
case tok_nostr:
|
|
READ_STRING (messages_add, bad_message);
|
|
break;
|
|
|
|
default:
|
|
bad_message:
|
|
SYNTAX_ERROR (_("syntax error in message locale definition"));
|
|
}
|
|
continue;
|
|
|
|
default:
|
|
error (5, 0, _("%s: error in state machine"), __FILE__);
|
|
/* NOTREACHED */
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
/* We read all of the file. */
|
|
lr_close (ldfile);
|
|
|
|
/* Let's see what information is available. */
|
|
for (cnt = LC_CTYPE; cnt <= LC_MESSAGES; ++cnt)
|
|
if (result->categories[cnt].generic != NULL)
|
|
result->avail |= 1 << cnt;
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
void
|
|
check_all_categories (struct localedef_t *locale, struct charset_t *charset)
|
|
{
|
|
/* Call the finishing functions for all locales. */
|
|
if ((locale->binary & (1 << LC_CTYPE)) == 0)
|
|
ctype_finish (locale, charset);
|
|
if ((locale->binary & (1 << LC_COLLATE)) == 0)
|
|
collate_finish (locale, charset);
|
|
if ((locale->binary & (1 << LC_MONETARY)) == 0)
|
|
monetary_finish (locale);
|
|
if ((locale->binary & (1 << LC_NUMERIC)) == 0)
|
|
numeric_finish (locale);
|
|
if ((locale->binary & (1 << LC_TIME)) == 0)
|
|
time_finish (locale);
|
|
if ((locale->binary & (1 << LC_MESSAGES)) == 0)
|
|
messages_finish (locale);
|
|
}
|
|
|
|
|
|
void
|
|
write_all_categories (struct localedef_t *locale, struct charset_t *charset,
|
|
const char *output_path)
|
|
{
|
|
/* Call all functions to write locale data. */
|
|
ctype_output (locale, charset, output_path);
|
|
collate_output (locale, output_path);
|
|
monetary_output (locale, output_path);
|
|
numeric_output (locale, output_path);
|
|
time_output (locale, output_path);
|
|
messages_output (locale, output_path);
|
|
}
|
|
|
|
|
|
void
|
|
write_locale_data (const char *output_path, const char *category,
|
|
size_t n_elem, struct iovec *vec)
|
|
{
|
|
size_t cnt, step;
|
|
int fd;
|
|
char *fname;
|
|
|
|
asprintf (&fname, "%s/%s", output_path, category);
|
|
fd = creat (fname, 0666);
|
|
if (fd == -1)
|
|
{
|
|
int save_err = errno;
|
|
|
|
if (errno == EISDIR)
|
|
{
|
|
free (fname);
|
|
asprintf (&fname, "%1$s/%2$s/SYS_%2$s", output_path, category);
|
|
fd = creat (fname, 0666);
|
|
if (fd == -1)
|
|
save_err = errno;
|
|
}
|
|
|
|
if (fd == -1)
|
|
{
|
|
error (0, save_err, _("cannot open output file for category `%s'"),
|
|
category);
|
|
return;
|
|
}
|
|
}
|
|
free (fname);
|
|
|
|
/* Write the data using writev. But we must take care for the
|
|
limitation of the implementation. */
|
|
for (cnt = 0; cnt < n_elem; cnt += step)
|
|
{
|
|
/* XXX Fixme: should be in libc header. */
|
|
#ifndef MAX_IOVEC
|
|
# define MAX_IOVEC 8
|
|
#endif
|
|
step = MIN (MAX_IOVEC, n_elem - cnt);
|
|
|
|
if (writev (fd, &vec[cnt], step) < 0)
|
|
{
|
|
error (0, errno, _("failure while writing data for category `%s'"),
|
|
category);
|
|
break;
|
|
}
|
|
}
|
|
|
|
close (fd);
|
|
}
|