about summary refs log tree commit diff
path: root/locale/programs
diff options
context:
space:
mode:
Diffstat (limited to 'locale/programs')
-rw-r--r--locale/programs/charmap.c69
-rw-r--r--locale/programs/charset.h12
-rw-r--r--locale/programs/ld-ctype.c178
-rw-r--r--locale/programs/localedef.c4
-rw-r--r--locale/programs/locales.h129
-rw-r--r--locale/programs/locfile.c6
-rw-r--r--locale/programs/locfile.h2
7 files changed, 268 insertions, 132 deletions
diff --git a/locale/programs/charmap.c b/locale/programs/charmap.c
index 2b71821ec0..f938d798b8 100644
--- a/locale/programs/charmap.c
+++ b/locale/programs/charmap.c
@@ -47,7 +47,9 @@ void *xmalloc (size_t __n);
 
 /* Prototypes for local functions.  */
 static struct charset_t *parse_charmap (const char *filename);
-
+static void new_width (struct linereader *cmfile, struct charset_t *result,
+		       const char *from, const char *to,
+		       unsigned long int width);
 
 
 struct charset_t *
@@ -123,6 +125,8 @@ parse_charmap (const char *filename)
   /* Allocate room for result.  */
   result = (struct charset_t *) xmalloc (sizeof (struct charset_t));
   memset (result, '\0', sizeof (struct charset_t));
+  /* The default DEFAULT_WIDTH is 1.  */
+  result->width_default = 1;
 
 #define obstack_chunk_alloc xmalloc
 #define obstack_chunk_free free
@@ -399,6 +403,10 @@ argument to <%s> must be a single character"),
 
 	case 91:
 	  /* Waiting for WIDTH... */
+	  if (nowtok == tok_eol)
+	    /* Ignore empty lines.  */
+	    continue;
+
 	  if (nowtok == tok_width_default)
 	    {
 	      state = 92;
@@ -474,7 +482,10 @@ only WIDTH definitions are allowed to follow the CHARMAP definition"));
 
 	case 94:
 	  if (nowtok == tok_ellipsis)
-	    state = 95;
+	    {
+	      state = 95;
+	      continue;
+	    }
 
 	case 96:
 	  if (nowtok != tok_number)
@@ -482,8 +493,11 @@ only WIDTH definitions are allowed to follow the CHARMAP definition"));
 		      "WIDTH");
 	  else
 	    {
-	      /* XXX Store width for chars.  */
+	      /* Store width for chars.  */
+	      new_width (cmfile, result, from_name, to_name, now->val.num);
+
 	      from_name = NULL;
+	      to_name = NULL;
 	    }
 
 	  lr_ignore_rest (cmfile, nowtok == tok_number);
@@ -507,8 +521,6 @@ only WIDTH definitions are allowed to follow the CHARMAP definition"));
 					    now->val.str.start,
 					    now->val.str.len);
 
-	  lr_ignore_rest (cmfile, 1);
-
 	  state = 96;
 	  continue;
 
@@ -591,3 +603,50 @@ only WIDTH definitions are allowed to follow the CHARMAP definition"));
 
   return result;
 }
+
+
+static void
+new_width (struct linereader *cmfile, struct charset_t *result,
+	   const char *from, const char *to, unsigned long int width)
+{
+  unsigned int from_val, to_val;
+
+  from_val = charset_find_value (result, from, strlen (from));
+  if (from_val == ILLEGAL_CHAR_VALUE)
+    {
+      lr_error (cmfile, _("unknown character `%s'"), from);
+      return;
+    }
+
+  if (to == NULL)
+    to_val = from_val;
+  else
+    {
+      to_val = charset_find_value (result, to, strlen (to));
+      if (to_val == ILLEGAL_CHAR_VALUE)
+	{
+	  lr_error (cmfile, _("unknown character `%s'"), to);
+	  return;
+	}
+    }
+
+  if (result->nwidth_rules >= result->nwidth_rules_max)
+    {
+      size_t new_size = result->nwidth_rules + 32;
+      struct width_rule *new_rules =
+	(struct width_rule *) obstack_alloc (&result->mem_pool,
+					     (new_size
+					      * sizeof (struct width_rule)));
+
+      memcpy (new_rules, result->width_rules,
+	      result->nwidth_rules_max * sizeof (struct width_rule));
+
+      result->width_rules = new_rules;
+      result->nwidth_rules_max = new_size;
+    }
+
+  result->width_rules[result->nwidth_rules].from = from_val;
+  result->width_rules[result->nwidth_rules].to = to_val;
+  result->width_rules[result->nwidth_rules].width = (unsigned int) width;
+  ++result->nwidth_rules;
+}
diff --git a/locale/programs/charset.h b/locale/programs/charset.h
index 222d468407..1e8819c662 100644
--- a/locale/programs/charset.h
+++ b/locale/programs/charset.h
@@ -26,11 +26,23 @@ Boston, MA 02111-1307, USA.  */
 #include "linereader.h"
 
 
