new file mode 100644

@@ -0,0 +1,4790 @@

+Submitted by:            DJ Lucas (dj_AT_linuxfromscratch_DOT_org)

+Date:                    2016-02-09

+Initial Package Version: 8.25

+Upstream Status:         Rejected

+Origin:                  Based on Suse's i18n patches at https://build.opensuse.org/package/view_file/Base:System/coreutils/coreutils-i18n.patch

+Description:             Fixes several i18n issues with various Coreutils programs

+

+diff -Naurp coreutils-8.25-orig/lib/linebuffer.h coreutils-8.25/lib/linebuffer.h

+--- coreutils-8.25-orig/lib/linebuffer.h	2016-01-01 07:45:55.000000000 -0600

+@@ -21,6 +21,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

+@@ -28,6 +33,9 @@ struct linebuffer

+   size_t size;                  /* Allocated. */

+   size_t length;                /* Used. */

+   char *buffer;

++# if HAVE_WCHAR_H

++  mbstate_t state;

++# endif

+ };

+ 

+ /* Initialize linebuffer LINEBUFFER for use. */

+diff -Naurp coreutils-8.25-orig/src/cut.c coreutils-8.25/src/cut.c

+--- coreutils-8.25-orig/src/cut.c	2016-01-13 05:08:59.000000000 -0600

+@@ -28,6 +28,11 @@

+ #include <assert.h>

+ #include <getopt.h>

+ #include <sys/types.h>

++

++/* Get mbstate_t, mbrtowc().  */

++#if HAVE_WCHAR_H

++# include <wchar.h>

++#endif

+ #include "system.h"

+ 

+ #include "error.h"

+@@ -38,6 +43,18 @@

+ 

+ #include "set-fields.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

++

+ /* The official name of this program (e.g., no 'g' prefix).  */

+ #define PROGRAM_NAME "cut"

+ 

+@@ -54,6 +71,52 @@

+     }									\

+   while (0)

+ 

++/* Refill the buffer BUF to get a multibyte character. */

++#define REFILL_BUFFER(BUF, BUFPOS, BUFLEN, STREAM)                        \

++  do                                                                        \

++    {                                                                        \

++      if (BUFLEN < MB_LEN_MAX && !feof (STREAM) && !ferror (STREAM))        \

++        {                                                                \

++          memmove (BUF, BUFPOS, BUFLEN);                                \

++          BUFLEN += fread (BUF + BUFLEN, sizeof(char), BUFSIZ, STREAM); \

++          BUFPOS = BUF;                                                        \

++        }                                                                \

++    }                                                                        \

++  while (0)

++

++/* Get wide character on BUFPOS. BUFPOS is not included after that.

++   If byte sequence is not valid as a character, CONVFAIL is true. Otherwise false. */

++#define GET_NEXT_WC_FROM_BUFFER(WC, BUFPOS, BUFLEN, MBLENGTH, STATE, CONVFAIL) \

++  do                                                                        \

++    {                                                                        \

++      mbstate_t state_bak;                                                \

++                                                                        \

++      if (BUFLEN < 1)                                                        \

++        {                                                                \

++          WC = WEOF;                                                        \

++          break;                                                        \

++        }                                                                \

++                                                                        \

++      /* Get a wide character. */                                        \

++      CONVFAIL = false;                                                        \

++      state_bak = STATE;                                                \

++      MBLENGTH = mbrtowc ((wchar_t *)&WC, BUFPOS, BUFLEN, &STATE);        \

++                                                                        \

++      switch (MBLENGTH)                                                        \

++        {                                                                \

++        case (size_t)-1:                                                \

++        case (size_t)-2:                                                \

++          CONVFAIL = true;                                                        \

++          STATE = state_bak;                                                \

++          /* Fall througn. */                                                \

++                                                                        \

++        case 0:                                                                \

++          MBLENGTH = 1;                                                        \

++          break;                                                        \

++        }                                                                \

++    }                                                                        \

++  while (0)

++

+ 

+ /* Pointer inside RP.  When checking if a byte or field is selected

+    by a finite range, we check if it is between CURRENT_RP.LO

+@@ -61,6 +124,9 @@

+    CURRENT_RP.HI then we make CURRENT_RP to point to the next range pair. */

+ static struct field_range_pair *current_rp;

+ 

