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.

1 files changed, 979 insertions, 0 deletions

diff --git a/locale/programs/locfile.c b/locale/programs/locfile.c
new file mode 100644
index 0000000000..cb98a5d530
--- /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);
+}