+struct width_rule
+{
+  unsigned int from;
+  unsigned int to;
+  unsigned int width;
+};
+
+
 struct charset_t
 {
   const char *code_set_name;
   int mb_cur_min;
   int mb_cur_max;
+
+  struct width_rule *width_rules;
+  size_t nwidth_rules;
+  size_t nwidth_rules_max;
   int width_default;
 
   struct obstack mem_pool;
diff --git a/locale/programs/ld-ctype.c b/locale/programs/ld-ctype.c
index c1cc8e53b8..99e9ebe3fa 100644
--- a/locale/programs/ld-ctype.c
+++ b/locale/programs/ld-ctype.c
@@ -107,6 +107,7 @@ struct locale_ctype_t
   u32_t **map_el;
   u32_t *class_name_ptr;
   u32_t *map_name_ptr;
+  unsigned char *width;
 };
 
 
@@ -120,7 +121,8 @@ static u32_t *find_idx (struct locale_ctype_t *ctype, u32_t **table,
 			size_t *max, size_t *act, unsigned int idx);
 static void set_class_defaults (struct locale_ctype_t *ctype,
 				struct charset_t *charset);
-static void allocate_arrays (struct locale_ctype_t *ctype);
+static void allocate_arrays (struct locale_ctype_t *ctype,
+			     struct charset_t *charset);
 
 
 void
@@ -321,20 +323,33 @@ character %s'%s' in class `%s' must not be in class `%s'"),
            valid_table[cnt].name);
   else
     ELEM (ctype, class_collection, , space_value) |= BIT (tok_print);
+
+  /* Now that the tests are done make sure the name array contains all
+     characters which are handled in the WIDTH section of the
+     character set definition file.  */
+  if (charset->width_rules != NULL)
+    for (cnt = 0; cnt < charset->nwidth_rules; ++cnt)
+      {
+	size_t inner;
+	for (inner = charset->width_rules[cnt].from;
+	     inner <= charset->width_rules[cnt].to; ++inner)
+	  (void) find_idx (ctype, NULL, NULL, NULL, inner);
+      }
 }
 
 
 void
