devel/coreutils/coreutils-i18n.patch

diff -urN coreutils-6.12-orig/tests/misc/cut coreutils-6.12/tests/misc/cut
--- coreutils-6.12-orig/tests/misc/cut	2008-05-17 08:41:11.000000000 +0200
+++ coreutils-6.12/tests/misc/cut	2008-06-02 11:13:08.000000000 +0200
@@ -26,7 +26,7 @@
 my $prog = 'cut';
 my $try = "Try \`$prog --help' for more information.\n";
 my $from_1 = "$prog: fields and positions are numbered from 1\n$try";
-my $inval = "$prog: invalid byte or field list\n$try";
+my $inval = "$prog: invalid byte, character or field list\n$try";
 my $no_endpoint = "$prog: invalid range with no endpoint: -\n$try";
 
 my @Tests =
@@ -140,8 +140,8 @@
   ['od-overlap5', '-b1-3,1-4', '--output-d=:', {IN=>"abcde\n"}, {OUT=>"abcd\n"}],
 
   # None of the following invalid ranges provoked an error up to coreutils-6.9.
-  ['inval1', qw(-f 2-0), {IN=>''}, {OUT=>''}, {EXIT=>1},
-   {ERR=>"$prog: invalid decreasing range\n$try"}],
+  ['inval1', qw(-f 2-0), {IN=>''}, {OUT=>''}, {EXIT=>1},
+   {ERR=>"$prog: invalid byte, character or field list\n$try"}],
   ['inval2', qw(-f -), {IN=>''}, {OUT=>''}, {EXIT=>1}, {ERR=>$no_endpoint}],
   ['inval3', '-f', '4,-', {IN=>''}, {OUT=>''}, {EXIT=>1}, {ERR=>$no_endpoint}],
   ['inval4', '-f', '1-2,-', {IN=>''}, {OUT=>''}, {EXIT=>1}, {ERR=>$no_endpoint}],
--- /dev/null	2007-03-01 09:16:39.219409909 +0000
+++ coreutils-6.8+/tests/misc/sort-mb-tests	2007-03-01 15:08:24.000000000 +0000
@@ -0,0 +1,58 @@
+#! /bin/sh
+case $# in
+  0) xx='../src/sort';;
+  *) xx="$1";;
+esac
+test "$VERBOSE" && echo=echo || echo=:
+$echo testing program: $xx
+errors=0
+test "$srcdir" || srcdir=.
+test "$VERBOSE" && $xx --version 2> /dev/null
+
+export LC_ALL=en_US.UTF-8
+locale -k LC_CTYPE 2>&1 | grep -q charmap.*UTF-8 || exit 77
+errors=0
+
+$xx -t ＠ -k2 -n misc/mb1.I > misc/mb1.O
+code=$?
+if test $code != 0; then
+  $echo "Test mb1 failed: $xx return code $code differs from expected value 0" 1>&2
+  errors=`expr $errors + 1`
+else
+  cmp misc/mb1.O $srcdir/misc/mb1.X > /dev/null 2>&1
+  case $? in
+    0) if test "$VERBOSE"; then $echo "passed mb1"; fi;;
+    1) $echo "Test mb1 failed: files misc/mb1.O and $srcdir/misc/mb1.X differ" 1>&2
+       (diff -c misc/mb1.O $srcdir/misc/mb1.X) 2> /dev/null
+       errors=`expr $errors + 1`;;
+    2) $echo "Test mb1 may have failed." 1>&2
+       $echo The command "cmp misc/mb1.O $srcdir/misc/mb1.X" failed. 1>&2
+       errors=`expr $errors + 1`;;
+  esac
+fi
+
+$xx -t ＠ -k4 -n misc/mb2.I > misc/mb2.O
+code=$?
+if test $code != 0; then
+  $echo "Test mb2 failed: $xx return code $code differs from expected value 0" 1>&2
+  errors=`expr $errors + 1`
+else
+  cmp misc/mb2.O $srcdir/misc/mb2.X > /dev/null 2>&1
+  case $? in
+    0) if test "$VERBOSE"; then $echo "passed mb2"; fi;;
+    1) $echo "Test mb2 failed: files misc/mb2.O and $srcdir/misc/mb2.X differ" 1>&2
+       (diff -c misc/mb2.O $srcdir/misc/mb2.X) 2> /dev/null
+       errors=`expr $errors + 1`;;
+    2) $echo "Test mb2 may have failed." 1>&2
+       $echo The command "cmp misc/mb2.O $srcdir/misc/mb2.X" failed. 1>&2
+       errors=`expr $errors + 1`;;
+  esac
+fi
+
+if test $errors = 0; then
+  $echo Passed all 113 tests. 1>&2
+else
+  $echo Failed $errors tests. 1>&2
+fi
+test $errors = 0 || errors=1
+exit $errors
--- /dev/null	2007-03-01 09:16:39.219409909 +0000
+++ coreutils-6.8+/tests/misc/mb2.I	2007-03-01 15:08:24.000000000 +0000
@@ -0,0 +1,4 @@
+Apple＠ＡＡ10＠＠20
+Banana＠ＡＡ5＠＠30
+Citrus＠ＡＡ20＠＠5
+Cherry＠ＡＡ30＠＠10
--- /dev/null	2007-03-01 09:16:39.219409909 +0000
+++ coreutils-6.8+/tests/misc/mb2.X	2007-03-01 15:08:24.000000000 +0000
@@ -0,0 +1,4 @@
+Citrus＠ＡＡ20＠＠5
+Cherry＠ＡＡ30＠＠10
+Apple＠ＡＡ10＠＠20
+Banana＠ＡＡ5＠＠30
--- /dev/null	2007-03-01 09:16:39.219409909 +0000
+++ coreutils-6.8+/tests/misc/mb1.I	2007-03-01 15:08:24.000000000 +0000
@@ -0,0 +1,4 @@
+Apple＠10
+Banana＠5
+Citrus＠20
+Cherry＠30
--- /dev/null	2007-03-01 09:16:39.219409909 +0000
+++ coreutils-6.8+/tests/misc/mb1.X	2007-03-01 15:08:24.000000000 +0000
@@ -0,0 +1,4 @@
+Banana＠5
+Apple＠10
+Citrus＠20
+Cherry＠30
diff -urN coreutils-6.12-orig/tests/Makefile.am coreutils-6.12/tests/Makefile.am
--- coreutils-6.12-orig/tests/Makefile.am	2008-05-27 13:47:53.000000000 +0200
+++ coreutils-6.12/tests/Makefile.am	2008-06-02 10:06:03.000000000 +0200
@@ -192,6 +192,7 @@
   misc/sort-compress				\
   misc/sort-continue				\
   misc/sort-files0-from				\
