aboutsummaryrefslogtreecommitdiff
path: root/locale/programs/locfile.c
diff options
context:
space:
mode:
authorRoland McGrath <roland@gnu.org>1996-03-28 08:30:38 +0000
committerRoland McGrath <roland@gnu.org>1996-03-28 08:30:38 +0000
commit19bc17a90548ee427035994bbc4b14395723ff1f (patch)
treee7a17eda196c2610ca4be26c9e7985815162eafb /locale/programs/locfile.c
parent53f770e0f9d405ea8d1888254c6f7ce431b04c6e (diff)
downloadglibc-19bc17a90548ee427035994bbc4b14395723ff1f.zip
glibc-19bc17a90548ee427035994bbc4b14395723ff1f.tar.gz
glibc-19bc17a90548ee427035994bbc4b14395723ff1f.tar.bz2
Thu Mar 28 03:25:10 1996 Roland McGrath <roland@charlie-brown.gnu.ai.mit.edu>
* intl/Makefile (copysrc): Add missing > in sed cmd. Sat Mar 23 17:52:49 1996 Ulrich Drepper <drepper@gnu.ai.mit.edu> * Makeconfig: Rename Makefile variable nlsdir to i18ndir and change value to $(datadir)/i18n. `nls' is not an appropriate name. * Makefile (subdirs): Add new subdir wctype. * ctype/ctype-info.c: Add new global variable __ctype_names and initialize from _nl_C_LC_CTYPE. * ctype/ctype.h: In P1003.3b/D11 `alnum' is a separate character class. Use bit 11. [_ISbit]: Protect definition of bitmasks because they are also used in wctype.h. * libio/genops.c (_IO_sputbackc, _IO_sungetc): Clear EOF flag after successfully pushing back a character. Fundamental changes in locale implementation. Almost nothing from the old code is used anymore. * locale/charmap.c, locale/collate.c, locale/config.h, locale/ctypedump.c, locale/hash.h, locale/keyword.gperf, locale/keyword.h, locale/loadlocale.c, locale/locale-ctype.c, locale/locale.c locale/localeconv.c, locale/localedef.c, locale/localedef.h, locale/locfile-hash.c, locale/locfile-lex.c, locale/locfile-parse.c, locale/messages.c, locale/monetary.c, locale/numeric.c, locale/setlocale.c, locale/token.h, locale/xmalloc.c: Removed. * locale/Makefile: Update for new locale implementation with program source code distributed in subdir. * locale/categories.def, locale/iso-4217.def: Updated file for new locale implementation. * locale/langinfo.h: Updated for new locale implementation. (ERA_D_T_FMT, ERA_T_FMT): New official values according to P1003.2b/D11. (_NL_COLLATE_NRULES, _NL_COLLATE_RULES, _NL_COLLATE_HASH_SIZE, _NL_COLLATE_HASH_LAYERS, _NL_COLLATE_TABLE_EB, _NL_COLLATE_TABLE_EL, _NL_COLLATE_UNDEFINED, _NL_COLLATE_EXTRA_EB, _NL_COLLATE_EXTRA_EL, _NL_CTYPE_NAMES_EB, _NL_CTYPE_NAMES_EL, _NL_CTYPE_HASH_SIZE, _NL_CTYPE_HASH_LAYERS, _NL_CTYPE_CLASS_NAMES, _NL_CTYPE_MAP_NAMES, _NL_CTYPE_WIDTH): New internal values for extended LC_CTYPE and LC_COLLATE implementation. * locale/simple-hash.c, locale/simple-hash.h, locale/xmalloc.c, locale/xstrdup.c: Helper functions for locale related programs. * locale/C-collate.c, locale/C-ctype.c, locale/C-messages.c, locale/C-monetary.c, locale/C-numeric.c, locale/C-time.c, locale/lc-collate.c, locale/lc-ctype.c, locale/lc-messages.c, locale/lc-monetary.c, locale/lc-numeric.c, locale/lc-time.c: New implementation of locale functions, and new generated "C" locale data. * locale/loadlocale.c: Now handles word fields in locale binary automatically by changing the endianess if necessary. * locale/localeinfo.h (LIMAGIC): Changed magic number because of incompatible changes. (locale_data): Changed definition to allow word as a value type. (coll_sort_rule): Values for collation sorting mode. (_NL_CURRENT_WORD): New macro to access word value of locale entry. (__collate_table, __collate_extra): Declare new global variables for collation tables. * locale/programs/charmap-kw.gperf, locale/programs/charmap-kw.h, locale/programs/charmap.c, locale/programs/charset.c, locale/programs/charset.h, locale/programs/config.h, locale/programs/ctypedump.c, locale/programs/ld-collate.c, locale/programs/ld-ctype.c, locale/programs/ld-messages.c, locale/programs/ld-monetary.c, locale/programs/ld-numeric.c, locale/programs/ld-time.c, locale/programs/linereader.c, locale/programs/linereader.h, locale/programs/locale.c, locale/programs/localedef.c, locale/programs/locales.h, locale/programs/locfile-kw.gperf, locale/programs/locfile-kw.h, locale/programs/locfile-token.h, locale/programs/locfile.c, locale/programs/locfile.h, locale/programs/stringtrans.c, locale/programs/stringtrans.h: Implementation of locale related programs. * locale/weight.h: Functions to access collation tables. * posix/unistd.h: Define _POSIX2_LOCALEDEF. * stdio-common/printf_fp.c: Fix bug with printing certain numbers < 10^-1. Reported by Bill Metzenthen. * stdio-common/tfformat.c: Add new test for above bug. * string/strcoll.c, string/strxfrm.c: Real implementation of string collation according to ISO C. * wctype/Makefile, wctype/cname-lookup.h, wctype/iswctype.c, wctype/test_wctype.c, wctype/towctrans.c, wctype/wcfuncs.c, wctype/wctrans.c, wctype/wctype.c, wctype/wctype.h: New files. Implementation of wide character classes and mapping.
Diffstat (limited to 'locale/programs/locfile.c')
-rw-r--r--locale/programs/locfile.c979
1 files changed, 979 insertions, 0 deletions
diff --git a/locale/programs/locfile.c b/locale/programs/locfile.c
new file mode 100644
index 0000000..cb98a5d
--- /dev/null
+++ b/locale/programs/locfile.c
@@ -0,0 +1,979 @@
+/* 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 <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, const char *output_path)
+{
+ /* Call all functions to write locale data. */
+ ctype_output (locale, 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);
+}