-ctype_output (struct localedef_t *locale, const char *output_path)
+ctype_output (struct localedef_t *locale, struct charset_t *charset,
+	      const char *output_path)
 {
   struct locale_ctype_t *ctype = locale->categories[LC_CTYPE].ctype;
   const size_t nelems = (_NL_ITEM_INDEX (_NL_NUM_LC_CTYPE)
 			 + 2 * (ctype->map_collection_nr - 2));
-  struct iovec iov[2 + nelems + (ctype->nr_charclass + 1)
-		  + (ctype->map_collection_nr + 1)];
+  struct iovec iov[2 + nelems + ctype->nr_charclass
+		  + ctype->map_collection_nr];
   struct locale_file data;
   u32_t idx[nelems];
-  size_t elem, cnt, offset;
+  size_t elem, cnt, offset, total;
 
 
   if ((locale->binary & (1 << LC_CTYPE)) != 0)
@@ -349,7 +364,7 @@ ctype_output (struct localedef_t *locale, const char *output_path)
 
 
   /* Now prepare the output: Find the sizes of the table we can use.  */
-  allocate_arrays (ctype);
+  allocate_arrays (ctype, charset);
 
   data.magic = LIMAGIC (LC_CTYPE);
   data.n = nelems;
@@ -369,8 +384,10 @@ ctype_output (struct localedef_t *locale, const char *output_path)
 	  {
 #define CTYPE_DATA(name, base, len)					      \
 	  case _NL_ITEM_INDEX (name):					      \
-	    iov[2 + elem].iov_base = base;				      \
-	    iov[2 + elem].iov_len = len;				      \
+	    iov[2 + elem + offset].iov_base = base;			      \
+	    iov[2 + elem + offset].iov_len = len;			      \
+	    if (elem + 1 < nelems)					      \
+	      idx[elem + 1] = idx[elem] + iov[2 + elem + offset].iov_len;     \
 	    break
 
 	  CTYPE_DATA (_NL_CTYPE_CLASS,
@@ -412,15 +429,46 @@ ctype_output (struct localedef_t *locale, const char *output_path)
 	  CTYPE_DATA (_NL_CTYPE_HASH_LAYERS,
 		      &ctype->plane_cnt, sizeof (u32_t));
 
-	  CTYPE_DATA (_NL_CTYPE_CLASS_NAMES,
-		      ctype->class_name_ptr,
-		      ctype->nr_charclass * sizeof (u32_t));
-	  CTYPE_DATA (_NL_CTYPE_MAP_NAMES,
-		      ctype->map_name_ptr,
-		      ctype->map_collection_nr * sizeof (u32_t));
+	  case _NL_ITEM_INDEX (_NL_CTYPE_CLASS_NAMES):
+	    /* The class name array.  */
+	    total = 0;
+	    for (cnt = 0; cnt < ctype->nr_charclass; ++cnt, ++offset)
+	      {
+		iov[2 + elem + offset].iov_base
+		  = (void *) ctype->classnames[cnt];
+		iov[2 + elem + offset].iov_len
+		  = strlen (ctype->classnames[cnt]) + 1;
+		total += iov[2 + elem + offset].iov_len;
+	      }
+	    iov[2 + elem + offset].iov_base = (void *) "";
+	    iov[2 + elem + offset].iov_len = 1;
+	    ++total;
+
+	    if (elem + 1 < nelems)
+	      idx[elem + 1] = idx[elem] + total;
+	    break;
+
+	  case _NL_ITEM_INDEX (_NL_CTYPE_MAP_NAMES):
+	    /* The class name array.  */
+	    total = 0;
+	    for (cnt = 0; cnt < ctype->map_collection_nr; ++cnt, ++offset)
+	      {
+		iov[2 + elem + offset].iov_base
+		  = (void *) ctype->mapnames[cnt];
+		iov[2 + elem + offset].iov_len
+		  = strlen (ctype->mapnames[cnt]) + 1;
+		total += iov[2 + elem + offset].iov_len;
+	      }
+	    iov[2 + elem + offset].iov_base = (void *) "";
+	    iov[2 + elem + offset].iov_len = 1;
+	    ++total;
+
+	    if (elem + 1 < nelems)
+	      idx[elem + 1] = idx[elem] + total;
+	    break;
 
 	  CTYPE_DATA (_NL_CTYPE_WIDTH,
-		      NULL, 0);		/* Not yet implemented.  */
+		      ctype->width, ctype->plane_size * ctype->plane_cnt);
 
 	  default:
 	    assert (! "unknown CTYPE element");
@@ -431,49 +479,23 @@ ctype_output (struct localedef_t *locale, const char *output_path)
 	  size_t nr = (elem - _NL_ITEM_INDEX (_NL_NUM_LC_CTYPE)) >> 1;
 
 	  if (((elem - _NL_ITEM_INDEX (_NL_NUM_LC_CTYPE)) & 1) == 0)
-	    iov[2 + elem].iov_base = ctype->map_eb[nr];
+	    iov[2 + elem + offset].iov_base = ctype->map_eb[nr];
 	  else
-	    iov[2 + elem].iov_base = ctype->map_el[nr];
-
-	  iov[2 + elem].iov_len = ((ctype->plane_size * ctype->plane_cnt + 128)
-				   * sizeof (u32_t));
-	}
-
-      if (elem + 1 < nelems)
-	idx[elem + 1] = idx[elem] + iov[2 + elem].iov_len;
-    }
-
-  offset = idx[elem - 1] + iov[2 + elem - 1].iov_len;
-
-  /* The class name array.  */
-  for (cnt = 0; cnt < ctype->nr_charclass; ++cnt, ++elem)
-    {
-      iov[2 + elem].iov_base = (void *) ctype->classnames[cnt];
-      iov[2 + elem].iov_len = strlen (ctype->classnames[cnt]) + 1;
-
-      ctype->class_name_ptr[cnt] = offset;
-      offset += iov[2 + elem].iov_len;
-    }
-  iov[2 + elem].iov_base = (void *) "";
-  iov[2 + elem].iov_len = 1;
-  ++elem;
+	    iov[2 + elem + offset].iov_base = ctype->map_el[nr];
 