+  misc/sort-mb-tests				\
   misc/sort-merge				\
   misc/sort-merge-fdlimit			\
   misc/sort-rand				\
@@ -391,6 +392,10 @@
   $(root_tests)
 
 pr_data =					\
+  misc/mb1.X			\
+  misc/mb1.I			\
+  misc/mb2.X			\
+  misc/mb2.I			\
   pr/0F						\
   pr/0FF					\
   pr/0FFnt					\
--- coreutils-6.8+/lib/linebuffer.h.i18n	2005-05-14 07:44:24.000000000 +0100
+++ coreutils-6.8+/lib/linebuffer.h	2007-03-01 15:08:24.000000000 +0000
@@ -22,6 +22,11 @@
 
 # include <stdio.h>
 
+/* Get mbstate_t.  */
+# if HAVE_WCHAR_H
+#  include <wchar.h>
+# endif
+
 /* A `struct linebuffer' holds a line of text. */
 
 struct linebuffer
@@ -29,6 +34,9 @@
   size_t size;			/* Allocated. */
   size_t length;		/* Used. */
   char *buffer;
+# if HAVE_WCHAR_H
+  mbstate_t state;
+# endif
 };
 
 /* Initialize linebuffer LINEBUFFER for use. */
--- coreutils-6.8+/src/expand.c.i18n	2007-01-14 15:41:28.000000000 +0000
+++ coreutils-6.8+/src/expand.c	2007-03-01 15:08:24.000000000 +0000
@@ -38,11 +38,28 @@
 #include <stdio.h>
 #include <getopt.h>
 #include <sys/types.h>
+
+/* Get mbstate_t, mbrtowc(), wcwidth(). */
+#if HAVE_WCHAR_H
+# include <wchar.h>
+#endif
+
 #include "system.h"
 #include "error.h"
 #include "quote.h"
 #include "xstrndup.h"
 
+/* MB_LEN_MAX is incorrectly defined to be 1 in at least one GCC
+   installation; work around this configuration error.  */
+#if !defined MB_LEN_MAX || MB_LEN_MAX < 2
+# define MB_LEN_MAX 16
+#endif
+
+/* Some systems, like BeOS, have multibyte encodings but lack mbstate_t.  */
+#if HAVE_MBRTOWC && defined mbstate_t
+# define mbrtowc(pwc, s, n, ps) (mbrtowc) (pwc, s, n, 0)
+#endif
+
 /* The official name of this program (e.g., no `g' prefix).  */
 #define PROGRAM_NAME "expand"
 
@@ -183,6 +200,7 @@
 	      stops = num_start + len - 1;
 	    }
 	}
+
       else
 	{
 	  error (0, 0, _("tab size contains invalid character(s): %s"),
@@ -365,6 +383,142 @@
     }
 }
 
