Wed May 1 09:10:04 1996 Roland McGrath <roland@delasyd.gnu.ai.mit.edu>

	* 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.

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,