-  /* The map name array.  */
-  for (cnt = 0; cnt < ctype->map_collection_nr; ++cnt, ++elem)
-    {
-      iov[2 + elem].iov_base = (void *) ctype->mapnames[cnt];
-      iov[2 + elem].iov_len = strlen (ctype->mapnames[cnt]) + 1;
+	  iov[2 + elem + offset].iov_len = ((ctype->plane_size
+					     * ctype->plane_cnt + 128)
+					    * sizeof (u32_t));
 
-      ctype->map_name_ptr[cnt] = offset;
-      offset += iov[2 + elem].iov_len;
+	  if (elem + 1 < nelems)
+	    idx[elem + 1] = idx[elem] + iov[2 + elem + offset].iov_len;
+	}
     }
-  iov[2 + elem].iov_base = (void *) "";
-  iov[2 + elem].iov_len = 1;
-  ++elem;
 
-  assert (elem == nelems + ctype->nr_charclass + ctype->map_collection_nr + 2);
+  assert (2 + elem + offset == (nelems + ctype->nr_charclass
+				+ ctype->map_collection_nr + 2));
 
-  write_locale_data (output_path, "LC_CTYPE", 2 + elem, iov);
+  write_locale_data (output_path, "LC_CTYPE", 2 + elem + offset, iov);
 }
 
 
@@ -813,6 +835,8 @@ implementation limit: no more than %d character maps allowed"),
 }
 
 
+/* We have to be prepared that TABLE, MAX, and ACT can be NULL.  This
+   is possible if we only want ot extend the name array.  */
 static u32_t *
 find_idx (struct locale_ctype_t *ctype, u32_t **table, size_t *max,
 	  size_t *act, unsigned int idx)