++/* Length of the delimiter given as argument to -d.  */

++size_t delimlen;

++

+ /* This buffer is used to support the semantics of the -s option

+    (or lack of same) when the specified field list includes (does

+    not include) the first field.  In both of those cases, the entire

+@@ -77,15 +143,25 @@ enum operating_mode

+   {

+     undefined_mode,

+ 

+-    /* Output characters that are in the given bytes. */

++    /* Output bytes that are at the given positions. */

+     byte_mode,

+ 

++    /* Output characters that are at the given positions. */

++    character_mode,

++

+     /* Output the given delimiter-separated fields. */

+     field_mode

+   };

+ 

+ static enum operating_mode operating_mode;

+ 

++/* If nonzero, when in byte mode, don't split multibyte characters.  */

++static int byte_mode_character_aware;

++

++/* If nonzero, the function for single byte locale is work

++   if this program runs on multibyte locale. */

++static int force_singlebyte_mode;

++

+ /* If true do not output lines containing no delimiter characters.

+    Otherwise, all such lines are printed.  This option is valid only

+    with field mode.  */

+@@ -97,6 +173,9 @@ static bool complement;

+ 

+ /* The delimiter character for field mode. */

+ static unsigned char delim;

++#if HAVE_WCHAR_H

++static wchar_t wcdelim;

++#endif

+ 

+ /* The delimiter for each line/record. */

+ static unsigned char line_delim = '\n';

+@@ -164,7 +243,7 @@ Print selected parts of lines from each

+   -f, --fields=LIST       select only these fields;  also print any line\n\

+                             that contains no delimiter character, unless\n\

+                             the -s option is specified\n\

+-  -n                      (ignored)\n\

++  -n                      with -b: don't split multibyte characters\n\

+ "), stdout);

+       fputs (_("\

+       --complement        complement the set of selected bytes, characters\n\

+@@ -280,6 +359,82 @@ cut_bytes (FILE *stream)

+     }

+ }

+ 

++#if HAVE_MBRTOWC

++/* This function is in use for the following case.

++

++   1. Read from the stream STREAM, printing to standard output any selected

++   characters.

++

++   2. Read from stream STREAM, printing to standard output any selected bytes,

++   without splitting multibyte characters.  */

++

++static void

++cut_characters_or_cut_bytes_no_split (FILE *stream)

++{

++  size_t idx;                /* number of bytes or characters in the line so far. */

++  char buf[MB_LEN_MAX + BUFSIZ];  /* For spooling a read byte sequence. */

++  char *bufpos;                /* Next read position of BUF. */

++  size_t buflen;        /* The length of the byte sequence in buf. */

++  wint_t wc;                /* A gotten wide character. */

++  size_t mblength;        /* The byte size of a multibyte character which shows

++                           as same character as WC. */

++  mbstate_t state;        /* State of the stream. */

++  bool convfail = false;  /* true, when conversion failed. Otherwise false. */

++  /* Whether to begin printing delimiters between ranges for the current line.

++     Set after we've begun printing data corresponding to the first range.  */

++  bool print_delimiter = false;

++

++  idx = 0;

++  buflen = 0;

++  bufpos = buf;

++  memset (&state, '\0', sizeof(mbstate_t));

++

++  current_rp = frp;

++

++  while (1)

++    {

++      REFILL_BUFFER (buf, bufpos, buflen, stream);

++

++      GET_NEXT_WC_FROM_BUFFER (wc, bufpos, buflen, mblength, state, convfail);

++      (void) convfail;  /* ignore unused */

++

++      if (wc == WEOF)

++        {

++          if (idx > 0)

++            putchar (line_delim);

++          break;

++        }

++      else if (wc == line_delim)

++        {

++          putchar (line_delim);

++          idx = 0;

++          print_delimiter = false;

++          current_rp = frp;

++        }

++      else

++        {

++          next_item (&idx);

++          if (print_kth (idx))

++            {

++              if (output_delimiter_specified)

++                {

++                  if (print_delimiter && is_range_start_index (idx))

++                    {

++                      fwrite (output_delimiter_string, sizeof (char),

++                              output_delimiter_length, stdout);

++                    }

++                  print_delimiter = true;

++                }

++              fwrite (bufpos, mblength, sizeof(char), stdout);

++            }

++        }

++

++      buflen -= mblength;

++      bufpos += mblength;

++    }

++}