+#if HAVE_MBRTOWC
+static void
+expand_multibyte (void)
+{
+  FILE *fp;			/* Input strem. */
+  mbstate_t i_state;		/* Current shift state of the input stream. */
+  mbstate_t i_state_bak;	/* Back up the I_STATE. */
+  mbstate_t o_state;		/* Current shift state of the output stream. */
+  char buf[MB_LEN_MAX + BUFSIZ];  /* For spooling a read byte sequence. */
+  char *bufpos;			/* Next read position of BUF. */
+  size_t buflen = 0;		/* The length of the byte sequence in buf. */
+  wchar_t wc;			/* A gotten wide character. */
+  size_t mblength;		/* The byte size of a multibyte character
+				   which shows as same character as WC. */
+  int tab_index = 0;		/* Index in `tab_list' of next tabstop. */
+  int column = 0;		/* Column on screen of the next char. */
+  int next_tab_column;		/* Column the next tab stop is on. */
+  int convert = 1;		/* If nonzero, perform translations. */
+
+  fp = next_file ((FILE *) NULL);
+  if (fp == NULL)
+    return;
+
+  memset (&o_state, '\0', sizeof(mbstate_t));
+  memset (&i_state, '\0', sizeof(mbstate_t));
+
+  for (;;)
+    {
+      /* Refill the buffer BUF. */
+      if (buflen < MB_LEN_MAX && !feof(fp) && !ferror(fp))
+	{
+	  memmove (buf, bufpos, buflen);
+	  buflen += fread (buf + buflen, sizeof(char), BUFSIZ, fp);
+	  bufpos = buf;
+	}
+
+      /* No character is left in BUF. */
+      if (buflen < 1)
+	{
+	  fp = next_file (fp);
+
+	  if (fp == NULL)
+	    break;		/* No more files. */
+	  else
+	    {
+	      memset (&i_state, '\0', sizeof(mbstate_t));
+	      continue;
+	    }
+	}
+
+      /* Get a wide character. */
+      i_state_bak = i_state;
+      mblength = mbrtowc (&wc, bufpos, buflen, &i_state);
+
+      switch (mblength)
+	{
+	case (size_t)-1:	/* illegal byte sequence. */
+	case (size_t)-2:
+	  mblength = 1;
+	  i_state = i_state_bak;
+	  if (convert)
+	    {
+	      ++column;
+	      if (convert_entire_line == 0)
+		convert = 0;
+	    }
+	  putchar (*bufpos);
+	  break;
+
+	case 0:		/* null. */
+	  mblength = 1;
+	  if (convert && convert_entire_line == 0)
+	    convert = 0;
+	  putchar ('\0');
+	  break;
+
+	default:
+	  if (wc == L'\n')   /* LF. */
+	    {
+	      tab_index = 0;
+	      column = 0;
+	      convert = 1;
+	      putchar ('\n');
+	    }
+	  else if (wc == L'\t' && convert)	/* Tab. */
+	    {
+	      if (tab_size == 0)
+		{
+		  /* Do not let tab_index == first_free_tab;
+		     stop when it is 1 less. */
+		  while (tab_index < first_free_tab - 1
+		      && column >= tab_list[tab_index])
+		    tab_index++;
+		  next_tab_column = tab_list[tab_index];
+		  if (tab_index < first_free_tab - 1)
+		    tab_index++;
+		  if (column >= next_tab_column)
+		    next_tab_column = column + 1;
+		}
+	      else
+		next_tab_column = column + tab_size - column % tab_size;
+
+	      while (column < next_tab_column)
+		{
+		  putchar (' ');
+		  ++column;
+		}
+	    }
+	  else  /* Others. */
+	    {
+	      if (convert)
+		{
+		  if (wc == L'\b')
+		    {
+		      if (column > 0)
+			--column;
+		    }
+		  else
+		    {
+		      int width;		/* The width of WC. */
+
+		      width = wcwidth (wc);
+		      column += (width > 0) ? width : 0;
+		      if (convert_entire_line == 0)
+			convert = 0;
+		    }
+		}
+	      fwrite (bufpos, sizeof(char), mblength, stdout);
+	    }
+	}
+      buflen -= mblength;
+      bufpos += mblength;
+    }
+}
+#endif
+
 int
 main (int argc, char **argv)
 {
@@ -429,7 +583,12 @@
 
   file_list = (optind < argc ? &argv[optind] : stdin_argv);
 
-  expand ();
+#if HAVE_MBRTOWC
+  if (MB_CUR_MAX > 1)
+    expand_multibyte ();
+  else
+#endif
+    expand ();
 
   if (have_read_stdin && fclose (stdin) != 0)
     error (EXIT_FAILURE, errno, "-");
--- coreutils-6.8+/src/join.c.i18n	2007-01-14 15:41:28.000000000 +0000
+++ coreutils-6.8+/src/join.c	2007-03-01 15:08:24.000000000 +0000
@@ -23,16 +23,30 @@
 #include <sys/types.h>
 #include <getopt.h>
 
+/* Get mbstate_t, mbrtowc(), mbrtowc(), wcwidth().  */
+#if HAVE_WCHAR_H
+# include <wchar.h>
+#endif
+
+/* Get iswblank(), towupper.  */
+#if HAVE_WCTYPE_H
+# include <wctype.h>
+#endif
+
 #include "system.h"
 #include "error.h"
 #include "linebuffer.h"
-#include "memcasecmp.h"
 #include "quote.h"
 #include "stdio--.h"
 #include "xmemcoll.h"
 #include "xstrtol.h"
 #include "argmatch.h"
 
+/* Some systems, like BeOS, have multibyte encodings but lack mbstate_t.  */
+#if HAVE_MBRTOWC && defined mbstate_t
+# define mbrtowc(pwc, s, n, ps) (mbrtowc) (pwc, s, n, 0)
+#endif
+
 /* The official name of this program (e.g., no `g' prefix).  */
 #define PROGRAM_NAME "join"
 
@@ -104,10 +118,12 @@
 /* Last element in `outlist', where a new element can be added.  */
 static struct outlist *outlist_end = &outlist_head;
 
-/* Tab character separating fields.  If negative, fields are separated
-   by any nonempty string of blanks, otherwise by exactly one
-   tab character whose value (when cast to unsigned char) equals TAB.  */
-static int tab = -1;
+/* Tab character separating fields.  If NULL, fields are separated
+   by any nonempty string of blanks.  */
+static char *tab = NULL;
+
+/* The number of bytes used for tab. */
+static size_t tablen = 0;
 
 /* If nonzero, check that the input is correctly ordered. */
 static enum
@@ -199,10 +217,11 @@
   if (ptr == lim)
     return;
 
-  if (0 <= tab)
+  if (tab != NULL)
     {
+      unsigned char t = tab[0];
       char *sep;
-      for (; (sep = memchr (ptr, tab, lim - ptr)) != NULL; ptr = sep + 1)
+      for (; (sep = memchr (ptr, t, lim - ptr)) != NULL; ptr = sep + 1)
 	extract_field (line, ptr, sep - ptr);
     }
   else
@@ -229,6 +248,148 @@
   extract_field (line, ptr, lim - ptr);
 }
 