@@ -820,7 +844,7 @@ find_idx (struct locale_ctype_t *ctype, u32_t **table, size_t *max,
   size_t cnt;
 
   if (idx < 256)
-    return &(*table)[idx];
+    return table == NULL ? NULL : &(*table)[idx];
 
   for (cnt = 256; cnt < ctype->charnames_act; ++cnt)
     if (ctype->charnames[cnt] == idx)
@@ -840,6 +864,10 @@ find_idx (struct locale_ctype_t *ctype, u32_t **table, size_t *max,
       ctype->charnames[ctype->charnames_act++] = idx;
     }
 
+  if (table == NULL)
+    /* We have done everything we are asked to do.  */
+    return NULL;
+
   if (cnt >= *act)
     {
       if (cnt >= *max)
@@ -1126,7 +1154,7 @@ character `%s' not defined while needed as default value"),
 
 
 static void
-allocate_arrays (struct locale_ctype_t *ctype)
+allocate_arrays (struct locale_ctype_t *ctype, struct charset_t *charset)
 {
   size_t idx;
 
@@ -1182,6 +1210,7 @@ Computing table size for character classes might take a while..."),
 
   fprintf (stderr, _(" done\n"));
 
+
 #if __BYTE_ORDER == __LITTLE_ENDIAN
 # define NAMES_B1 ctype->names_el
 # define NAMES_B2 ctype->names_eb
@@ -1246,8 +1275,9 @@ Computing table size for character classes might take a while..."),
       ctype->ctype_b[128 + ctype->charnames[idx]]
 	= TRANS (ctype->class_collection[idx]);
 
-  /* Mirror first 128 entries.  */
-  for (idx = 0; idx < 128; ++idx)
+  /* Mirror first 127 entries.  We must take care that entry -1 is not
+     mirrored because EOF == -1.  */
+  for (idx = 0; idx < 127; ++idx)
     ctype->ctype_b[idx] = ctype->ctype_b[256 + idx];
 
   /* The 32 bit array contains all characters.  */
@@ -1292,10 +1322,13 @@ Computing table size for character classes might take a while..."),
 	  MAP_B1[idx][128 + ctype->charnames[idx2]] =
 	    ctype->map_collection[idx][idx2];
 
-      /* Mirror first 128 entries.  */
-      for (idx2 = 0; idx2 < 128; ++idx2)
+      /* Mirror first 127 entries.  We must take care not to map entry
+	 -1 because EOF == -1.  */
+      for (idx2 = 0; idx2 < 127; ++idx2)
 	MAP_B1[idx][idx2] = MAP_B1[idx][256 + idx2];
 
+      /* EOF must map to EOF.  */
+      MAP_B1[idx][127] = EOF;
 
       /* And now the other byte order.  */
       for (idx2 = 0; idx2 < ctype->plane_size * ctype->plane_cnt + 128; ++idx2)
@@ -1307,4 +1340,33 @@ Computing table size for character classes might take a while..."),
 					     * sizeof (u32_t));
   ctype->map_name_ptr = (u32_t *) xmalloc (ctype->map_collection_nr
 					   * sizeof (u32_t));
+
+  /* Array for width information.  Because the expected width are very
+     small we use only one single byte.  This save space and we need
+     not provide the information twice with both endianesses.  */
+  ctype->width = (unsigned char *) xmalloc (ctype->plane_size
+					    * ctype->plane_cnt);
+  /* Initialize with default width value.  */
+  memset (ctype->width, charset->width_default,
+	  ctype->plane_size * ctype->plane_cnt);
+  if (charset->width_rules != NULL)
+    {
+      size_t cnt;
+
+      for (cnt = 0; cnt < charset->nwidth_rules; ++cnt)
+	if (charset->width_rules[cnt].width != charset->width_default)
+	  for (idx = charset->width_rules[cnt].from;
+	       idx <= charset->width_rules[cnt].to; ++idx)
+	    {
+	      size_t nr = idx % ctype->plane_size;
+	      size_t depth = 0;
+
+	      while (NAMES_B1[nr + depth * ctype->plane_size] != nr)
+		++depth;
+	      assert (depth < ctype->plane_cnt);
+
+	      ctype->width[nr + depth * ctype->plane_size]
+		= charset->width_rules[cnt].width;
+	    }
+    }
 }
diff --git a/locale/programs/localedef.c b/locale/programs/localedef.c
index a98bac4301..72eb2d36e2 100644
--- a/locale/programs/localedef.c
+++ b/locale/programs/localedef.c
@@ -231,7 +231,7 @@ main (int argc, char *argv[])
       for (act_add_locdef = copy_list; act_add_locdef != NULL;
 	   act_add_locdef = act_add_locdef->next)
 	{
-	  for (cat = LC_COLLATE; cat <= LC_MESSAGES; ++cat)
+	  for (cat = LC_CTYPE; cat <= LC_MESSAGES; ++cat)
 	    if ((act_add_locdef->mask & (1 << cat)) != 0)
 	      {
 		act_add_locdef->mask &= ~(1 << cat);
@@ -335,7 +335,7 @@ cannot `stat' locale file `%s'"),
 	error (4, cannot_write_why, _("cannot write output files to `%s'"),
 	       output_path);
       else
-	write_all_categories (localedef, output_path);
+	write_all_categories (localedef, charset, output_path);
     }
   else
     error (4, 0, _("no output file produced because warning were issued"));
diff --git a/locale/programs/locales.h b/locale/programs/locales.h
index 3c7676b765..a992642805 100644
--- a/locale/programs/locales.h
+++ b/locale/programs/locales.h
@@ -79,129 +79,130 @@ charclass_to_bit (enum token_t tok)
 
 /* Remember name of newly created charclass.  */
 void ctype_startup (struct linereader *lr, struct localedef_t *locale,
-		    struct charset_t *__charset);
-void ctype_finish (struct localedef_t *__locale, struct charset_t *__charset);
+		    struct charset_t *charset);
+void ctype_finish (struct localedef_t *locale, struct charset_t *charset);
 