++#endif

++

+ /* Read from stream STREAM, printing to standard output any selected fields.  */

+ 

+ static void

+@@ -425,13 +580,211 @@ cut_fields (FILE *stream)

+     }

+ }

+ 

++#if HAVE_MBRTOWC

++static void

++cut_fields_mb (FILE *stream)

++{

++  int c;

++  size_t field_idx;

++  int found_any_selected_field;

++  int buffer_first_field;

++  int empty_input;

++  char buf[MB_LEN_MAX + BUFSIZ];  /* For spooling a read byte sequence. */

++  char *bufpos;                /* Next read position of BUF. */

++  size_t buflen;        /* The length of the byte sequence in buf. */

++  wint_t wc = 0;        /* A gotten wide character. */

++  size_t mblength;        /* The byte size of a multibyte character which shows

++                           as same character as WC. */

++  mbstate_t state;        /* State of the stream. */

++  bool convfail = false;  /* true, when conversion failed. Otherwise false. */

++

++  current_rp = frp;

++

++  found_any_selected_field = 0;

++  field_idx = 1;

++  bufpos = buf;

++  buflen = 0;

++  memset (&state, '\0', sizeof(mbstate_t));

++

++  c = getc (stream);

++  empty_input = (c == EOF);

++  if (c != EOF)

++  {

++    ungetc (c, stream);

++    wc = 0;

++  }

++  else

++    wc = WEOF;

++

++  /* To support the semantics of the -s flag, we may have to buffer

++     all of the first field to determine whether it is `delimited.'

++     But that is unnecessary if all non-delimited lines must be printed

++     and the first field has been selected, or if non-delimited lines

++     must be suppressed and the first field has *not* been selected.

++     That is because a non-delimited line has exactly one field.  */

++  buffer_first_field = (suppress_non_delimited ^ !print_kth (1));

++

++  while (1)

++    {

++      if (field_idx == 1 && buffer_first_field)

++        {

++          int len = 0;

++

++          while (1)

++            {

++              REFILL_BUFFER (buf, bufpos, buflen, stream);

++

++              GET_NEXT_WC_FROM_BUFFER

++                (wc, bufpos, buflen, mblength, state, convfail);

++

++              if (wc == WEOF)

++                break;

++

++              field_1_buffer = xrealloc (field_1_buffer, len + mblength);

++              memcpy (field_1_buffer + len, bufpos, mblength);

++              len += mblength;

++              buflen -= mblength;

++              bufpos += mblength;

++

++              if (!convfail && (wc == line_delim || wc == wcdelim))

++                break;

++            }

++

++          if (len <= 0 && wc == WEOF)

++            break;

++

++          /* If the first field extends to the end of line (it is not

++             delimited) and we are printing all non-delimited lines,

++             print this one.  */

++          if (convfail || (!convfail && wc != wcdelim))

++            {

++              if (suppress_non_delimited)

++                {

++                  /* Empty.        */

++                }

++              else

++                {

++                  fwrite (field_1_buffer, sizeof (char), len, stdout);

++                  /* Make sure the output line is newline terminated.  */

++                  if (convfail || (!convfail && wc != line_delim))

++                    putchar (line_delim);

++                }

++              continue;

++            }

++

++          if (print_kth (1))

++            {

++              /* Print the field, but not the trailing delimiter.  */

++              fwrite (field_1_buffer, sizeof (char), len - 1, stdout);

++              found_any_selected_field = 1;

++            }

++          next_item (&field_idx);

++        }

++

++      if (wc != WEOF)

++        {

++          if (print_kth (field_idx))

++            {

++              if (found_any_selected_field)

++                {

++                  fwrite (output_delimiter_string, sizeof (char),

++                          output_delimiter_length, stdout);

++                }

++              found_any_selected_field = 1;

++            }

++

++          while (1)

++            {

++              REFILL_BUFFER (buf, bufpos, buflen, stream);

++

++              GET_NEXT_WC_FROM_BUFFER

++                (wc, bufpos, buflen, mblength, state, convfail);

++

++              if (wc == WEOF)

++                break;

++              else if (!convfail && (wc == wcdelim || wc == line_delim))

++                {

++                  buflen -= mblength;

++                  bufpos += mblength;

++                  break;

++                }

++

++              if (print_kth (field_idx))

++                fwrite (bufpos, mblength, sizeof(char), stdout);

++

++              buflen -= mblength;

++              bufpos += mblength;

++            }

++        }

++

++      if ((!convfail || wc == line_delim) && buflen < 1)

++        wc = WEOF;

++

++      if (!convfail && wc == wcdelim)

++        next_item (&field_idx);

++      else if (wc == WEOF || (!convfail && wc == line_delim))

++        {

++          if (found_any_selected_field

++              || (!empty_input && !(suppress_non_delimited && field_idx == 1)))

++            putchar (line_delim);

++          if (wc == WEOF)

++            break;

++          field_idx = 1;

++          current_rp = frp;

++          found_any_selected_field = 0;

++        }

++    }

++}