+#if HAVE_MBRTOWC
+static void
+xfields_multibyte (struct line *line)
+{
+  char *ptr = line->buf.buffer;
+  char const *lim = ptr + line->buf.length - 1;
+  wchar_t wc = 0;
+  size_t mblength = 1;
+  mbstate_t state, state_bak;
+
+  memset (&state, 0, sizeof (mbstate_t));
+
+  if (ptr >= lim)
+    return;
+
+  if (tab != NULL)
+    {
+      unsigned char t = tab[0];
+      char *sep = ptr;
+      for (; ptr < lim; ptr = sep + mblength)
+	{
+	  sep = ptr;
+	  while (sep < lim)
+	    {
+	      state_bak = state;
+	      mblength = mbrtowc (&wc, sep, lim - sep + 1, &state);
+
+	      if (mblength == (size_t)-1 || mblength == (size_t)-2)
+		{
+		  mblength = 1;
+		  state = state_bak;
+		}
+	      mblength = (mblength < 1) ? 1 : mblength;
+
+	      if (mblength == tablen && !memcmp (sep, tab, mblength))
+		break;
+	      else
+		{
+		  sep += mblength;
+		  continue;
+		}
+	    }
+
+	  if (sep >= lim)
+	    break;
+
+	  extract_field (line, ptr, sep - ptr);
+	}
+    }
+  else
+    {
+      /* Skip leading blanks before the first field.  */
+      while(ptr < lim)
+      {
+        state_bak = state;
+        mblength = mbrtowc (&wc, ptr, lim - ptr + 1, &state);
+
+        if (mblength == (size_t)-1 || mblength == (size_t)-2)
+          {
+            mblength = 1;
+            state = state_bak;
+            break;
+          }
+        mblength = (mblength < 1) ? 1 : mblength;
+
+        if (!iswblank(wc))
+          break;
+        ptr += mblength;
+      }
+
+      do
+	{
+	  char *sep;
+	  state_bak = state;
+	  mblength = mbrtowc (&wc, ptr, lim - ptr + 1, &state);
+	  if (mblength == (size_t)-1 || mblength == (size_t)-2)
+	    {
+	      mblength = 1;
+	      state = state_bak;
+	      break;
+	    }
+	  mblength = (mblength < 1) ? 1 : mblength;
+
+	  sep = ptr + mblength;
+	  while (sep < lim)
+	    {
+	      state_bak = state;
+	      mblength = mbrtowc (&wc, sep, lim - sep + 1, &state);
+	      if (mblength == (size_t)-1 || mblength == (size_t)-2)
+		{
+		  mblength = 1;
+		  state = state_bak;
+		  break;
+		}
+	      mblength = (mblength < 1) ? 1 : mblength;
+
+	      if (iswblank (wc))
+		break;
+
+	      sep += mblength;
+	    }
+
+	  extract_field (line, ptr, sep - ptr);
+	  if (sep >= lim)
+	    return;
+
+	  state_bak = state;
+	  mblength = mbrtowc (&wc, sep, lim - sep + 1, &state);
+	  if (mblength == (size_t)-1 || mblength == (size_t)-2)
+	    {
+	      mblength = 1;
+	      state = state_bak;
+	      break;
+	    }
+	  mblength = (mblength < 1) ? 1 : mblength;
+
+	  ptr = sep + mblength;
+	  while (ptr < lim)
+	    {
+	      state_bak = state;
+	      mblength = mbrtowc (&wc, ptr, lim - ptr + 1, &state);
+	      if (mblength == (size_t)-1 || mblength == (size_t)-2)
+		{
+		  mblength = 1;
+		  state = state_bak;
+		  break;
+		}
+	      mblength = (mblength < 1) ? 1 : mblength;
+
+	      if (!iswblank (wc))
+		break;
+
+	      ptr += mblength;
+	    }
+	}
+      while (ptr < lim);
+    }
+
+  extract_field (line, ptr, lim - ptr);
+}
+#endif
+ 
 static void
 freeline (struct line *line)
 {
@@ -377,11 +601,18 @@
 
 /* Print the join of LINE1 and LINE2.  */
 
+#define PUT_TAB_CHAR							\
+  do									\
+    {									\
+      (tab != NULL) ?							\
+	fwrite(tab, sizeof(char), tablen, stdout) : putchar (' ');	\
+    }									\
+  while (0)								
+
 static void
 prjoin (struct line const *line1, struct line const *line2)
 {
   const struct outlist *outlist;
-  char output_separator = tab < 0 ? ' ' : tab;
 
   outlist = outlist_head.next;
   if (outlist)
@@ -397,12 +628,12 @@
 	  if (o->file == 0)
 	    {
 	      if (line1 == &uni_blank)
-	        {
+		{
 		  line = line2;
 		  field = join_field_2;
 		}
 	      else
-	        {
+		{
 		  line = line1;
 		  field = join_field_1;
 		}
@@ -416,7 +647,7 @@
 	  o = o->next;
 	  if (o == NULL)
 	    break;
-	  putchar (output_separator);
+	  PUT_TAB_CHAR;
 	}
       putchar ('\n');
     }
@@ -434,23 +665,23 @@
       prfield (join_field_1, line1);
       for (i = 0; i < join_field_1 && i < line1->nfields; ++i)
 	{
-	  putchar (output_separator);
+	  PUT_TAB_CHAR;
 	  prfield (i, line1);
 	}
       for (i = join_field_1 + 1; i < line1->nfields; ++i)
 	{
-	  putchar (output_separator);
+	  PUT_TAB_CHAR;
 	  prfield (i, line1);
 	}
 
       for (i = 0; i < join_field_2 && i < line2->nfields; ++i)
 	{
-	  putchar (output_separator);
+	  PUT_TAB_CHAR;
 	  prfield (i, line2);
 	}
       for (i = join_field_2 + 1; i < line2->nfields; ++i)
 	{
-	  putchar (output_separator);
+	  PUT_TAB_CHAR;
 	  prfield (i, line2);
 	}
       putchar ('\n');
@@ -859,20 +1090,41 @@
 
 	case 't':
 	  {
-	    unsigned char newtab = optarg[0];
-	    if (! newtab)
+	    char *newtab;
+	    size_t newtablen;
+	    if (! optarg[0])
 	      error (EXIT_FAILURE, 0, _("empty tab"));
-	    if (optarg[1])
+	    newtab = xstrdup (optarg);
+#if HAVE_MBRTOWC
+	    if (MB_CUR_MAX > 1)
+	      {
+		mbstate_t state;
+
+		memset (&state, 0, sizeof (mbstate_t));
+		newtablen = mbrtowc (NULL, newtab,
+				     strnlen (newtab, MB_LEN_MAX),
+				     &state);
+		if (newtablen == (size_t) 0
+		    || newtablen == (size_t) -1
+		    || newtablen == (size_t) -2)
+		  newtablen = 1;
+	      }
+	    else
+#endif
+	      newtablen = 1;
+		
+	    if (newtablen == 1 && newtab[1])
+	      {
+		if (STREQ (newtab, "\\0"))
+		  newtab[0] = '\0';
+	      }
+	    if (tab != NULL && strcmp (tab, newtab))
 	      {
-		if (STREQ (optarg, "\\0"))
-		  newtab = '\0';
-		else
-		  error (EXIT_FAILURE, 0, _("multi-character tab %s"),
-			 quote (optarg));
+		free (newtab);
+		error (EXIT_FAILURE, 0, _("incompatible tabs"));
 	      }
-	    if (0 <= tab && tab != newtab)
-	      error (EXIT_FAILURE, 0, _("incompatible tabs"));
 	    tab = newtab;
+	    tablen = newtablen;
 	  }
 	  break;

diff -urNp coreutils-6.11-orig/src/join.c coreutils-6.11/src/join.c
--- coreutils-6.11-orig/src/join.c	2008-04-21 13:44:32.000000000 +0200
+++ coreutils-6.11/src/join.c	2008-04-21 14:03:22.000000000 +0200
@@ -324,56 +324,115 @@ keycmp (struct line const *line1, struct
 	size_t jf_1, size_t jf_2)
 {
   /* Start of field to compare in each file.  */
-  char *beg1;
-  char *beg2;
-
-  size_t len1;
-  size_t len2;		/* Length of fields to compare.  */
+  char *beg[2];
+  char *copy[2];
+  size_t len[2]; 	/* Length of fields to compare.  */
   int diff;
+  int i, j;
 
   if (jf_1 < line1->nfields)
     {
-      beg1 = line1->fields[jf_1].beg;
-      len1 = line1->fields[jf_1].len;
+      beg[0] = line1->fields[jf_1].beg;
+      len[0] = line1->fields[jf_1].len;
     }
   else
     {
-      beg1 = NULL;
-      len1 = 0;
+      beg[0] = NULL;
+      len[0] = 0;
     }
 
   if (jf_2 < line2->nfields)
     {
-      beg2 = line2->fields[jf_2].beg;
-      len2 = line2->fields[jf_2].len;
+      beg[1] = line2->fields[jf_2].beg;
+      len[1] = line2->fields[jf_2].len;
     }
   else
     {
-      beg2 = NULL;
-      len2 = 0;
+      beg[1] = NULL;
+      len[1] = 0;
     }
 
-  if (len1 == 0)
-    return len2 == 0 ? 0 : -1;
-  if (len2 == 0)
+  if (len[0] == 0)
+    return len[1] == 0 ? 0 : -1;
+  if (len[1] == 0)
     return 1;
 
   if (ignore_case)
     {
-      /* FIXME: ignore_case does not work with NLS (in particular,
-         with multibyte chars).  */
-      diff = memcasecmp (beg1, beg2, MIN (len1, len2));
+#ifdef HAVE_MBRTOWC
+      if (MB_CUR_MAX > 1)
+      {
+        size_t mblength;
+        wchar_t wc, uwc;
+        mbstate_t state, state_bak;
+
+        memset (&state, '\0', sizeof (mbstate_t));
+
+        for (i = 0; i < 2; i++)
+          {
+            copy[i] = alloca (len[i] + 1);
+
+            for (j = 0; j < MIN (len[0], len[1]);)
+              {
+                state_bak = state;
+                mblength = mbrtowc (&wc, beg[i] + j, len[i] - j, &state);
+
+                switch (mblength)
+                  {
+                  case (size_t) -1:
+                  case (size_t) -2:
+                    state = state_bak;
+                    /* Fall through */
+                  case 0:
+                    mblength = 1;
+                    break;
+
+                  default:
+                    uwc = towupper (wc);
+
+                    if (uwc != wc)
+                      {
+                        mbstate_t state_wc;
+
+                        memset (&state_wc, '\0', sizeof (mbstate_t));
+                        wcrtomb (copy[i] + j, uwc, &state_wc);
+                      }
+                    else
+                      memcpy (copy[i] + j, beg[i] + j, mblength);
+                  }
+                j += mblength;
+              }
+            copy[i][j] = '\0';
+          }
+      }
+      else
+#endif
+      {
+        for (i = 0; i < 2; i++)
+          {
+            copy[i] = alloca (len[i] + 1);
+
+            for (j = 0; j < MIN (len[0], len[1]); j++)
+              copy[i][j] = toupper (beg[i][j]);
+
+            copy[i][j] = '\0';
+          }
+      }
     }
   else
     {
-      if (hard_LC_COLLATE)
-	return xmemcoll (beg1, len1, beg2, len2);
-      diff = memcmp (beg1, beg2, MIN (len1, len2));
+      copy[0] = (unsigned char *) beg[0];
+      copy[1] = (unsigned char *) beg[1];  
     }
 
+  if (hard_LC_COLLATE)
+    return xmemcoll ((char *) copy[0], len[0], (char *) copy[1], len[1]);
+  diff = memcmp (copy[0], copy[1], MIN (len[0], len[1]));
+
+
   if (diff)
     return diff;
-  return len1 < len2 ? -1 : len1 != len2;
+  return len[0] - len[1];
 }
 
 /* Check that successive input lines PREV and CURRENT from input file
--- coreutils-6.8+/src/uniq.c.i18n	2007-01-14 15:41:28.000000000 +0000
+++ coreutils-6.8+/src/uniq.c	2007-03-01 15:08:24.000000000 +0000
@@ -23,6 +23,16 @@
 #include <getopt.h>
 #include <sys/types.h>
 
+/* Get mbstate_t, mbrtowc(). */
+#if HAVE_WCHAR_H
+# include <wchar.h>
+#endif
+
+/* Get isw* functions. */
+#if HAVE_WCTYPE_H
+# include <wctype.h>
+#endif
+
 #include "system.h"
 #include "argmatch.h"
 #include "linebuffer.h"
@@ -32,7 +42,19 @@
 #include "quote.h"
 #include "xmemcoll.h"
 #include "xstrtol.h"
-#include "memcasecmp.h"
+#include "xmemcoll.h"
+
+/* MB_LEN_MAX is incorrectly defined to be 1 in at least one GCC
+   installation; work around this configuration error.  */
+#if !defined MB_LEN_MAX || MB_LEN_MAX < 2
+# define MB_LEN_MAX 16
+#endif
+
+/* Some systems, like BeOS, have multibyte encodings but lack mbstate_t.  */
+#if HAVE_MBRTOWC && defined mbstate_t
+# define mbrtowc(pwc, s, n, ps) (mbrtowc) (pwc, s, n, 0)
+#endif
+
 
 /* The official name of this program (e.g., no `g' prefix).  */
 #define PROGRAM_NAME "uniq"
@@ -109,6 +131,10 @@
 /* Select whether/how to delimit groups of duplicate lines.  */
 static enum delimit_method delimit_groups;
 
+/* Function pointers. */
+static char *
+(*find_field) (struct linebuffer *line);
+
 static struct option const longopts[] =
 {
   {"count", no_argument, NULL, 'c'},
@@ -198,7 +224,7 @@
    return a pointer to the beginning of the line's field to be compared. */
 
 static char *
-find_field (struct linebuffer const *line)
+find_field_uni (struct linebuffer *line)
 {
   size_t count;
   char const *lp = line->buffer;
@@ -219,6 +245,83 @@
   return line->buffer + i;
 }
 
+#if HAVE_MBRTOWC
+
+# define MBCHAR_TO_WCHAR(WC, MBLENGTH, LP, POS, SIZE, STATEP, CONVFAIL)  \
+  do									\
+    {									\
+      mbstate_t state_bak;						\
+									\
+      CONVFAIL = 0;							\
+      state_bak = *STATEP;						\
+									\
+      MBLENGTH = mbrtowc (&WC, LP + POS, SIZE - POS, STATEP);		\
+									\
+      switch (MBLENGTH)							\
+	{								\
+	case (size_t)-2:						\
+	case (size_t)-1:						\
+	  *STATEP = state_bak;						\
+	  CONVFAIL++;							\
+	  /* Fall through */						\
+	case 0:								\
+	  MBLENGTH = 1;							\
+	}								\
+    }									\
+  while (0)
+
+static char *
+find_field_multi (struct linebuffer *line)
+{
+  size_t count;
+  char *lp = line->buffer;
+  size_t size = line->length - 1;
+  size_t pos;
+  size_t mblength;
+  wchar_t wc;
+  mbstate_t *statep;
+  int convfail;
+
+  pos = 0;
+  statep = &(line->state);
+
+  /* skip fields. */
+  for (count = 0; count < skip_fields && pos < size; count++)
+    {
+      while (pos < size)
+	{
+	  MBCHAR_TO_WCHAR (wc, mblength, lp, pos, size, statep, convfail);
+ 
+	  if (convfail || !iswblank (wc))
+	    {
+	      pos += mblength;
+	      break;
+	    }
+	  pos += mblength;
+	}
+
+      while (pos < size)
+	{
+	  MBCHAR_TO_WCHAR (wc, mblength, lp, pos, size, statep, convfail);
+
+	  if (!convfail && iswblank (wc))
+	    break;
+
+	  pos += mblength;
+	}
+    }
+
+  /* skip fields. */
+  for (count = 0; count < skip_chars && pos < size; count++)
+    {
+      MBCHAR_TO_WCHAR (wc, mblength, lp, pos, size, statep, convfail);
+      pos += mblength;
+    }
+
+  return lp + pos;
+}
+#endif
+
 /* Return false if two strings OLD and NEW match, true if not.
    OLD and NEW point not to the beginnings of the lines
    but rather to the beginnings of the fields to compare.
@@ -227,6 +330,8 @@
 static bool
 different (char *old, char *new, size_t oldlen, size_t newlen)
 {
+  char *copy_old, *copy_new;
+
   if (check_chars < oldlen)
     oldlen = check_chars;
   if (check_chars < newlen)
@@ -234,14 +339,92 @@
 
   if (ignore_case)
     {
-      /* FIXME: This should invoke strcoll somehow.  */
-      return oldlen != newlen || memcasecmp (old, new, oldlen);
+      size_t i;
+
+      copy_old = alloca (oldlen + 1);
+      copy_new = alloca (oldlen + 1);
+
+      for (i = 0; i < oldlen; i++)
+	{
+	  copy_old[i] = toupper (old[i]);
+	  copy_new[i] = toupper (new[i]);
+	}
     }
-  else if (hard_LC_COLLATE)
-    return xmemcoll (old, oldlen, new, newlen) != 0;
   else
-    return oldlen != newlen || memcmp (old, new, oldlen);
+    {
+      copy_old = (char *)old;
+      copy_new = (char *)new;
+    }
+
+  return xmemcoll (copy_old, oldlen, copy_new, newlen);
+}
+
+#if HAVE_MBRTOWC
+static int
+different_multi (const char *old, const char *new, size_t oldlen, size_t newlen, mbstate_t oldstate, mbstate_t newstate)
+{
+  size_t i, j, chars;
+  const char *str[2];
+  char *copy[2];
+  size_t len[2];
+  mbstate_t state[2];
+  size_t mblength;
+  wchar_t wc, uwc;
+  mbstate_t state_bak;
+
+  str[0] = old;
+  str[1] = new;
+  len[0] = oldlen;
+  len[1] = newlen;
+  state[0] = oldstate;
+  state[1] = newstate;
+
+  for (i = 0; i < 2; i++)
+    {
+      copy[i] = alloca (len[i] + 1);
+
+      for (j = 0, chars = 0; j < len[i] && chars < check_chars; chars++)
+	{
+	  state_bak = state[i];
+	  mblength = mbrtowc (&wc, str[i] + j, len[i] - j, &(state[i]));
+
+	  switch (mblength)
+	    {
+	    case (size_t)-1:
+	    case (size_t)-2:
+	      state[i] = state_bak;
+	      /* Fall through */
+	    case 0:
+	      mblength = 1;
+	      break;
+
+	    default:
+	      if (ignore_case)
+		{
+		  uwc = towupper (wc);
+
+		  if (uwc != wc)
+		    {
+		      mbstate_t state_wc;
+
+		      memset (&state_wc, '\0', sizeof(mbstate_t));
+		      wcrtomb (copy[i] + j, uwc, &state_wc);
+		    }
+		  else
+		    memcpy (copy[i] + j, str[i] + j, mblength);
+		}
+	      else
+		memcpy (copy[i] + j, str[i] + j, mblength);
+	    }
+	  j += mblength;
+	}
+      copy[i][j] = '\0';
+      len[i] = j;
+    }
+
+  return xmemcoll (copy[0], len[0], copy[1], len[1]);
 }
+#endif
 
 /* Output the line in linebuffer LINE to standard output
    provided that the switches say it should be output.
@@ -295,15 +478,43 @@
     {
       char *prevfield IF_LINT (= NULL);
       size_t prevlen IF_LINT (= 0);
+#if HAVE_MBRTOWC
+      mbstate_t prevstate;
+
+      memset (&prevstate, '\0', sizeof (mbstate_t));
+#endif
 
       while (!feof (stdin))
 	{
 	  char *thisfield;
 	  size_t thislen;
+#if HAVE_MBRTOWC
+	  mbstate_t thisstate;
+#endif
+
 	  if (readlinebuffer_delim (thisline, stdin, delimiter) == 0)
 	    break;
 	  thisfield = find_field (thisline);
 	  thislen = thisline->length - 1 - (thisfield - thisline->buffer);
+#if HAVE_MBRTOWC
+	  if (MB_CUR_MAX > 1)
+            {
+            thisstate = thisline->state;
+
+            if (prevline->length == 0 || different_multi
+              (thisfield, prevfield, thislen, prevlen, thisstate, prevstate))
+              {
+                fwrite (thisline->buffer, sizeof (char),
+                        thisline->length, stdout);
+
+                SWAP_LINES (prevline, thisline);
+                prevfield = thisfield;
+                prevlen = thislen;
+                prevstate = thisstate;
+              }
+          }
+	else
+#endif
 	  if (prevline->length == 0
 	      || different (thisfield, prevfield, thislen, prevlen))
 	    {
@@ -322,17 +533,26 @@
       size_t prevlen;
       uintmax_t match_count = 0;
       bool first_delimiter = true;
+#if HAVE_MBRTOWC
+      mbstate_t prevstate;
+#endif
 
       if (readlinebuffer_delim (prevline, stdin, delimiter) == 0)
 	goto closefiles;
       prevfield = find_field (prevline);
       prevlen = prevline->length - 1 - (prevfield - prevline->buffer);
+#if HAVE_MBRTOWC
+      prevstate = prevline->state;
+#endif
 
       while (!feof (stdin))
 	{
 	  bool match;
 	  char *thisfield;
 	  size_t thislen;
+#if HAVE_MBRTOWC
+	  mbstate_t thisstate;
+#endif
 	  if (readlinebuffer_delim (thisline, stdin, delimiter) == 0)
 	    {
 	      if (ferror (stdin))
@@ -341,6 +561,15 @@
 	    }
 	  thisfield = find_field (thisline);
 	  thislen = thisline->length - 1 - (thisfield - thisline->buffer);
+#if HAVE_MBRTOWC
+	  if (MB_CUR_MAX > 1)
+	    {
+              thisstate = thisline->state;
+              match = !different_multi (thisfield, prevfield,
+                                thislen, prevlen, thisstate, prevstate);
+            }
+	  else
+#endif
 	  match = !different (thisfield, prevfield, thislen, prevlen);
 	  match_count += match;
 
@@ -373,6 +602,9 @@
 	      SWAP_LINES (prevline, thisline);
 	      prevfield = thisfield;
 	      prevlen = thislen;
+#if HAVE_MBRTOWC
+	      prevstate = thisstate;
+#endif
 	      if (!match)
 		match_count = 0;
 	    }
@@ -417,6 +649,19 @@
 
   atexit (close_stdout);
 
+#if HAVE_MBRTOWC
+  if (MB_CUR_MAX > 1)
+    {
+      find_field = find_field_multi;
+    }
+  else
+#endif
+    {
+      find_field = find_field_uni;
+    }
+
+
+
   skip_chars = 0;
   skip_fields = 0;
   check_chars = SIZE_MAX;
--- coreutils-6.8+/src/fold.c.i18n	2007-02-23 12:01:47.000000000 +0000
+++ coreutils-6.8+/src/fold.c	2007-03-01 15:08:24.000000000 +0000
@@ -23,11 +23,33 @@
 #include <getopt.h>
 #include <sys/types.h>
 
+/* Get mbstate_t, mbrtowc(), wcwidth().  */
+#if HAVE_WCHAR_H
+# include <wchar.h>
+#endif
+
+/* Get iswprint(), iswblank(), wcwidth().  */
+#if HAVE_WCTYPE_H
+# include <wctype.h>
+#endif
+
 #include "system.h"
 #include "error.h"
 #include "quote.h"
 #include "xstrtol.h"
 
+/* MB_LEN_MAX is incorrectly defined to be 1 in at least one GCC
+      installation; work around this configuration error.  */
+#if !defined MB_LEN_MAX || MB_LEN_MAX < 2
+# undef MB_LEN_MAX
+# define MB_LEN_MAX 16
+#endif
+
+/* Some systems, like BeOS, have multibyte encodings but lack mbstate_t.  */
+#if HAVE_MBRTOWC && defined mbstate_t
+# define mbrtowc(pwc, s, n, ps) (mbrtowc) (pwc, s, n, 0)
+#endif
+
 #define TAB_WIDTH 8
 
 /* The official name of this program (e.g., no `g' prefix).  */
@@ -35,20 +57,41 @@
 
 #define AUTHORS proper_name ("David MacKenzie")
 
+#define FATAL_ERROR(Message)                                            \
+  do                                                                    \
+    {                                                                   \
+      error (0, 0, (Message));                                          \
+      usage (2);                                                        \
+    }                                                                   \
+  while (0)
+
+enum operating_mode
+{
+  /* Fold texts by columns that are at the given positions. */
+  column_mode,
+
+  /* Fold texts by bytes that are at the given positions. */
+  byte_mode,
+
+  /* Fold texts by characters that are at the given positions. */
+  character_mode,
+};
+
+/* The argument shows current mode. (Default: column_mode) */
+static enum operating_mode operating_mode;
+
 /* If nonzero, try to break on whitespace. */
 static bool break_spaces;
 
-/* If nonzero, count bytes, not column positions. */
-static bool count_bytes;
-
 /* If nonzero, at least one of the files we read was standard input. */
 static bool have_read_stdin;
 
-static char const shortopts[] = "bsw:0::1::2::3::4::5::6::7::8::9::";
+static char const shortopts[] = "bcsw:0::1::2::3::4::5::6::7::8::9::";
 
 static struct option const longopts[] =
 {
   {"bytes", no_argument, NULL, 'b'},
+  {"characters", no_argument, NULL, 'c'},
   {"spaces", no_argument, NULL, 's'},
   {"width", required_argument, NULL, 'w'},
   {GETOPT_HELP_OPTION_DECL},
@@ -81,6 +124,7 @@
 "), stdout);
       fputs (_("\
   -b, --bytes         count bytes rather than columns\n\
+  -c, --characters    count characters rather than columns\n\
   -s, --spaces        break at spaces\n\
   -w, --width=WIDTH   use WIDTH columns instead of 80\n\
 "), stdout);
@@ -98,7 +142,7 @@
 static size_t
 adjust_column (size_t column, char c)
 {
-  if (!count_bytes)
+  if (operating_mode != byte_mode)
     {
       if (c == '\b')
 	{
@@ -121,30 +165,14 @@
    to stdout, with maximum line length WIDTH.
    Return true if successful.  */
 
-static bool
-fold_file (char const *filename, size_t width)
+static void
+fold_text (FILE *istream, size_t width, int *saved_errno)
 {
-  FILE *istream;
   int c;
   size_t column = 0;		/* Screen column where next char will go. */
   size_t offset_out = 0;	/* Index in `line_out' for next char. */
   static char *line_out = NULL;
   static size_t allocated_out = 0;
-  int saved_errno;
-
-  if (STREQ (filename, "-"))
-    {
-      istream = stdin;
-      have_read_stdin = true;
-    }
-  else
-    istream = fopen (filename, "r");
-
-  if (istream == NULL)
-    {
-      error (0, errno, "%s", filename);
-      return false;
-    }
 
   while ((c = getc (istream)) != EOF)
     {
@@ -172,6 +200,15 @@
 	      bool found_blank = false;
 	      size_t logical_end = offset_out;
 
+	      /* If LINE_OUT has no wide character,
+		 put a new wide character in LINE_OUT
+		 if column is bigger than width. */
+	      if (offset_out == 0)
+		{
+		  line_out[offset_out++] = c;
+		  continue;
+		}
+
 	      /* Look for the last blank. */
 	      while (logical_end)