-void ctype_output (struct localedef_t *locale, const char *output_path);
+void ctype_output (struct localedef_t *locale, struct charset_t *charset,
+		   const char *output_path);
 
 int ctype_is_charclass (struct linereader *lr, struct localedef_t *locale,
-			const char *__name);
+			const char *name);
 void ctype_class_new (struct linereader *lr, struct localedef_t *locale,
-		      enum token_t __tok, struct token *__code,
-		      struct charset_t *__charset);
+		      enum token_t tok, struct token *code,
+		      struct charset_t *charset);
 void ctype_class_start (struct linereader *lr, struct localedef_t *locale,
-			enum token_t __tok, const char *__name,
-			struct charset_t *__charset);
+			enum token_t tok, const char *name,
+			struct charset_t *charset);
 void ctype_class_from (struct linereader *lr, struct localedef_t *locale,
-		       struct token *__code, struct charset_t *__charset);
+		       struct token *code, struct charset_t *charset);
 void ctype_class_to (struct linereader *lr, struct localedef_t *locale,
-		     struct token *__code, struct charset_t *__charset);
+		     struct token *code, struct charset_t *charset);
 void ctype_class_end (struct linereader *lr, struct localedef_t *locale);
 
 int ctype_is_charmap (struct linereader *lr, struct localedef_t *locale,
-		      const char *__name);
+		      const char *name);
 void ctype_map_new (struct linereader *lr, struct localedef_t *locale,
-		    enum token_t __tok, struct token *__code,
-		    struct charset_t *__charset);
+		    enum token_t tok, struct token *code,
+		    struct charset_t *charset);
 void ctype_map_start (struct linereader *lr, struct localedef_t *locale,
-		      enum token_t __tok, const char *__name,
-		      struct charset_t *__charset);
+		      enum token_t tok, const char *name,
+		      struct charset_t *charset);
 void ctype_map_from (struct linereader *lr, struct localedef_t *locale,
-		     struct token *__code, struct charset_t *__charset);
+		     struct token *code, struct charset_t *charset);
 void ctype_map_to (struct linereader *lr, struct localedef_t *locale,
-		   struct token *__code, struct charset_t *__charset);
+		   struct token *code, struct charset_t *charset);
 void ctype_map_end (struct linereader *lr, struct localedef_t *locale);
 
 
 /* Handle LC_COLLATE category.  */
 
-void collate_startup (struct linereader *__lr, struct localedef_t *__locale,
-		      struct charset_t *__charset);
+void collate_startup (struct linereader *lr, struct localedef_t *locale,
+		      struct charset_t *charset);
 
-void collate_finish (struct localedef_t *__locale,
-		     struct charset_t *__charset);
+void collate_finish (struct localedef_t *locale,
+		     struct charset_t *charset);
 
 void collate_output (struct localedef_t *locale, const char *output_path);
 
-void collate_element_to (struct linereader *__lr, struct localedef_t *__locale,
-			 struct token *__code, struct charset_t *__charset);
-void collate_element_from (struct linereader *__lr,
-			   struct localedef_t *__locale, struct token *__code,
-			   struct charset_t *__charset);
-void collate_symbol (struct linereader *__lr, struct localedef_t *__locale,
-		     struct token *__code, struct charset_t *__charset);
-void collate_new_order (struct linereader *__lr, struct localedef_t *__locale,
-			enum coll_sort_rule __sort_rule);
-void collate_build_arrays (struct linereader *__lr,
-			   struct localedef_t *__locale);
-int collate_order_elem (struct linereader *__lr, struct localedef_t *__locale,
-			struct token *__code, struct charset_t *__charset);
-int collate_weight_bsymbol (struct linereader *__lr,
-			    struct localedef_t *__locale,
-			    struct token *__code, struct charset_t *__charset);
-int collate_next_weight (struct linereader *__lr,
-			 struct localedef_t *__locale);
-int collate_simple_weight (struct linereader *__lr,
-			   struct localedef_t *__locale,
-			   struct token *__code, struct charset_t *__charset);
-void collate_end_weight (struct linereader *__lr,
-			 struct localedef_t *__locale);
+void collate_element_to (struct linereader *lr, struct localedef_t *locale,
+			 struct token *code, struct charset_t *charset);
+void collate_element_from (struct linereader *lr,
+			   struct localedef_t *locale, struct token *code,
+			   struct charset_t *charset);
+void collate_symbol (struct linereader *lr, struct localedef_t *locale,
+		     struct token *code, struct charset_t *charset);
+void collate_new_order (struct linereader *lr, struct localedef_t *locale,
+			enum coll_sort_rule sort_rule);
+void collate_build_arrays (struct linereader *lr,
+			   struct localedef_t *locale);
+int collate_order_elem (struct linereader *lr, struct localedef_t *locale,
+			struct token *code, struct charset_t *charset);
+int collate_weight_bsymbol (struct linereader *lr,
+			    struct localedef_t *locale,
+			    struct token *code, struct charset_t *charset);
+int collate_next_weight (struct linereader *lr,
+			 struct localedef_t *locale);
+int collate_simple_weight (struct linereader *lr,
+			   struct localedef_t *locale,
+			   struct token *code, struct charset_t *charset);
+void collate_end_weight (struct linereader *lr,
+			 struct localedef_t *locale);
 
 
 /* Handle LC_MONETARY category.  */
 