++#endif

++

+ static void

+ cut_stream (FILE *stream)

+ {

+-  if (operating_mode == byte_mode)

+-    cut_bytes (stream);

++#if HAVE_MBRTOWC

++  if (MB_CUR_MAX > 1 && !force_singlebyte_mode)

++    {

++      switch (operating_mode)

++        {

++        case byte_mode:

++          if (byte_mode_character_aware)

++            cut_characters_or_cut_bytes_no_split (stream);

++          else

++            cut_bytes (stream);

++          break;

++

++        case character_mode:

++          cut_characters_or_cut_bytes_no_split (stream);

++          break;

++

++        case field_mode:

++          if (delimlen == 1)

++            {

++              /* Check if we have utf8 multibyte locale, so we can use this

++                 optimization because of uniqueness of characters, which is

++                 not true for e.g. SJIS */

++              char * loc = setlocale(LC_CTYPE, NULL);

++              if (loc && (strstr (loc, "UTF-8") || strstr (loc, "utf-8") ||

++                  strstr (loc, "UTF8") || strstr (loc, "utf8")))

++                {

++                  cut_fields (stream);

++                  break;

++                }

++            }

++          cut_fields_mb (stream);

++          break;

++

++        default:

++          abort ();

++        }

++    }

+   else

+-    cut_fields (stream);

++#endif

++    {

++      if (operating_mode == field_mode)

++        cut_fields (stream);

++      else

++        cut_bytes (stream);

++    }

+ }

+ 

+ /* Process file FILE to standard output.

+@@ -483,6 +836,7 @@ main (int argc, char **argv)

+   bool ok;

+   bool delim_specified = false;

+   char *spec_list_string IF_LINT ( = NULL);

++  char mbdelim[MB_LEN_MAX + 1];

+ 

+   initialize_main (&argc, &argv);

+   set_program_name (argv[0]);

+@@ -505,7 +859,6 @@ main (int argc, char **argv)

+       switch (optc)

+         {

+         case 'b':

+-        case 'c':

+           /* Build the byte list. */

+           if (operating_mode != undefined_mode)

+             FATAL_ERROR (_("only one type of list may be specified"));

+@@ -513,6 +866,14 @@ main (int argc, char **argv)

+           spec_list_string = optarg;

+           break;

+ 

++        case 'c':

++          /* Build the character list. */

++          if (operating_mode != undefined_mode)

++            FATAL_ERROR (_("only one type of list may be specified"));

++          operating_mode = character_mode;

++          spec_list_string = optarg;

++          break;

++

+         case 'f':

+           /* Build the field list. */

+           if (operating_mode != undefined_mode)

+@@ -524,10 +885,38 @@ main (int argc, char **argv)

+         case 'd':

+           /* New delimiter. */

+           /* Interpret -d '' to mean 'use the NUL byte as the delimiter.'  */

+-          if (optarg[0] != '\0' && optarg[1] != '\0')

+-            FATAL_ERROR (_("the delimiter must be a single character"));

+-          delim = optarg[0];

+-          delim_specified = true;