-void monetary_startup (struct linereader *__lr, struct localedef_t *__locale,
-		       struct charset_t *__charset);
+void monetary_startup (struct linereader *lr, struct localedef_t *locale,
+		       struct charset_t *charset);
 
-void monetary_finish (struct localedef_t *__locale);
+void monetary_finish (struct localedef_t *locale);
 
 void monetary_output (struct localedef_t *locale, const char *output_path);
 
 void monetary_add (struct linereader *lr, struct localedef_t *locale,
-		   enum token_t __tok, struct token *__code,
-		   struct charset_t *__charset);
+		   enum token_t tok, struct token *code,
+		   struct charset_t *charset);
 
 
 /* Handle LC_NUMERIC category.  */
 
-void numeric_startup (struct linereader *__lr, struct localedef_t *__locale,
-		      struct charset_t *__charset);
+void numeric_startup (struct linereader *lr, struct localedef_t *locale,
+		      struct charset_t *charset);
 
-void numeric_finish (struct localedef_t *__locale);
+void numeric_finish (struct localedef_t *locale);
 
 void numeric_output (struct localedef_t *locale, const char *output_path);
 
 void numeric_add (struct linereader *lr, struct localedef_t *locale,
-		  enum token_t __tok, struct token *__code,
-		  struct charset_t *__charset);
+		  enum token_t tok, struct token *code,
+		  struct charset_t *charset);
 
 
 /* Handle LC_TIME category.  */
 
-void time_startup (struct linereader *__lr, struct localedef_t *__locale,
-		   struct charset_t *__charset);
+void time_startup (struct linereader *lr, struct localedef_t *locale,
+		   struct charset_t *charset);
 
-void time_finish (struct localedef_t *__locale);
+void time_finish (struct localedef_t *locale);
 
 void time_output (struct localedef_t *locale, const char *output_path);
 
 void time_add (struct linereader *lr, struct localedef_t *locale,
-	       enum token_t __tok, struct token *__code,
-	       struct charset_t *__charset);
+	       enum token_t tok, struct token *code,
+	       struct charset_t *charset);
 
 
 /* Handle LC_MESSAGES category.  */
 
-void messages_startup (struct linereader *__lr, struct localedef_t *__locale,
-		       struct charset_t *__charset);
+void messages_startup (struct linereader *lr, struct localedef_t *locale,
+		       struct charset_t *charset);
 
-void messages_finish (struct localedef_t *__locale);
+void messages_finish (struct localedef_t *locale);
 
 void messages_output (struct localedef_t *locale, const char *output_path);
 
 void messages_add (struct linereader *lr, struct localedef_t *locale,
-		   enum token_t __tok, struct token *__code,
-		   struct charset_t *__charset);
+		   enum token_t tok, struct token *code,
+		   struct charset_t *charset);
 
 
 #endif /* locales.h */
diff --git a/locale/programs/locfile.c b/locale/programs/locfile.c
index cb98a5d530..89dc6bb539 100644
--- a/locale/programs/locfile.c
+++ b/locale/programs/locfile.c
@@ -25,6 +25,7 @@ Boston, MA 02111-1307, USA.  */
 #include <fcntl.h>
 #include <locale.h>
 #include <malloc.h>
+#include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/stat.h>
@@ -913,10 +914,11 @@ check_all_categories (struct localedef_t *locale, struct charset_t *charset)
 
 
 void
-write_all_categories (struct localedef_t *locale, const char *output_path)
+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, output_path);
+  ctype_output (locale, charset, output_path);
   collate_output (locale, output_path);
   monetary_output (locale, output_path);
   numeric_output (locale, output_path);
diff --git a/locale/programs/locfile.h b/locale/programs/locfile.h
index e337e961ed..a0fe06b674 100644
--- a/locale/programs/locfile.h
+++ b/locale/programs/locfile.h
@@ -66,7 +66,7 @@ void check_all_categories (struct localedef_t *locale,
 			   struct charset_t *charset);
 
 void write_all_categories (struct localedef_t *locale,
-			   const char *output_path);
+			   struct charset_t *charset, const char *output_path);
 
 
 void write_locale_data (const char *output_path, const char *category,