++            {

++#if HAVE_MBRTOWC

++              if(MB_CUR_MAX > 1)

++                {

++                  mbstate_t state;

++

++                  memset (&state, '\0', sizeof(mbstate_t));

++                  delimlen = mbrtowc (&wcdelim, optarg, strnlen(optarg, MB_LEN_MAX), &state);

++

++                  if (delimlen == (size_t)-1 || delimlen == (size_t)-2)

++                    ++force_singlebyte_mode;

++                  else

++                    {

++                      delimlen = (delimlen < 1) ? 1 : delimlen;

++                      if (wcdelim != L'\0' && *(optarg + delimlen) != '\0')

++                        FATAL_ERROR (_("the delimiter must be a single character"));

++                      memcpy (mbdelim, optarg, delimlen);

++                      mbdelim[delimlen] = '\0';

++                      if (delimlen == 1)

++                        delim = *optarg;

++                    }

++                }

++

++              if (MB_CUR_MAX <= 1 || force_singlebyte_mode)

++#endif

++                {

++                  if (optarg[0] != '\0' && optarg[1] != '\0')

++                    FATAL_ERROR (_("the delimiter must be a single character"));

++                  delim = (unsigned char) optarg[0];

++                }

++            delim_specified = true;

++          }

+           break;

+ 

+         case OUTPUT_DELIMITER_OPTION:

+@@ -540,6 +929,7 @@ main (int argc, char **argv)

+           break;

+ 

+         case 'n':

++          byte_mode_character_aware = 1;

+           break;

+ 

+         case 's':

+@@ -579,15 +969,34 @@ main (int argc, char **argv)

+               | (complement ? SETFLD_COMPLEMENT : 0) );

+ 

+   if (!delim_specified)

+-    delim = '\t';

++    {

++      delim = '\t';

++#ifdef HAVE_MBRTOWC

++      wcdelim = L'\t';

++      mbdelim[0] = '\t';

++      mbdelim[1] = '\0';

++      delimlen = 1;

++#endif

++    }

+ 

+   if (output_delimiter_string == NULL)

+     {

+-      static char dummy[2];

+-      dummy[0] = delim;

+-      dummy[1] = '\0';

+-      output_delimiter_string = dummy;

+-      output_delimiter_length = 1;

++#ifdef HAVE_MBRTOWC

++      if (MB_CUR_MAX > 1 && !force_singlebyte_mode)

++        {

++          output_delimiter_string = xstrdup(mbdelim);

++          output_delimiter_length = delimlen;

++        }

++

++      if (MB_CUR_MAX <= 1 || force_singlebyte_mode)

++#endif

++        {

++          static char dummy[2];

++          dummy[0] = delim;

++          dummy[1] = '\0';

++          output_delimiter_string = dummy;

++          output_delimiter_length = 1;

++        }

+     }

+ 

+   if (optind == argc)

+diff -Naurp coreutils-8.25-orig/src/expand.c coreutils-8.25/src/expand.c

+--- coreutils-8.25-orig/src/expand.c	2016-01-01 07:48:50.000000000 -0600

+@@ -37,12 +37,34 @@

+ #include <stdio.h>

+ #include <getopt.h>

+ #include <sys/types.h>

++

++/* Get mbstate_t, mbrtowc(), wcwidth(). */

++#if HAVE_WCHAR_H

++# include <wchar.h>

++#endif

++

++/* Get iswblank(). */

++#if HAVE_WCTYPE_H

++# include <wctype.h>

++#endif

++

+ #include "system.h"

+ #include "error.h"

+ #include "fadvise.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"

+ 

+@@ -357,6 +379,142 @@ expand (void)

+     }

+ }

+ 

++#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 = buf;			/* 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 && !isblank(*bufpos))

++		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 && !iswblank(wc))

++			convert = 0;

++		    }

++		}

++	      fwrite (bufpos, sizeof(char), mblength, stdout);

++	    }

++	}

++      buflen -= mblength;

++      bufpos += mblength;

++    }

++}

++#endif

++

+ int

+ main (int argc, char **argv)

+ {

+@@ -421,7 +579,12 @@ main (int argc, char **argv)

+ 

+   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, "-");

+diff -Naurp coreutils-8.25-orig/src/fold.c coreutils-8.25/src/fold.c

+--- coreutils-8.25-orig/src/fold.c	2016-01-01 07:48:50.000000000 -0600

+@@ -22,11 +22,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 "fadvise.h"

+ #include "xdectoint.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).  */

+@@ -34,20 +56,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},

+@@ -75,6 +118,7 @@ Wrap input lines in each FILE, writing t

+ 

+       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);

+@@ -92,7 +136,7 @@ Wrap input lines in each FILE, writing t

+ static size_t

+ adjust_column (size_t column, char c)