Hi Michael, the toolchain builds in i586 are successful and i make a new patch with with rootfiles and uptime. POSIX requires that programs from Coreutils recognize character boundaries correctly even in multibyte locales The i18n patch fixes this non-compliance and other internationalization-related bugs. If this not needed for IPFire i can remove the patch. I myself can not tell... I orient myself on the Linux from scratch website. Please support me. The testsuite had a Problem with perl 5.22.0, now this is not more needed.. removed in the v2 patch. Thx for reviewing... Best, Marcel Am 2016-04-08 17:56, schrieb Michael Tremer: > Hi, > > we have to focus more on quality over quantity here: > > 1) The rootfile has changed but is not included in this patch. > > 2) Why is uptime not built any more (this alone will trigger a rootfile > change)? > > 3) Include comments about why you think adding the i18n patch is > required > > 4) Why are the sorting tests being disabled but no testsuite is > executed at all? > > 5) This package is part of the toolchain. Can you confirm that the > toolchain > still builds (on at least both x86 architectures)? > > Best, > -Michael > > On Thu, 2016-04-07 at 12:37 +0200, Marcel Lorenz wrote: >> Signed-off-by: Marcel Lorenz >> >> --- >>  lfs/coreutils                           |   11 +- >>  src/patches/coreutils-8.25-i18n-2.patch | 4790 >> +++++++++++++++++++++++++++++++ >>  2 files changed, 4796 insertions(+), 5 deletions(-) >>  create mode 100644 src/patches/coreutils-8.25-i18n-2.patch >> >> diff --git a/lfs/coreutils b/lfs/coreutils >> index ede0493..a79a508 100644 >> --- a/lfs/coreutils >> +++ b/lfs/coreutils >> @@ -24,7 +24,7 @@ >>   >>  include Config >>   >> -VER        = 8.24 >> +VER        = 8.25 >>   >>  THISAPP    = coreutils-$(VER) >>  DL_FILE    = $(THISAPP).tar.xz >> @@ -42,11 +42,10 @@ else >>  endif >>   >>  CONFIGURE_OPTIONS += \ >> - --disable-selinux \ >>   --enable-largefile \ >>   --disable-rpath \ >>   --enable-install-program=arch \ >> - --enable-no-install-program=hostname,kill \ >> + --enable-no-install-program=hostname,kill,uptime \ >>   --with-tty-group \ >>   gl_cv_func_mknod_works=yes >>   >> @@ -60,7 +59,7 @@ objects =$(DL_FILE) >>   >>  $(DL_FILE)                      = $(DL_FROM)/$(DL_FILE) >>   >> -$(DL_FILE)_MD5                  = 40efdbce865d2458d8da0a9dcee7c16c >> +$(DL_FILE)_MD5                  = 070e43ba7f618d747414ef56ab248a48 >>   >>  install : $(TARGET) >>   >> @@ -90,7 +89,9 @@ $(subst %,%_MD5,$(objects)) : >>  $(TARGET) : $(patsubst %,$(DIR_DL)/%,$(objects)) >>   @$(PREBUILD) >>   @rm -rf $(DIR_APP) && cd $(DIR_SRC) && tar axf $(DIR_DL)/$(DL_FILE) >> - cd $(DIR_APP) && ./configure $(CONFIGURE_OPTIONS) >> + cd $(DIR_APP) && patch -Np1 < $(DIR_SRC)/src/patches/coreutils-8.25- >> i18n-2.patch >> + cd $(DIR_APP) && sed -i '/tests\/misc\/sort.pl/ d' Makefile.in >> + cd $(DIR_APP) && FORCE_UNSAFE_CONFIGURE=1 && ./configure >> $(CONFIGURE_OPTIONS) >>   cd $(DIR_APP) && make $(MAKETUNING) >>   cd $(DIR_APP) && make install >>   >> diff --git a/src/patches/coreutils-8.25-i18n-2.patch >> b/src/patches/coreutils- >> 8.25-i18n-2.patch >> new file mode 100644 >> index 0000000..ad984ec >> --- /dev/null >> +++ b/src/patches/coreutils-8.25-i18n-2.patch >> @@ -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.opensu >> se.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 >> ++++ coreutils-8.25/lib/linebuffer.h 2016-02-08 19:07:10.298944609 >> -0600 >> +@@ -21,6 +21,11 @@ >> +  >> + # include >> +  >> ++/* Get mbstate_t.  */ >> ++# if HAVE_WCHAR_H >> ++#  include >> ++# 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 >> ++++ coreutils-8.25/src/cut.c 2016-02-08 19:07:10.300944616 -0600 >> +@@ -28,6 +28,11 @@ >> + #include >> + #include >> + #include >> ++ >> ++/* Get mbstate_t, mbrtowc().  */ >> ++#if HAVE_WCHAR_H >> ++# include >> ++#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 >> ++++ coreutils-8.25/src/expand.c 2016-02-08 19:07:10.301944619 -0600 >> +@@ -37,12 +37,34 @@ >> + #include >> + #include >> + #include >> ++ >> ++/* Get mbstate_t, mbrtowc(), wcwidth(). */ >> ++#if HAVE_WCHAR_H >> ++# include >> ++#endif >> ++ >> ++/* Get iswblank(). */ >> ++#if HAVE_WCTYPE_H >> ++# include >> ++#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 >> ++++ coreutils-8.25/src/fold.c 2016-02-08 19:07:10.302944622 -0600 >> +@@ -22,11 +22,33 @@ >> + #include >> + #include >> +  >> ++/* Get mbstate_t, mbrtowc(), wcwidth().  */ >> ++#if HAVE_WCHAR_H >> ++# include >> ++#endif >> ++ >> ++/* Get iswprint(), iswblank(), wcwidth().  */ >> ++#if HAVE_WCTYPE_H >> ++# include >> ++#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) >> + { >> +-  if (!count_bytes) >> ++  if (operating_mode != byte_mode) >> +     { >> +       if (c == '\b') >> +         { >> +@@ -115,30 +159,14 @@ adjust_column (size_t column, char c) >> +    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", quotef (filename)); >> +-      return false; >> +-    } >> +  >> +   fadvise (istream, FADVISE_SEQUENTIAL); >> +  >> +@@ -168,6 +196,15 @@ fold_file (char const *filename, size_t >> +               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) >> +                 { >> +@@ -214,11 +251,221 @@ fold_file (char const *filename, size_t >> +       line_out[offset_out++] = c; >> +     } >> +  >> +-  saved_errno = errno; >> ++  *saved_errno = errno; >> ++ >> ++  if (offset_out) >> ++    fwrite (line_out, sizeof (char), (size_t) offset_out, stdout); >> ++ >> ++} >> ++ >> ++#if HAVE_MBRTOWC >> ++static void >> ++fold_multibyte_text (FILE *istream, size_t width, int *saved_errno) >> ++{ >> ++  char buf[MB_LEN_MAX + BUFSIZ];  /* For spooling a read byte >> sequence. */ >> ++  size_t buflen = 0;        /* The length of the byte sequence in >> buf. */ >> ++  char *bufpos = buf;         /* Next read position of 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_bak;        /* State of the stream. */ >> ++  int convfail = 0;                /* 1, when conversion is failed. >> Otherwise 0. */ >> ++ >> ++  static char *line_out = NULL; >> ++  size_t offset_out = 0;        /* Index in `line_out' for next >> char. */ >> ++  static size_t allocated_out = 0; >> ++ >> ++  int increment; >> ++  size_t column = 0; >> ++ >> ++  size_t last_blank_pos; >> ++  size_t last_blank_column; >> ++  int is_blank_seen; >> ++  int last_blank_increment = 0; >> ++  int is_bs_following_last_blank; >> ++  size_t bs_following_last_blank_num; >> ++  int is_cr_after_last_blank; >> ++ >> ++#define CLEAR_FLAGS                                \ >> ++   do                                                \ >> ++     {                                                \ >> ++        last_blank_pos = 0;                        \ >> ++        last_blank_column = 0;                        \ >> ++        is_blank_seen = 0;                        \ >> ++        is_bs_following_last_blank = 0;                \ >> ++        bs_following_last_blank_num = 0;        \ >> ++        is_cr_after_last_blank = 0;                \ >> ++     }                                                \ >> ++   while (0) >> ++ >> ++#define START_NEW_LINE                        \ >> ++   do                                        \ >> ++     {                                        \ >> ++      putchar ('\n');                        \ >> ++      column = 0;                        \ >> ++      offset_out = 0;                        \ >> ++      CLEAR_FLAGS;                        \ >> ++    }                                        \ >> ++   while (0) >> ++ >> ++  CLEAR_FLAGS; >> ++  memset (&state, '\0', sizeof(mbstate_t)); >> ++ >> ++  for (;; bufpos += mblength, buflen -= mblength) >> ++    { >> ++      if (buflen < MB_LEN_MAX && !feof (istream) && !ferror >> (istream)) >> ++        { >> ++          memmove (buf, bufpos, buflen); >> ++          buflen += fread (buf + buflen, sizeof(char), BUFSIZ, >> istream); >> ++          bufpos = buf; >> ++        } >> ++ >> ++      if (buflen < 1) >> ++        break; >> ++ >> ++      /* Get a wide character. */ >> ++      state_bak = state; >> ++      mblength = mbrtowc ((wchar_t *)&wc, bufpos, buflen, &state); >> ++ >> ++      switch (mblength) >> ++        { >> ++        case (size_t)-1: >> ++        case (size_t)-2: >> ++          convfail++; >> ++          state = state_bak; >> ++          /* Fall through. */ >> ++ >> ++        case 0: >> ++          mblength = 1; >> ++          break; >> ++        } >> ++ >> ++rescan: >> ++      if (operating_mode == byte_mode)                        /* >> byte mode >> */ >> ++        increment = mblength; >> ++      else if (operating_mode == character_mode)        /* character >> mode */ >> ++        increment = 1; >> ++      else                                                /* column >> mode */ >> ++        { >> ++          if (convfail) >> ++            increment = 1; >> ++          else >> ++            { >> ++              switch (wc) >> ++                { >> ++                case L'\n': >> ++                  fwrite (line_out, sizeof(char), offset_out, >> stdout); >> ++                  START_NEW_LINE; >> ++                  continue; >> ++ >> ++                case L'\b': >> ++                  increment = (column > 0) ? -1 : 0; >> ++                  break; >> ++ >> ++                case L'\r': >> ++                  increment = -1 * column; >> ++                  break; >> ++ >> ++                case L'\t': >> ++                  increment = 8 - column % 8; >> ++                  break; >> ++ >> ++                default: >> ++                  increment = wcwidth (wc); >> ++                  increment = (increment < 0) ? 0 : increment; >> ++                } >> ++            } >> ++        } >> ++ >> ++      if (column + increment > width && break_spaces && >> last_blank_pos) >> ++        { >> ++          fwrite (line_out, sizeof(char), last_blank_pos, stdout); >> ++          putchar ('\n'); >> ++ >> ++          offset_out = offset_out - last_blank_pos; >> ++          column = column - last_blank_column + >> ((is_cr_after_last_blank) >> ++              ? last_blank_increment : bs_following_last_blank_num); >> ++          memmove (line_out, line_out + last_blank_pos, offset_out); >> ++          CLEAR_FLAGS; >> ++          goto rescan; >> ++        } >> ++ >> ++      if (column + increment > width && column != 0) >> ++        { >> ++          fwrite (line_out, sizeof(char), offset_out, stdout); >> ++          START_NEW_LINE; >> ++          goto rescan; >> ++        } >> ++ >> ++      if (allocated_out < offset_out + mblength) >> ++        { >> ++          line_out = X2REALLOC (line_out, &allocated_out); >> ++        } >> ++ >> ++      memcpy (line_out + offset_out, bufpos, mblength); >> ++      offset_out += mblength; >> ++      column += increment; >> ++ >> ++      if (is_blank_seen && !convfail && wc == L'\r') >> ++        is_cr_after_last_blank = 1; >> ++ >> ++      if (is_bs_following_last_blank && !convfail && wc == L'\b') >> ++        ++bs_following_last_blank_num; >> ++      else >> ++        is_bs_following_last_blank = 0; >> ++ >> ++      if (break_spaces && !convfail && iswblank (wc)) >> ++        { >> ++          last_blank_pos = offset_out; >> ++          last_blank_column = column; >> ++          is_blank_seen = 1; >> ++          last_blank_increment = increment; >> ++          is_bs_following_last_blank = 1; >> ++          bs_following_last_blank_num = 0; >> ++          is_cr_after_last_blank = 0; >> ++        } >> ++    } >> ++ >> ++  *saved_errno = errno; >> +  >> +   if (offset_out) >> +     fwrite (line_out, sizeof (char), (size_t) offset_out, stdout); >> +  >> ++} >> ++#endif >> ++ >> ++/* Fold file FILENAME, or standard input if FILENAME is "-", >> ++   to stdout, with maximum line length WIDTH. >> ++   Return 0 if successful, 1 if an error occurs. */ >> ++ >> ++static bool >> ++fold_file (char const *filename, size_t width) >> ++{ >> ++  FILE *istream; >> ++  int saved_errno; >> ++ >> ++  if (STREQ (filename, "-")) >> ++    { >> ++      istream = stdin; >> ++      have_read_stdin = 1; >> ++    } >> ++  else >> ++    istream = fopen (filename, "r"); >> ++ >> ++  if (istream == NULL) >> ++    { >> ++      error (0, errno, "%s", quotef (filename)); >> ++      return 1; >> ++    } >> ++ >> ++  /* Define how ISTREAM is being folded. */ >> ++#if HAVE_MBRTOWC >> ++  if (MB_CUR_MAX > 1) >> ++    fold_multibyte_text (istream, width, &saved_errno); >> ++  else >> ++#endif >> ++    fold_text (istream, width, &saved_errno); >> ++ >> +   if (ferror (istream)) >> +     { >> +       error (0, saved_errno, "%s", quotef (filename)); >> +@@ -251,7 +498,8 @@ main (int argc, char **argv) >> +  >> +   atexit (close_stdout); >> +  >> +-  break_spaces = count_bytes = have_read_stdin = false; >> ++  operating_mode = column_mode; >> ++  break_spaces = have_read_stdin = false; >> +  >> +   while ((optc = getopt_long (argc, argv, shortopts, longopts, >> NULL)) != -1) >> +     { >> +@@ -260,7 +508,15 @@ main (int argc, char **argv) >> +       switch (optc) >> +         { >> +         case 'b': /* Count bytes rather than columns. */ >> +-          count_bytes = true; >> ++          if (operating_mode != column_mode) >> ++            FATAL_ERROR (_("only one way of folding may be >> specified")); >> ++          operating_mode = byte_mode; >> ++          break; >> ++ >> ++        case 'c': >> ++          if (operating_mode != column_mode) >> ++            FATAL_ERROR (_("only one way of folding may be >> specified")); >> ++          operating_mode = character_mode; >> +           break; >> +  >> +         case 's': /* Break at word boundaries. */ >> +diff -Naurp coreutils-8.25-orig/src/join.c coreutils-8.25/src/join.c >> +--- coreutils-8.25-orig/src/join.c 2016-01-13 05:08:59.000000000 >> -0600 >> ++++ coreutils-8.25/src/join.c 2016-02-08 19:07:10.303944625 -0600 >> +@@ -22,18 +22,32 @@ >> + #include >> + #include >> +  >> ++/* Get mbstate_t, mbrtowc(), mbrtowc(), wcwidth().  */ >> ++#if HAVE_WCHAR_H >> ++# include >> ++#endif >> ++ >> ++/* Get iswblank(), towupper.  */ >> ++#if HAVE_WCTYPE_H >> ++# include >> ++#endif >> ++ >> + #include "system.h" >> + #include "error.h" >> + #include "fadvise.h" >> + #include "hard-locale.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" >> +  >> +@@ -135,10 +149,12 @@ static struct outlist outlist_head; >> + /* 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 >> +@@ -275,13 +291,14 @@ xfields (struct line *line) >> +   if (ptr == lim) >> +     return; >> +  >> +-  if (0 <= tab && tab != '\n') >> ++  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 if (tab < 0) >> ++   else >> +     { >> +       /* Skip leading blanks before the first field.  */ >> +       while (field_sep (*ptr)) >> +@@ -305,6 +322,147 @@ xfields (struct line *line) >> +   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) >> ++    { >> ++      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) && wc != '\n') >> ++          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) || wc == '\n') >> ++ 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) && wc != '\n') >> ++ break; >> ++ >> ++       ptr += mblength; >> ++     } >> ++ } >> ++      while (ptr < lim); >> ++    } >> ++ >> ++  extract_field (line, ptr, lim - ptr); >> ++} >> ++#endif >> ++ >> + static void >> + freeline (struct line *line) >> + { >> +@@ -326,56 +484,133 @@ 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; >> ++  int mallocd = 0; >> +  >> +   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++) >> ++          { >> ++            mallocd = 1; >> ++            copy[i] = xmalloc (len[i] + 1); >> ++            memset (copy[i], '\0',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; >> ++                        size_t mblen; >> ++ >> ++                        memset (&state_wc, '\0', sizeof >> (mbstate_t)); >> ++                        mblen = wcrtomb (copy[i] + j, uwc, >> &state_wc); >> ++                        assert (mblen != (size_t)-1); >> ++                      } >> ++                    else >> ++                      memcpy (copy[i] + j, beg[i] + j, mblength); >> ++                  } >> ++                j += mblength; >> ++              } >> ++            copy[i][j] = '\0'; >> ++          } >> ++      } >> ++      else >> ++#endif >> ++      { >> ++        for (i = 0; i < 2; i++) >> ++          { >> ++            mallocd = 1; >> ++            copy[i] = xmalloc (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] = beg[0]; >> ++      copy[1] = beg[1]; >> ++    } >> ++ >> ++  if (hard_LC_COLLATE) >> ++    { >> ++      diff = xmemcoll ((char *) copy[0], len[0], (char *) copy[1], >> len[1]); >> ++ >> ++      if (mallocd) >> ++        for (i = 0; i < 2; i++) >> ++          free (copy[i]); >> ++ >> ++      return diff; >> +     } >> ++  diff = memcmp (copy[0], copy[1], MIN (len[0], len[1])); >> ++ >> ++  if (mallocd) >> ++    for (i = 0; i < 2; i++) >> ++      free (copy[i]); >> ++ >> +  >> +   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 >> +@@ -467,6 +702,11 @@ get_line (FILE *fp, struct line **linep, >> +     } >> +   ++line_no[which - 1]; >> +  >> ++#if HAVE_MBRTOWC >> ++  if (MB_CUR_MAX > 1) >> ++    xfields_multibyte (line); >> ++  else >> ++#endif >> +   xfields (line); >> +  >> +   if (prevline[which - 1]) >> +@@ -566,21 +806,28 @@ prfield (size_t n, struct line const *li >> +  >> + /* Output all the fields in line, other than the join field.  */ >> +  >> ++#define PUT_TAB_CHAR >> \ >> ++  do >> \ >> ++    { >> \ >> ++      (tab != NULL) ? >> \ >> ++ fwrite(tab, sizeof(char), tablen, stdout) : putchar (' '); \ >> ++    } >> \ >> ++  while (0) >> ++ >> + static void >> + prfields (struct line const *line, size_t join_field, size_t >> autocount) >> + { >> +   size_t i; >> +   size_t nfields = autoformat ? autocount : line->nfields; >> +-  char output_separator = tab < 0 ? ' ' : tab; >> +  >> +   for (i = 0; i < join_field && i < nfields; ++i) >> +     { >> +-      putchar (output_separator); >> ++      PUT_TAB_CHAR; >> +       prfield (i, line); >> +     } >> +   for (i = join_field + 1; i < nfields; ++i) >> +     { >> +-      putchar (output_separator); >> ++      PUT_TAB_CHAR; >> +       prfield (i, line); >> +     } >> + } >> +@@ -591,7 +838,6 @@ static void >> + prjoin (struct line const *line1, struct line const *line2) >> + { >> +   const struct outlist *outlist; >> +-  char output_separator = tab < 0 ? ' ' : tab; >> +   size_t field; >> +   struct line const *line; >> +  >> +@@ -625,7 +871,7 @@ prjoin (struct line const *line1, struct >> +           o = o->next; >> +           if (o == NULL) >> +             break; >> +-          putchar (output_separator); >> ++          PUT_TAB_CHAR; >> +         } >> +       putchar (eolchar); >> +     } >> +@@ -1103,21 +1349,46 @@ main (int argc, char **argv) >> +  >> +         case 't': >> +           { >> +-            unsigned char newtab = optarg[0]; >> ++            char *newtab = NULL; >> ++            size_t newtablen; >> ++            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 (! newtab) >> +-              newtab = '\n'; /* '' => process the whole line.  */ >> ++            { >> ++              newtab = (char*)"\n"; /* '' => process the whole >> line.  */ >> ++            } >> +             else if (optarg[1]) >> +               { >> +-                if (STREQ (optarg, "\\0")) >> +-                  newtab = '\0'; >> +-                else >> +-                  error (EXIT_FAILURE, 0, _("multi-character tab >> %s"), >> +-                         quote (optarg)); >> ++                if (newtablen == 1 && newtab[1]) >> ++                { >> ++                  if (STREQ (newtab, "\\0")) >> ++                     newtab[0] = '\0'; >> ++                } >> ++              } >> ++            if (tab != NULL && strcmp (tab, newtab)) >> ++              { >> ++                free (newtab); >> ++                error (EXIT_FAILURE, 0, _("incompatible tabs")); >> +               } >> +-            if (0 <= tab && tab != newtab) >> +-              error (EXIT_FAILURE, 0, _("incompatible tabs")); >> +             tab = newtab; >> +-          } >> ++            tablen = newtablen; >> ++           } >> +           break; >> +  >> +         case 'z': >> +diff -Naurp coreutils-8.25-orig/src/pr.c coreutils-8.25/src/pr.c >> +--- coreutils-8.25-orig/src/pr.c 2016-01-01 07:48:50.000000000 -0600 >> ++++ coreutils-8.25/src/pr.c 2016-02-08 19:07:10.306944635 -0600 >> +@@ -311,6 +311,24 @@ >> +  >> + #include >> + #include >> ++ >> ++/* Get MB_LEN_MAX.  */ >> ++#include >> ++/* 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 == 1 >> ++# define MB_LEN_MAX 16 >> ++#endif >> ++ >> ++/* Get MB_CUR_MAX.  */ >> ++#include >> ++ >> ++/* Solaris 2.5 has a bug: must be included before >> .  */ >> ++/* Get mbstate_t, mbrtowc(), wcwidth().  */ >> ++#if HAVE_WCHAR_H >> ++# include >> ++#endif >> ++ >> + #include "system.h" >> + #include "error.h" >> + #include "fadvise.h" >> +@@ -323,6 +341,18 @@ >> + #include "xstrtol.h" >> + #include "xdectoint.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 >> ++ >> ++#ifndef HAVE_DECL_WCWIDTH >> ++"this configure-time declaration test was not run" >> ++#endif >> ++#if !HAVE_DECL_WCWIDTH >> ++extern int wcwidth (); >> ++#endif >> ++ >> + /* The official name of this program (e.g., no 'g' prefix).  */ >> + #define PROGRAM_NAME "pr" >> +  >> +@@ -415,7 +445,20 @@ struct COLUMN >> +  >> + typedef struct COLUMN COLUMN; >> +  >> +-static int char_to_clump (char c); >> ++/* Funtion pointers to switch functions for single byte locale or >> for >> ++   multibyte locale. If multibyte functions do not exist in your >> sysytem, >> ++   these pointers always point the function for single byte locale. >> */ >> ++static void (*print_char) (char c); >> ++static int (*char_to_clump) (char c); >> ++ >> ++/* Functions for single byte locale. */ >> ++static void print_char_single (char c); >> ++static int char_to_clump_single (char c); >> ++ >> ++/* Functions for multibyte locale. */ >> ++static void print_char_multi (char c); >> ++static int char_to_clump_multi (char c); >> ++ >> + static bool read_line (COLUMN *p); >> + static bool print_page (void); >> + static bool print_stored (COLUMN *p); >> +@@ -427,6 +470,7 @@ static void add_line_number (COLUMN *p); >> + static void getoptnum (const char *n_str, int min, int *num, >> +                        const char *errfmt); >> + static void getoptarg (char *arg, char switch_char, char *character, >> ++                       int *character_length, int *character_width, >> +                        int *number); >> + static void print_files (int number_of_files, char **av); >> + static void init_parameters (int number_of_files); >> +@@ -440,7 +484,6 @@ static void store_char (char c); >> + static void pad_down (unsigned int lines); >> + static void read_rest_of_line (COLUMN *p); >> + static void skip_read (COLUMN *p, int column_number); >> +-static void print_char (char c); >> + static void cleanup (void); >> + static void print_sep_string (void); >> + static void separator_string (const char *optarg_S); >> +@@ -452,7 +495,7 @@ static COLUMN *column_vector; >> +    we store the leftmost columns contiguously in buff. >> +    To print a line from buff, get the index of the first character >> +    from line_vector[i], and print up to line_vector[i + 1]. */ >> +-static char *buff; >> ++static unsigned char *buff; >> +  >> + /* Index of the position in buff where the next character >> +    will be stored. */ >> +@@ -556,7 +599,7 @@ static int chars_per_column; >> + static bool untabify_input = false; >> +  >> + /* (-e) The input tab character. */ >> +-static char input_tab_char = '\t'; >> ++static char input_tab_char[MB_LEN_MAX] = "\t"; >> +  >> + /* (-e) Tabstops are at chars_per_tab, 2*chars_per_tab, >> 3*chars_per_tab, ... >> +    where the leftmost column is 1. */ >> +@@ -566,7 +609,10 @@ static int chars_per_input_tab = 8; >> + static bool tabify_output = false; >> +  >> + /* (-i) The output tab character. */ >> +-static char output_tab_char = '\t'; >> ++static char output_tab_char[MB_LEN_MAX] = "\t"; >> ++ >> ++/* (-i) The byte length of output tab character. */ >> ++static int output_tab_char_length = 1; >> +  >> + /* (-i) The width of the output tab. */ >> + static int chars_per_output_tab = 8; >> +@@ -636,7 +682,13 @@ static int line_number; >> + static bool numbered_lines = false; >> +  >> + /* (-n) Character which follows each line number. */ >> +-static char number_separator = '\t'; >> ++static char number_separator[MB_LEN_MAX] = "\t"; >> ++ >> ++/* (-n) The byte length of the character which follows each line >> number. */ >> ++static int number_separator_length = 1; >> ++ >> ++/* (-n) The character width of the character which follows each line >> number. >> */ >> ++static int number_separator_width = 0; >> +  >> + /* (-n) line counting starts with 1st line of input file (not with >> 1st >> +    line of 1st page printed). */ >> +@@ -689,6 +741,7 @@ static bool use_col_separator = false; >> +    -a|COLUMN|-m is a 'space' and with the -J option a 'tab'. */ >> + static char *col_sep_string = (char *) ""; >> + static int col_sep_length = 0; >> ++static int col_sep_width = 0; >> + static char *column_separator = (char *) " "; >> + static char *line_separator = (char *) "\t"; >> +  >> +@@ -839,6 +892,13 @@ separator_string (const char *optarg_S) >> +   col_sep_length = (int) strlen (optarg_S); >> +   col_sep_string = xmalloc (col_sep_length + 1); >> +   strcpy (col_sep_string, optarg_S); >> ++ >> ++#if HAVE_MBRTOWC >> ++  if (MB_CUR_MAX > 1) >> ++    col_sep_width = mbswidth (col_sep_string, 0); >> ++  else >> ++#endif >> ++    col_sep_width = col_sep_length; >> + } >> +  >> + int >> +@@ -863,6 +923,21 @@ main (int argc, char **argv) >> +  >> +   atexit (close_stdout); >> +  >> ++/* Define which functions are used, the ones for single byte locale >> or the >> ones >> ++   for multibyte locale. */ >> ++#if HAVE_MBRTOWC >> ++  if (MB_CUR_MAX > 1) >> ++    { >> ++      print_char = print_char_multi; >> ++      char_to_clump = char_to_clump_multi; >> ++    } >> ++  else >> ++#endif >> ++    { >> ++      print_char = print_char_single; >> ++      char_to_clump = char_to_clump_single; >> ++    } >> ++ >> +   n_files = 0; >> +   file_names = (argc > 1 >> +                 ? xmalloc ((argc - 1) * sizeof (char *)) >> +@@ -939,8 +1014,12 @@ main (int argc, char **argv) >> +           break; >> +         case 'e': >> +           if (optarg) >> +-            getoptarg (optarg, 'e', &input_tab_char, >> +-                       &chars_per_input_tab); >> ++            { >> ++              int dummy_length, dummy_width; >> ++ >> ++              getoptarg (optarg, 'e', input_tab_char, &dummy_length, >> ++                         &dummy_width, &chars_per_input_tab); >> ++            } >> +           /* Could check tab width > 0. */ >> +           untabify_input = true; >> +           break; >> +@@ -953,8 +1032,12 @@ main (int argc, char **argv) >> +           break; >> +         case 'i': >> +           if (optarg) >> +-            getoptarg (optarg, 'i', &output_tab_char, >> +-                       &chars_per_output_tab); >> ++            { >> ++              int dummy_width; >> ++ >> ++              getoptarg (optarg, 'i', output_tab_char, >> &output_tab_char_length, >> ++                         &dummy_width, &chars_per_output_tab); >> ++            } >> +           /* Could check tab width > 0. */ >> +           tabify_output = true; >> +           break; >> +@@ -972,8 +1055,8 @@ main (int argc, char **argv) >> +         case 'n': >> +           numbered_lines = true; >> +           if (optarg) >> +-            getoptarg (optarg, 'n', &number_separator, >> +-                       &chars_per_number); >> ++            getoptarg (optarg, 'n', number_separator, >> &number_separator_length, >> ++                       &number_separator_width, &chars_per_number); >> +           break; >> +         case 'N': >> +           skip_count = false; >> +@@ -997,7 +1080,7 @@ main (int argc, char **argv) >> +           old_s = false; >> +           /* Reset an additional input of -s, -S dominates -s */ >> +           col_sep_string = bad_cast (""); >> +-          col_sep_length = 0; >> ++          col_sep_length = col_sep_width = 0; >> +           use_col_separator = true; >> +           if (optarg) >> +             separator_string (optarg); >> +@@ -1152,10 +1235,45 @@ getoptnum (const char *n_str, int min, i >> +    a number. */ >> +  >> + static void >> +-getoptarg (char *arg, char switch_char, char *character, int >> *number) >> ++getoptarg (char *arg, char switch_char, char *character, int >> *character_length, >> ++           int *character_width, int *number) >> + { >> +   if (!ISDIGIT (*arg)) >> +-    *character = *arg++; >> ++    { >> ++#ifdef HAVE_MBRTOWC >> ++      if (MB_CUR_MAX > 1)        /* for multibyte locale. */ >> ++        { >> ++          wchar_t wc; >> ++          size_t mblength; >> ++          int width; >> ++          mbstate_t state = {'\0'}; >> ++ >> ++          mblength = mbrtowc (&wc, arg, strnlen(arg, MB_LEN_MAX), >> &state); >> ++ >> ++          if (mblength == (size_t)-1 || mblength == (size_t)-2) >> ++            { >> ++              *character_length = 1; >> ++              *character_width = 1; >> ++            } >> ++          else >> ++            { >> ++              *character_length = (mblength < 1) ? 1 : mblength; >> ++              width = wcwidth (wc); >> ++              *character_width = (width < 0) ? 0 : width; >> ++            } >> ++ >> ++          strncpy (character, arg, *character_length); >> ++          arg += *character_length; >> ++        } >> ++      else                        /* for single byte locale. */ >> ++#endif >> ++        { >> ++          *character = *arg++; >> ++          *character_length = 1; >> ++          *character_width = 1; >> ++        } >> ++    } >> ++ >> +   if (*arg) >> +     { >> +       long int tmp_long; >> +@@ -1177,6 +1295,11 @@ static void >> + init_parameters (int number_of_files) >> + { >> +   int chars_used_by_number = 0; >> ++  int mb_len = 1; >> ++#if HAVE_MBRTOWC >> ++  if (MB_CUR_MAX > 1) >> ++    mb_len = MB_LEN_MAX; >> ++#endif >> +  >> +   lines_per_body = lines_per_page - lines_per_header - >> lines_per_footer; >> +   if (lines_per_body <= 0) >> +@@ -1214,7 +1337,7 @@ init_parameters (int number_of_files) >> +           else >> +             col_sep_string = column_separator; >> +  >> +-          col_sep_length = 1; >> ++          col_sep_length = col_sep_width = 1; >> +           use_col_separator = true; >> +         } >> +       /* It's rather pointless to define a TAB separator with column >> +@@ -1244,11 +1367,11 @@ init_parameters (int number_of_files) >> +              + TAB_WIDTH (chars_per_input_tab, >> chars_per_number);   */ >> +  >> +       /* Estimate chars_per_text without any margin and keep it >> constant. */ >> +-      if (number_separator == '\t') >> ++      if (number_separator[0] == '\t') >> +         number_width = (chars_per_number >> +                         + TAB_WIDTH (chars_per_default_tab, >> chars_per_number)); >> +       else >> +-        number_width = chars_per_number + 1; >> ++        number_width = chars_per_number + number_separator_width; >> +  >> +       /* The number is part of the column width unless we are >> +          printing files in parallel. */ >> +@@ -1257,7 +1380,7 @@ init_parameters (int number_of_files) >> +     } >> +  >> +   chars_per_column = (chars_per_line - chars_used_by_number >> +-                      - (columns - 1) * col_sep_length) / columns; >> ++                      - (columns - 1) * col_sep_width) / columns; >> +  >> +   if (chars_per_column < 1) >> +     error (EXIT_FAILURE, 0, _("page width too narrow")); >> +@@ -1275,7 +1398,7 @@ init_parameters (int number_of_files) >> +      We've to use 8 as the lower limit, if we use >> chars_per_default_tab = 8 >> +      to expand a tab which is not an input_tab-char. */ >> +   free (clump_buff); >> +-  clump_buff = xmalloc (MAX (8, chars_per_input_tab)); >> ++  clump_buff = xmalloc (mb_len * MAX (8, chars_per_input_tab)); >> + } >> +  >> + /* Open the necessary files, >> +@@ -1383,7 +1506,7 @@ init_funcs (void) >> +  >> +   /* Enlarge p->start_position of first column to use the same form >> of >> +      padding_not_printed with all columns. */ >> +-  h = h + col_sep_length; >> ++  h = h + col_sep_width; >> +  >> +   /* This loop takes care of all but the rightmost column. */ >> +  >> +@@ -1417,7 +1540,7 @@ init_funcs (void) >> +         } >> +       else >> +         { >> +-          h = h_next + col_sep_length; >> ++          h = h_next + col_sep_width; >> +           h_next = h + chars_per_column; >> +         } >> +     } >> +@@ -1708,9 +1831,9 @@ static void >> + align_column (COLUMN *p) >> + { >> +   padding_not_printed = p->start_position; >> +-  if (padding_not_printed - col_sep_length > 0) >> ++  if (padding_not_printed - col_sep_width > 0) >> +     { >> +-      pad_across_to (padding_not_printed - col_sep_length); >> ++      pad_across_to (padding_not_printed - col_sep_width); >> +       padding_not_printed = ANYWHERE; >> +     } >> +  >> +@@ -1981,13 +2104,13 @@ store_char (char c) >> +       /* May be too generous. */ >> +       buff = X2REALLOC (buff, &buff_allocated); >> +     } >> +-  buff[buff_current++] = c; >> ++  buff[buff_current++] = (unsigned char) c; >> + } >> +  >> + static void >> + add_line_number (COLUMN *p) >> + { >> +-  int i; >> ++  int i, j; >> +   char *s; >> +   int num_width; >> +  >> +@@ -2004,22 +2127,24 @@ add_line_number (COLUMN *p) >> +       /* Tabification is assumed for multiple columns, also for n- >> separators, >> +          but 'default n-separator = TAB' hasn't been given priority >> over >> +          equal column_width also specified by POSIX. */ >> +-      if (number_separator == '\t') >> ++      if (number_separator[0] == '\t') >> +         { >> +           i = number_width - chars_per_number; >> +           while (i-- > 0) >> +             (p->char_func) (' '); >> +         } >> +       else >> +-        (p->char_func) (number_separator); >> ++        for (j = 0; j < number_separator_length; j++) >> ++          (p->char_func) (number_separator[j]); >> +     } >> +   else >> +     /* To comply with POSIX, we avoid any expansion of default TAB >> +        separator with a single column output. No column_width >> requirement >> +        has to be considered. */ >> +     { >> +-      (p->char_func) (number_separator); >> +-      if (number_separator == '\t') >> ++      for (j = 0; j < number_separator_length; j++) >> ++        (p->char_func) (number_separator[j]); >> ++      if (number_separator[0] == '\t') >> +         output_position = POS_AFTER_TAB (chars_per_output_tab, >> +                           output_position); >> +     } >> +@@ -2180,7 +2305,7 @@ print_white_space (void) >> +   while (goal - h_old > 1 >> +          && (h_new = POS_AFTER_TAB (chars_per_output_tab, h_old)) <= >> goal) >> +     { >> +-      putchar (output_tab_char); >> ++      fwrite (output_tab_char, sizeof(char), output_tab_char_length, >> stdout); >> +       h_old = h_new; >> +     } >> +   while (++h_old <= goal) >> +@@ -2200,6 +2325,7 @@ print_sep_string (void) >> + { >> +   char *s; >> +   int l = col_sep_length; >> ++  int not_space_flag; >> +  >> +   s = col_sep_string; >> +  >> +@@ -2213,6 +2339,7 @@ print_sep_string (void) >> +     { >> +       for (; separators_not_printed > 0; --separators_not_printed) >> +         { >> ++          not_space_flag = 0; >> +           while (l-- > 0) >> +             { >> +               /* 3 types of sep_strings: spaces only, spaces and >> chars, >> +@@ -2226,12 +2353,15 @@ print_sep_string (void) >> +                 } >> +               else >> +                 { >> ++                  not_space_flag = 1; >> +                   if (spaces_not_printed > 0) >> +                     print_white_space (); >> +                   putchar (*s++); >> +-                  ++output_position; >> +                 } >> +             } >> ++          if (not_space_flag) >> ++            output_position += col_sep_width; >> ++ >> +           /* sep_string ends with some spaces */ >> +           if (spaces_not_printed > 0) >> +             print_white_space (); >> +@@ -2259,7 +2389,7 @@ print_clump (COLUMN *p, int n, char *clu >> +    required number of tabs and spaces. */ >> +  >> + static void >> +-print_char (char c) >> ++print_char_single (char c) >> + { >> +   if (tabify_output) >> +     { >> +@@ -2283,6 +2413,74 @@ print_char (char c) >> +   putchar (c); >> + } >> +  >> ++#ifdef HAVE_MBRTOWC >> ++static void >> ++print_char_multi (char c) >> ++{ >> ++  static size_t mbc_pos = 0; >> ++  static char mbc[MB_LEN_MAX] = {'\0'}; >> ++  static mbstate_t state = {'\0'}; >> ++  mbstate_t state_bak; >> ++  wchar_t wc; >> ++  size_t mblength; >> ++  int width; >> ++ >> ++  if (tabify_output) >> ++    { >> ++      state_bak = state; >> ++      mbc[mbc_pos++] = c; >> ++      mblength = mbrtowc (&wc, mbc, mbc_pos, &state); >> ++ >> ++      while (mbc_pos > 0) >> ++        { >> ++          switch (mblength) >> ++            { >> ++            case (size_t)-2: >> ++              state = state_bak; >> ++              return; >> ++ >> ++            case (size_t)-1: >> ++              state = state_bak; >> ++              ++output_position; >> ++              putchar (mbc[0]); >> ++              memmove (mbc, mbc + 1, MB_CUR_MAX - 1); >> ++              --mbc_pos; >> ++              break; >> ++ >> ++            case 0: >> ++              mblength = 1; >> ++ >> ++            default: >> ++              if (wc == L' ') >> ++                { >> ++                  memmove (mbc, mbc + mblength, MB_CUR_MAX - >> mblength); >> ++                  --mbc_pos; >> ++                  ++spaces_not_printed; >> ++                  return; >> ++                } >> ++              else if (spaces_not_printed > 0) >> ++                print_white_space (); >> ++ >> ++              /* Nonprintables are assumed to have width 0, except >> L'\b'. */ >> ++              if ((width = wcwidth (wc)) < 1) >> ++                { >> ++                  if (wc == L'\b') >> ++                    --output_position; >> ++                } >> ++              else >> ++                output_position += width; >> ++ >> ++              fwrite (mbc, sizeof(char), mblength, stdout); >> ++              memmove (mbc, mbc + mblength, MB_CUR_MAX - mblength); >> ++              mbc_pos -= mblength; >> ++            } >> ++        } >> ++      return; >> ++    } >> ++  putchar (c); >> ++} >> ++#endif >> ++ >> + /* Skip to page PAGE before printing. >> +    PAGE may be larger than total number of pages. */ >> +  >> +@@ -2462,9 +2660,9 @@ read_line (COLUMN *p) >> +           align_empty_cols = false; >> +         } >> +  >> +-      if (padding_not_printed - col_sep_length > 0) >> ++      if (padding_not_printed - col_sep_width > 0) >> +         { >> +-          pad_across_to (padding_not_printed - col_sep_length); >> ++          pad_across_to (padding_not_printed - col_sep_width); >> +           padding_not_printed = ANYWHERE; >> +         } >> +  >> +@@ -2534,7 +2732,7 @@ print_stored (COLUMN *p) >> +   int i; >> +  >> +   int line = p->current_line++; >> +-  char *first = &buff[line_vector[line]]; >> ++  unsigned char *first = &buff[line_vector[line]]; >> +   /* FIXME >> +      UMR: Uninitialized memory read: >> +      * This is occurring while in: >> +@@ -2546,7 +2744,7 @@ print_stored (COLUMN *p) >> +      xmalloc        [xmalloc.c:94] >> +      init_store_cols [pr.c:1648] >> +      */ >> +-  char *last = &buff[line_vector[line + 1]]; >> ++  unsigned char *last = &buff[line_vector[line + 1]]; >> +  >> +   pad_vertically = true; >> +  >> +@@ -2565,9 +2763,9 @@ print_stored (COLUMN *p) >> +         } >> +     } >> +  >> +-  if (padding_not_printed - col_sep_length > 0) >> ++  if (padding_not_printed - col_sep_width > 0) >> +     { >> +-      pad_across_to (padding_not_printed - col_sep_length); >> ++      pad_across_to (padding_not_printed - col_sep_width); >> +       padding_not_printed = ANYWHERE; >> +     } >> +  >> +@@ -2580,8 +2778,8 @@ print_stored (COLUMN *p) >> +   if (spaces_not_printed == 0) >> +     { >> +       output_position = p->start_position + end_vector[line]; >> +-      if (p->start_position - col_sep_length == chars_per_margin) >> +-        output_position -= col_sep_length; >> ++      if (p->start_position - col_sep_width == chars_per_margin) >> ++        output_position -= col_sep_width; >> +     } >> +  >> +   return true; >> +@@ -2600,7 +2798,7 @@ print_stored (COLUMN *p) >> +    number of characters is 1.) */ >> +  >> + static int >> +-char_to_clump (char c) >> ++char_to_clump_single (char c) >> + { >> +   unsigned char uc = c; >> +   char *s = clump_buff; >> +@@ -2610,10 +2808,10 @@ char_to_clump (char c) >> +   int chars; >> +   int chars_per_c = 8; >> +  >> +-  if (c == input_tab_char) >> ++  if (c == input_tab_char[0]) >> +     chars_per_c = chars_per_input_tab; >> +  >> +-  if (c == input_tab_char || c == '\t') >> ++  if (c == input_tab_char[0] || c == '\t') >> +     { >> +       width = TAB_WIDTH (chars_per_c, input_position); >> +  >> +@@ -2694,6 +2892,164 @@ char_to_clump (char c) >> +   return chars; >> + } >> +  >> ++#ifdef HAVE_MBRTOWC >> ++static int >> ++char_to_clump_multi (char c) >> ++{ >> ++  static size_t mbc_pos = 0; >> ++  static char mbc[MB_LEN_MAX] = {'\0'}; >> ++  static mbstate_t state = {'\0'}; >> ++  mbstate_t state_bak; >> ++  wchar_t wc; >> ++  size_t mblength; >> ++  int wc_width; >> ++  register char *s = clump_buff; >> ++  register int i, j; >> ++  char esc_buff[4]; >> ++  int width; >> ++  int chars; >> ++  int chars_per_c = 8; >> ++ >> ++  state_bak = state; >> ++  mbc[mbc_pos++] = c; >> ++  mblength = mbrtowc (&wc, mbc, mbc_pos, &state); >> ++ >> ++  width = 0; >> ++  chars = 0; >> ++  while (mbc_pos > 0) >> ++    { >> ++      switch (mblength) >> ++        { >> ++        case (size_t)-2: >> ++          state = state_bak; >> ++          return 0; >> ++ >> ++        case (size_t)-1: >> ++          state = state_bak; >> ++          mblength = 1; >> ++ >> ++          if (use_esc_sequence || use_cntrl_prefix) >> ++            { >> ++              width = +4; >> ++              chars = +4; >> ++              *s++ = '\\'; >> ++              sprintf (esc_buff, "%03o", (unsigned char) mbc[0]); >> ++              for (i = 0; i <= 2; ++i) >> ++                *s++ = (int) esc_buff[i]; >> ++            } >> ++          else >> ++            { >> ++              width += 1; >> ++              chars += 1; >> ++              *s++ = mbc[0]; >> ++            } >> ++          break; >> ++ >> ++        case 0: >> ++          mblength = 1; >> ++                /* Fall through */ >> ++ >> ++        default: >> ++          if (memcmp (mbc, input_tab_char, mblength) == 0) >> ++            chars_per_c = chars_per_input_tab; >> ++ >> ++          if (memcmp (mbc, input_tab_char, mblength) == 0 || c == >> '\t') >> ++            { >> ++              int  width_inc; >> ++ >> ++              width_inc = TAB_WIDTH (chars_per_c, input_position); >> ++              width += width_inc; >> ++ >> ++              if (untabify_input) >> ++                { >> ++                  for (i = width_inc; i; --i) >> ++                    *s++ = ' '; >> ++                  chars += width_inc; >> ++                } >> ++              else >> ++                { >> ++                  for (i = 0; i <  mblength; i++) >> ++                    *s++ = mbc[i]; >> ++                  chars += mblength; >> ++                } >> ++            } >> ++          else if ((wc_width = wcwidth (wc)) < 1) >> ++            { >> ++              if (use_esc_sequence) >> ++                { >> ++                  for (i = 0; i < mblength; i++) >> ++                    { >> ++                      width += 4; >> ++                      chars += 4; >> ++                      *s++ = '\\'; >> ++                      sprintf (esc_buff, "%03o", (unsigned char) >> mbc[i]); >> ++                      for (j = 0; j <= 2; ++j) >> ++                        *s++ = (int) esc_buff[j]; >> ++                    } >> ++                } >> ++              else if (use_cntrl_prefix) >> ++                { >> ++                  if (wc < 0200) >> ++                    { >> ++                      width += 2; >> ++                      chars += 2; >> ++                      *s++ = '^'; >> ++                      *s++ = wc ^ 0100; >> ++                    } >> ++                  else >> ++                    { >> ++                      for (i = 0; i < mblength; i++) >> ++                        { >> ++                          width += 4; >> ++                          chars += 4; >> ++                          *s++ = '\\'; >> ++                          sprintf (esc_buff, "%03o", (unsigned char) >> mbc[i]); >> ++                          for (j = 0; j <= 2; ++j) >> ++                            *s++ = (int) esc_buff[j]; >> ++                        } >> ++                    } >> ++                } >> ++              else if (wc == L'\b') >> ++                { >> ++                  width += -1; >> ++                  chars += 1; >> ++                  *s++ = c; >> ++                } >> ++              else >> ++                { >> ++                  width += 0; >> ++                  chars += mblength; >> ++                  for (i = 0; i < mblength; i++) >> ++                    *s++ = mbc[i]; >> ++                } >> ++            } >> ++          else >> ++            { >> ++              width += wc_width; >> ++              chars += mblength; >> ++              for (i = 0; i < mblength; i++) >> ++                *s++ = mbc[i]; >> ++            } >> ++        } >> ++      memmove (mbc, mbc + mblength, MB_CUR_MAX - mblength); >> ++      mbc_pos -= mblength; >> ++    } >> ++ >> ++  /* Too many backspaces must put us in position 0 -- never >> negative. */ >> ++  if (width < 0 && input_position == 0) >> ++    { >> ++      chars = 0; >> ++      input_position = 0; >> ++    } >> ++  else if (width < 0 && input_position <= -width) >> ++    input_position = 0; >> ++  else >> ++   input_position += width; >> ++ >> ++  return chars; >> ++} >> ++#endif >> ++ >> + /* We've just printed some files and need to clean up things before >> +    looking for more options and printing the next batch of files. >> +  >> +diff -Naurp coreutils-8.25-orig/src/sort.c coreutils-8.25/src/sort.c >> +--- coreutils-8.25-orig/src/sort.c 2016-01-16 13:09:33.000000000 >> -0600 >> ++++ coreutils-8.25/src/sort.c 2016-02-08 19:07:10.310944648 -0600 >> +@@ -29,6 +29,14 @@ >> + #include >> + #include >> + #include >> ++#if HAVE_WCHAR_H >> ++# include >> ++#endif >> ++/* Get isw* functions. */ >> ++#if HAVE_WCTYPE_H >> ++# include >> ++#endif >> ++ >> + #include "system.h" >> + #include "argmatch.h" >> + #include "error.h" >> +@@ -163,14 +171,39 @@ static int decimal_point; >> + /* Thousands separator; if -1, then there isn't one.  */ >> + static int thousands_sep; >> +  >> ++/* True if -f is specified.  */ >> ++static bool folding; >> ++ >> + /* Nonzero if the corresponding locales are hard.  */ >> + static bool hard_LC_COLLATE; >> +-#if HAVE_NL_LANGINFO >> ++#if HAVE_LANGINFO_CODESET >> + static bool hard_LC_TIME; >> + #endif >> +  >> + #define NONZERO(x) ((x) != 0) >> +  >> ++/* get a multibyte character's byte length. */ >> ++#define GET_BYTELEN_OF_CHAR(LIM, PTR, MBLENGTH, >> STATE)                        \ >> ++  do                                                                         >> \ >> ++    {                                                                        >>  \ >> ++      wchar_t >> wc;                                                        \ >> ++      mbstate_t >> state_bak;                                                \ >> ++                                                                        \ >> ++      state_bak = >> STATE;                                                \ >> ++      mblength = mbrtowc (&wc, PTR, LIM - PTR, >> &STATE);                        \ >> ++                                                                        \ >> ++      switch >> (MBLENGTH)                                                        \ >> ++        {                                                                \ >> ++        case >> (size_t)-1:                                                \ >> ++        case >> (size_t)-2:                                                \ >> ++          STATE = >> state_bak;                                                \ >> ++                /* Fall through. >> */                                        \ >> ++        case >> 0:                                                                \ >> ++          MBLENGTH = >> 1;                                                        \ >> ++      }                                                                      >>    \ >> ++    }                                                                        >>  \ >> ++  while (0) >> ++ >> + /* The kind of blanks for '-b' to skip in various options. */ >> + enum blanktype { bl_start, bl_end, bl_both }; >> +  >> +@@ -344,13 +377,11 @@ static bool reverse; >> +    they were read if all keys compare equal.  */ >> + static bool stable; >> +  >> +-/* If TAB has this value, blanks separate fields.  */ >> +-enum { TAB_DEFAULT = CHAR_MAX + 1 }; >> +- >> +-/* Tab character separating fields.  If TAB_DEFAULT, then fields are >> ++/* Tab character separating fields.  If tab_length is 0, then fields >> are >> +    separated by the empty string between a non-blank character and a >> blank >> +    character. */ >> +-static int tab = TAB_DEFAULT; >> ++static char tab[MB_LEN_MAX + 1]; >> ++static size_t tab_length = 0; >> +  >> + /* Flag to remove consecutive duplicate lines from the output. >> +    Only the last of a sequence of equal lines will be output. */ >> +@@ -810,6 +841,46 @@ reap_all (void) >> +     reap (-1); >> + } >> +  >> ++/* Function pointers. */ >> ++static void >> ++(*inittables) (void); >> ++static char * >> ++(*begfield) (const struct line*, const struct keyfield *); >> ++static char * >> ++(*limfield) (const struct line*, const struct keyfield *); >> ++static void >> ++(*skipblanks) (char **ptr, char *lim); >> ++static int >> ++(*getmonth) (char const *, size_t, char **); >> ++static int >> ++(*keycompare) (const struct line *, const struct line *); >> ++static int >> ++(*numcompare) (const char *, const char *); >> ++ >> ++/* Test for white space multibyte character. >> ++   Set LENGTH the byte length of investigated multibyte character. >> */ >> ++#if HAVE_MBRTOWC >> ++static int >> ++ismbblank (const char *str, size_t len, size_t *length) >> ++{ >> ++  size_t mblength; >> ++  wchar_t wc; >> ++  mbstate_t state; >> ++ >> ++  memset (&state, '\0', sizeof(mbstate_t)); >> ++  mblength = mbrtowc (&wc, str, len, &state); >> ++ >> ++  if (mblength == (size_t)-1 || mblength == (size_t)-2) >> ++    { >> ++      *length = 1; >> ++      return 0; >> ++    } >> ++ >> ++  *length = (mblength < 1) ? 1 : mblength; >> ++  return iswblank (wc) || wc == '\n'; >> ++} >> ++#endif >> ++ >> + /* Clean up any remaining temporary files.  */ >> +  >> + static void >> +@@ -1254,7 +1325,7 @@ zaptemp (char const *name) >> +   free (node); >> + } >> +  >> +-#if HAVE_NL_LANGINFO >> ++#if HAVE_LANGINFO_CODESET >> +  >> + static int >> + struct_month_cmp (void const *m1, void const *m2) >> +@@ -1269,7 +1340,7 @@ struct_month_cmp (void const *m1, void c >> + /* Initialize the character class tables. */ >> +  >> + static void >> +-inittables (void) >> ++inittables_uni (void) >> + { >> +   size_t i; >> +  >> +@@ -1281,7 +1352,7 @@ inittables (void) >> +       fold_toupper[i] = toupper (i); >> +     } >> +  >> +-#if HAVE_NL_LANGINFO >> ++#if HAVE_LANGINFO_CODESET >> +   /* If we're not in the "C" locale, read different names for >> months.  */ >> +   if (hard_LC_TIME) >> +     { >> +@@ -1363,6 +1434,84 @@ specify_nmerge (int oi, char c, char con >> +     xstrtol_fatal (e, oi, c, long_options, s); >> + } >> +  >> ++#if HAVE_MBRTOWC >> ++static void >> ++inittables_mb (void) >> ++{ >> ++  int i, j, k, l; >> ++  char *name, *s, *lc_time, *lc_ctype; >> ++  size_t s_len, mblength; >> ++  char mbc[MB_LEN_MAX]; >> ++  wchar_t wc, pwc; >> ++  mbstate_t state_mb, state_wc; >> ++ >> ++  lc_time = setlocale (LC_TIME, ""); >> ++  if (lc_time) >> ++    lc_time = xstrdup (lc_time); >> ++ >> ++  lc_ctype = setlocale (LC_CTYPE, ""); >> ++  if (lc_ctype) >> ++    lc_ctype = xstrdup (lc_ctype); >> ++ >> ++  if (lc_time && lc_ctype) >> ++    /* temporarily set LC_CTYPE to match LC_TIME, so that we can >> convert >> ++     * the names of months to upper case */ >> ++    setlocale (LC_CTYPE, lc_time); >> ++ >> ++  for (i = 0; i < MONTHS_PER_YEAR; i++) >> ++    { >> ++      s = (char *) nl_langinfo (ABMON_1 + i); >> ++      s_len = strlen (s); >> ++      monthtab[i].name = name = (char *) xmalloc (s_len + 1); >> ++      monthtab[i].val = i + 1; >> ++ >> ++      memset (&state_mb, '\0', sizeof (mbstate_t)); >> ++      memset (&state_wc, '\0', sizeof (mbstate_t)); >> ++ >> ++      for (j = 0; j < s_len;) >> ++        { >> ++          if (!ismbblank (s + j, s_len - j, &mblength)) >> ++            break; >> ++          j += mblength; >> ++        } >> ++ >> ++      for (k = 0; j < s_len;) >> ++        { >> ++          mblength = mbrtowc (&wc, (s + j), (s_len - j), &state_mb); >> ++          assert (mblength != (size_t)-1 && mblength != (size_t)-2); >> ++          if (mblength == 0) >> ++            break; >> ++ >> ++          pwc = towupper (wc); >> ++          if (pwc == wc) >> ++            { >> ++              memcpy (mbc, s + j, mblength); >> ++              j += mblength; >> ++            } >> ++          else >> ++            { >> ++              j += mblength; >> ++              mblength = wcrtomb (mbc, pwc, &state_wc); >> ++              assert (mblength != (size_t)0 && mblength != >> (size_t)-1); >> ++            } >> ++ >> ++          for (l = 0; l < mblength; l++) >> ++            name[k++] = mbc[l]; >> ++        } >> ++      name[k] = '\0'; >> ++    } >> ++  qsort ((void *) monthtab, MONTHS_PER_YEAR, >> ++      sizeof (struct month), struct_month_cmp); >> ++ >> ++  if (lc_time && lc_ctype) >> ++    /* restore the original locales */ >> ++    setlocale (LC_CTYPE, lc_ctype); >> ++ >> ++  free (lc_ctype); >> ++  free (lc_time); >> ++} >> ++#endif >> ++ >> + /* Specify the amount of main memory to use when sorting.  */ >> + static void >> + specify_sort_size (int oi, char c, char const *s) >> +@@ -1596,7 +1745,7 @@ buffer_linelim (struct buffer const *buf >> +    by KEY in LINE. */ >> +  >> + static char * >> +-begfield (struct line const *line, struct keyfield const *key) >> ++begfield_uni (const struct line *line, const struct keyfield *key) >> + { >> +   char *ptr = line->text, *lim = ptr + line->length - 1; >> +   size_t sword = key->sword; >> +@@ -1605,10 +1754,10 @@ begfield (struct line const *line, struc >> +   /* The leading field separator itself is included in a field when >> -t >> +      is absent.  */ >> +  >> +-  if (tab != TAB_DEFAULT) >> ++  if (tab_length) >> +     while (ptr < lim && sword--) >> +       { >> +-        while (ptr < lim && *ptr != tab) >> ++        while (ptr < lim && *ptr != tab[0]) >> +           ++ptr; >> +         if (ptr < lim) >> +           ++ptr; >> +@@ -1634,11 +1783,70 @@ begfield (struct line const *line, struc >> +   return ptr; >> + } >> +  >> ++#if HAVE_MBRTOWC >> ++static char * >> ++begfield_mb (const struct line *line, const struct keyfield *key) >> ++{ >> ++  int i; >> ++  char *ptr = line->text, *lim = ptr + line->length - 1; >> ++  size_t sword = key->sword; >> ++  size_t schar = key->schar; >> ++  size_t mblength; >> ++  mbstate_t state; >> ++ >> ++  memset (&state, '\0', sizeof(mbstate_t)); >> ++ >> ++  if (tab_length) >> ++    while (ptr < lim && sword--) >> ++      { >> ++        while (ptr < lim && memcmp (ptr, tab, tab_length) != 0) >> ++          { >> ++            GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state); >> ++            ptr += mblength; >> ++          } >> ++        if (ptr < lim) >> ++          { >> ++            GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state); >> ++            ptr += mblength; >> ++          } >> ++      } >> ++  else >> ++    while (ptr < lim && sword--) >> ++      { >> ++        while (ptr < lim && ismbblank (ptr, lim - ptr, &mblength)) >> ++          ptr += mblength; >> ++        if (ptr < lim) >> ++          { >> ++            GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state); >> ++            ptr += mblength; >> ++          } >> ++        while (ptr < lim && !ismbblank (ptr, lim - ptr, &mblength)) >> ++          ptr += mblength; >> ++      } >> ++ >> ++  if (key->skipsblanks) >> ++    while (ptr < lim && ismbblank (ptr, lim - ptr, &mblength)) >> ++      ptr += mblength; >> ++ >> ++  for (i = 0; i < schar; i++) >> ++    { >> ++      GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state); >> ++ >> ++      if (ptr + mblength > lim) >> ++        break; >> ++      else >> ++        ptr += mblength; >> ++    } >> ++ >> ++  return ptr; >> ++} >> ++#endif >> ++ >> + /* Return the limit of (a pointer to the first character after) the >> field >> +    in LINE specified by KEY. */ >> +  >> + static char * >> +-limfield (struct line const *line, struct keyfield const *key) >> ++limfield_uni (const struct line *line, const struct keyfield *key) >> + { >> +   char *ptr = line->text, *lim = ptr + line->length - 1; >> +   size_t eword = key->eword, echar = key->echar; >> +@@ -1653,10 +1861,10 @@ limfield (struct line const *line, struc >> +      'beginning' is the first character following the delimiting >> TAB. >> +      Otherwise, leave PTR pointing at the first 'blank' character >> after >> +      the preceding field.  */ >> +-  if (tab != TAB_DEFAULT) >> ++  if (tab_length) >> +     while (ptr < lim && eword--) >> +       { >> +-        while (ptr < lim && *ptr != tab) >> ++        while (ptr < lim && *ptr != tab[0]) >> +           ++ptr; >> +         if (ptr < lim && (eword || echar)) >> +           ++ptr; >> +@@ -1702,10 +1910,10 @@ limfield (struct line const *line, struc >> +      */ >> +  >> +   /* Make LIM point to the end of (one byte past) the current >> field.  */ >> +-  if (tab != TAB_DEFAULT) >> ++  if (tab_length) >> +     { >> +       char *newlim; >> +-      newlim = memchr (ptr, tab, lim - ptr); >> ++      newlim = memchr (ptr, tab[0], lim - ptr); >> +       if (newlim) >> +         lim = newlim; >> +     } >> +@@ -1736,6 +1944,130 @@ limfield (struct line const *line, struc >> +   return ptr; >> + } >> +  >> ++#if HAVE_MBRTOWC >> ++static char * >> ++limfield_mb (const struct line *line, const struct keyfield *key) >> ++{ >> ++  char *ptr = line->text, *lim = ptr + line->length - 1; >> ++  size_t eword = key->eword, echar = key->echar; >> ++  int i; >> ++  size_t mblength; >> ++  mbstate_t state; >> ++ >> ++  if (echar == 0) >> ++    eword++; /* skip all of end field. */ >> ++ >> ++  memset (&state, '\0', sizeof(mbstate_t)); >> ++ >> ++  if (tab_length) >> ++    while (ptr < lim && eword--) >> ++      { >> ++        while (ptr < lim && memcmp (ptr, tab, tab_length) != 0) >> ++          { >> ++            GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state); >> ++            ptr += mblength; >> ++          } >> ++        if (ptr < lim && (eword | echar)) >> ++          { >> ++            GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state); >> ++            ptr += mblength; >> ++          } >> ++      } >> ++  else >> ++    while (ptr < lim && eword--) >> ++      { >> ++        while (ptr < lim && ismbblank (ptr, lim - ptr, &mblength)) >> ++          ptr += mblength; >> ++        if (ptr < lim) >> ++          { >> ++            GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state); >> ++            ptr += mblength; >> ++          } >> ++        while (ptr < lim && !ismbblank (ptr, lim - ptr, &mblength)) >> ++          ptr += mblength; >> ++      } >> ++ >> ++ >> ++# ifdef POSIX_UNSPECIFIED >> ++  /* Make LIM point to the end of (one byte past) the current >> field.  */ >> ++  if (tab_length) >> ++    { >> ++      char *newlim, *p; >> ++ >> ++      newlim = NULL; >> ++      for (p = ptr; p < lim;) >> ++         { >> ++          if (memcmp (p, tab, tab_length) == 0) >> ++            { >> ++              newlim = p; >> ++              break; >> ++            } >> ++ >> ++          GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state); >> ++          p += mblength; >> ++        } >> ++    } >> ++  else >> ++    { >> ++      char *newlim; >> ++      newlim = ptr; >> ++ >> ++      while (newlim < lim && ismbblank (newlim, lim - newlim, >> &mblength)) >> ++        newlim += mblength; >> ++      if (ptr < lim) >> ++        { >> ++          GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state); >> ++          ptr += mblength; >> ++        } >> ++      while (newlim < lim && !ismbblank (newlim, lim - newlim, >> &mblength)) >> ++        newlim += mblength; >> ++      lim = newlim; >> ++    } >> ++# endif >> ++ >> ++  if (echar != 0) >> ++  { >> ++    /* If we're skipping leading blanks, don't start counting >> characters >> ++     *      until after skipping past any leading blanks.  */ >> ++    if (key->skipeblanks) >> ++      while (ptr < lim && ismbblank (ptr, lim - ptr, &mblength)) >> ++        ptr += mblength; >> ++ >> ++    memset (&state, '\0', sizeof(mbstate_t)); >> ++ >> ++    /* Advance PTR by ECHAR (if possible), but no further than >> LIM.  */ >> ++    for (i = 0; i < echar; i++) >> ++     { >> ++        GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state); >> ++ >> ++        if (ptr + mblength > lim) >> ++          break; >> ++        else >> ++          ptr += mblength; >> ++      } >> ++  } >> ++ >> ++  return ptr; >> ++} >> ++#endif >> ++ >> ++static void >> ++skipblanks_uni (char **ptr, char *lim) >> ++{ >> ++  while (*ptr < lim && blanks[to_uchar (**ptr)]) >> ++    ++(*ptr); >> ++} >> ++ >> ++#if HAVE_MBRTOWC >> ++static void >> ++skipblanks_mb (char **ptr, char *lim) >> ++{ >> ++  size_t mblength; >> ++  while (*ptr < lim && ismbblank (*ptr, lim - *ptr, &mblength)) >> ++    (*ptr) += mblength; >> ++} >> ++#endif >> ++ >> + /* Fill BUF reading from FP, moving buf->left bytes from the end >> +    of buf->buf to the beginning first.  If EOF is reached and the >> +    file wasn't terminated by a newline, supply one.  Set up BUF's >> line >> +@@ -1822,8 +2154,22 @@ fillbuf (struct buffer *buf, FILE *fp, c >> +                   else >> +                     { >> +                       if (key->skipsblanks) >> +-                        while (blanks[to_uchar (*line_start)]) >> +-                          line_start++; >> ++                        { >> ++#if HAVE_MBRTOWC >> ++                          if (MB_CUR_MAX > 1) >> ++                            { >> ++                              size_t mblength; >> ++                              while (line_start < line->keylim && >> ++                                     ismbblank (line_start, >> ++                                                line->keylim - >> line_start, >> ++                                                &mblength)) >> ++                                line_start += mblength; >> ++                            } >> ++                          else >> ++#endif >> ++                          while (blanks[to_uchar (*line_start)]) >> ++                            line_start++; >> ++                        } >> +                       line->keybeg = line_start; >> +                     } >> +                 } >> +@@ -1944,7 +2290,7 @@ human_numcompare (char const *a, char co >> +    hideously fast. */ >> +  >> + static int >> +-numcompare (char const *a, char const *b) >> ++numcompare_uni (const char *a, const char *b) >> + { >> +   while (blanks[to_uchar (*a)]) >> +     a++; >> +@@ -1954,6 +2300,25 @@ numcompare (char const *a, char const *b >> +   return strnumcmp (a, b, decimal_point, thousands_sep); >> + } >> +  >> ++#if HAVE_MBRTOWC >> ++static int >> ++numcompare_mb (const char *a, const char *b) >> ++{ >> ++  size_t mblength, len; >> ++  len = strlen (a); /* okay for UTF-8 */ >> ++  while (*a && ismbblank (a, len > MB_CUR_MAX ? MB_CUR_MAX : len, >> &mblength)) >> ++    { >> ++      a += mblength; >> ++      len -= mblength; >> ++    } >> ++  len = strlen (b); /* okay for UTF-8 */ >> ++  while (*b && ismbblank (b, len > MB_CUR_MAX ? MB_CUR_MAX : len, >> &mblength)) >> ++    b += mblength; >> ++ >> ++  return strnumcmp (a, b, decimal_point, thousands_sep); >> ++} >> ++#endif /* HAV_EMBRTOWC */ >> ++ >> + /* Work around a problem whereby the long double value returned by >> glibc's >> +    strtold ("NaN", ...) contains uninitialized bits: clear all bytes >> of >> +    A and B before calling strtold.  FIXME: remove this function once >> +@@ -2004,7 +2369,7 @@ general_numcompare (char const *sa, char >> +    Return 0 if the name in S is not recognized.  */ >> +  >> + static int >> +-getmonth (char const *month, char **ea) >> ++getmonth_uni (char const *month, size_t len, char **ea) >> + { >> +   size_t lo = 0; >> +   size_t hi = MONTHS_PER_YEAR; >> +@@ -2280,15 +2645,14 @@ debug_key (struct line const *line, stru >> +           char saved = *lim; >> +           *lim = '\0'; >> +  >> +-          while (blanks[to_uchar (*beg)]) >> +-            beg++; >> ++          skipblanks (&beg, lim); >> +  >> +           char *tighter_lim = beg; >> +  >> +           if (lim < beg) >> +             tighter_lim = lim; >> +           else if (key->month) >> +-            getmonth (beg, &tighter_lim); >> ++            getmonth (beg, lim-beg, &tighter_lim); >> +           else if (key->general_numeric) >> +             ignore_value (strtold (beg, &tighter_lim)); >> +           else if (key->numeric || key->human_numeric) >> +@@ -2432,7 +2796,7 @@ key_warnings (struct keyfield const *gke >> +       bool maybe_space_aligned = !hard_LC_COLLATE && >> default_key_compare >> (key) >> +                                  && !(key->schar || key->echar); >> +       bool line_offset = key->eword == 0 && key->echar != 0; /* >> -k1.x,1.y  */ >> +-      if (!gkey_only && tab == TAB_DEFAULT && !line_offset >> ++      if (!gkey_only && !tab_length && !line_offset >> +           && ((!key->skipsblanks && !(implicit_skip || >> maybe_space_aligned)) >> +               || (!key->skipsblanks && key->schar) >> +               || (!key->skipeblanks && key->echar))) >> +@@ -2490,11 +2854,87 @@ key_warnings (struct keyfield const *gke >> +     error (0, 0, _("option '-r' only applies to last-resort >> comparison")); >> + } >> +  >> ++#if HAVE_MBRTOWC >> ++static int >> ++getmonth_mb (const char *s, size_t len, char **ea) >> ++{ >> ++  char *month; >> ++  register size_t i; >> ++  register int lo = 0, hi = MONTHS_PER_YEAR, result; >> ++  char *tmp; >> ++  size_t wclength, mblength; >> ++  const char *pp; >> ++  const wchar_t *wpp; >> ++  wchar_t *month_wcs; >> ++  mbstate_t state; >> ++ >> ++  while (len > 0 && ismbblank (s, len, &mblength)) >> ++    { >> ++      s += mblength; >> ++      len -= mblength; >> ++    } >> ++ >> ++  if (len == 0) >> ++    return 0; >> ++ >> ++  if (SIZE_MAX - len < 1) >> ++    xalloc_die (); >> ++ >> ++  month = (char *) xnmalloc (len + 1, MB_CUR_MAX); >> ++ >> ++  pp = tmp = (char *) xnmalloc (len + 1, MB_CUR_MAX); >> ++  memcpy (tmp, s, len); >> ++  tmp[len] = '\0'; >> ++  wpp = month_wcs = (wchar_t *) xnmalloc (len + 1, sizeof >> (wchar_t)); >> ++  memset (&state, '\0', sizeof (mbstate_t)); >> ++ >> ++  wclength = mbsrtowcs (month_wcs, &pp, len + 1, &state); >> ++  if (wclength == (size_t)-1 || pp != NULL) >> ++    error (SORT_FAILURE, 0, _("Invalid multibyte input %s."), >> quote(s)); >> ++ >> ++  for (i = 0; i < wclength; i++) >> ++    { >> ++      month_wcs[i] = towupper(month_wcs[i]); >> ++      if (iswblank (month_wcs[i])) >> ++        { >> ++          month_wcs[i] = L'\0'; >> ++          break; >> ++        } >> ++    } >> ++ >> ++  mblength = wcsrtombs (month, &wpp, (len + 1) * MB_CUR_MAX, >> &state); >> ++  assert (mblength != (-1) && wpp == NULL); >> ++ >> ++  do >> ++    { >> ++      int ix = (lo + hi) / 2; >> ++ >> ++      if (strncmp (month, monthtab[ix].name, strlen >> (monthtab[ix].name)) < >> 0) >> ++        hi = ix; >> ++      else >> ++        lo = ix; >> ++    } >> ++  while (hi - lo > 1); >> ++ >> ++  result = (!strncmp (month, monthtab[lo].name, strlen >> (monthtab[lo].name)) >> ++      ? monthtab[lo].val : 0); >> ++ >> ++  if (ea && result) >> ++     *ea = (char*) s + strlen (monthtab[lo].name); >> ++ >> ++  free (month); >> ++  free (tmp); >> ++  free (month_wcs); >> ++ >> ++  return result; >> ++} >> ++#endif >> ++ >> + /* Compare two lines A and B trying every key in sequence until >> there >> +    are no more keys or a difference is found. */ >> +  >> + static int >> +-keycompare (struct line const *a, struct line const *b) >> ++keycompare_uni (const struct line *a, const struct line *b) >> + { >> +   struct keyfield *key = keylist; >> +  >> +@@ -2579,7 +3019,7 @@ keycompare (struct line const *a, struct >> +           else if (key->human_numeric) >> +             diff = human_numcompare (ta, tb); >> +           else if (key->month) >> +-            diff = getmonth (ta, NULL) - getmonth (tb, NULL); >> ++            diff = getmonth (ta, tlena, NULL) - getmonth (tb, tlenb, >> NULL); >> +           else if (key->random) >> +             diff = compare_random (ta, tlena, tb, tlenb); >> +           else if (key->version) >> +@@ -2695,6 +3135,211 @@ keycompare (struct line const *a, struct >> +   return key->reverse ? -diff : diff; >> + } >> +  >> ++#if HAVE_MBRTOWC >> ++static int >> ++keycompare_mb (const struct line *a, const struct line *b) >> ++{ >> ++  struct keyfield *key = keylist; >> ++ >> ++  /* For the first iteration only, the key positions have been >> ++     precomputed for us. */ >> ++  char *texta = a->keybeg; >> ++  char *textb = b->keybeg; >> ++  char *lima = a->keylim; >> ++  char *limb = b->keylim; >> ++ >> ++  size_t mblength_a, mblength_b; >> ++  wchar_t wc_a, wc_b; >> ++  mbstate_t state_a, state_b; >> ++ >> ++  int diff = 0; >> ++ >> ++  memset (&state_a, '\0', sizeof(mbstate_t)); >> ++  memset (&state_b, '\0', sizeof(mbstate_t)); >> ++  /* Ignore keys with start after end.  */ >> ++  if (a->keybeg - a->keylim > 0) >> ++    return 0; >> ++ >> ++ >> ++              /* Ignore and/or translate chars before comparing.  */ >> ++# define IGNORE_CHARS(NEW_LEN, LEN, TEXT, COPY, WC, MBLENGTH, >> STATE)        \ >> ++  do                                                                         >> \ >> ++    {                                                                        >>  \ >> ++      wchar_t >> uwc;                                                        \ >> ++      char >> mbc[MB_LEN_MAX];                                                \ >> ++      mbstate_t >> state_wc;                                                \ >> ++                                                                        \ >> ++      for (NEW_LEN = i = 0; i < >> LEN;)                                        \ >> ++        {                                                                \ >> ++          mbstate_t >> state_bak;                                                \ >> ++                                                                        \ >> ++          state_bak = >> STATE;                                                \ >> ++          MBLENGTH = mbrtowc (&WC, TEXT + i, LEN - i, >> &STATE);                \ >> ++                                                                        \ >> ++          if (MBLENGTH == (size_t)-2 || MBLENGTH == (size_t)- >> 1                \ >> ++              || MBLENGTH == >> 0)                                                \ >> ++            {                                                                >>  \ >> ++              if (MBLENGTH == (size_t)-2 || MBLENGTH == >> (size_t)-1)        \ >> ++                STATE = >> state_bak;                                        \ >> ++              if >> (!ignore)                                                \ >> ++                COPY[NEW_LEN++] = >> TEXT[i];                                \ >> ++              i++;                                                         \ >> ++              continue;                                                      >>    \ >> ++            }                                                                >>  \ >> ++                                                                        \ >> ++          if >> (ignore)                                                        \ >> ++            {                                                                >>  \ >> ++              if ((ignore == nonprinting && !iswprint >> (WC))                \ >> ++                   || (ignore == >> nondictionary                                \ >> ++                       && !iswalnum (WC) && !iswblank >> (WC)))                \ >> ++                {                                                        \ >> ++                  i += >> MBLENGTH;                                        \ >> ++                  continue;                                                \ >> ++                }                                                        \ >> ++            }                                                                >>  \ >> ++                                                                        \ >> ++          if >> (translate)                                                \ >> ++            {                                                                >>  \ >> ++                                                                        \ >> ++              uwc = >> towupper(WC);                                        \ >> ++              if (WC == >> uwc)                                                \ >> ++                {                                                        \ >> ++                  memcpy (mbc, TEXT + i, >> MBLENGTH);                        \ >> ++                  i += >> MBLENGTH;                                        \ >> ++                }                                                        \ >> ++              else                                                        \ >> ++                {                                                        \ >> ++                  i += >> MBLENGTH;                                        \ >> ++                  WC = >> uwc;                                                \ >> ++                  memset (&state_wc, '\0', sizeof >> (mbstate_t));                \ >> ++                                                                        \ >> ++                  MBLENGTH = wcrtomb (mbc, WC, >> &state_wc);                \ >> ++                  assert (MBLENGTH != (size_t)-1 && MBLENGTH != >> 0);        \ >> ++                }                                                        \ >> ++                                                                        \ >> ++              for (j = 0; j < MBLENGTH; >> j++)                                \ >> ++                COPY[NEW_LEN++] = >> mbc[j];                                \ >> ++            }                                                                >>  \ >> ++          else                                                               >>   \ >> ++            for (j = 0; j < MBLENGTH; >> j++)                                \ >> ++              COPY[NEW_LEN++] = >> TEXT[i++];                                \ >> ++        }                                                                \ >> ++      COPY[NEW_LEN] = >> '\0';                                                \ >> ++    }                                                                        >>  \ >> ++  while (0) >> ++ >> ++      /* Actually compare the fields. */ >> ++ >> ++  for (;;) >> ++    { >> ++      /* Find the lengths. */ >> ++      size_t lena = lima <= texta ? 0 : lima - texta; >> ++      size_t lenb = limb <= textb ? 0 : limb - textb; >> ++ >> ++      char enda IF_LINT (= 0); >> ++      char endb IF_LINT (= 0); >> ++ >> ++      char const *translate = key->translate; >> ++      bool const *ignore = key->ignore; >> ++ >> ++      if (ignore || translate) >> ++        { >> ++          if (SIZE_MAX - lenb - 2 < lena) >> ++            xalloc_die (); >> ++          char *copy_a = (char *) xnmalloc (lena + lenb + 2, >> MB_CUR_MAX); >> ++          char *copy_b = copy_a + lena * MB_CUR_MAX + 1; >> ++          size_t new_len_a, new_len_b; >> ++          size_t i, j; >> ++ >> ++          IGNORE_CHARS (new_len_a, lena, texta, copy_a, >> ++                        wc_a, mblength_a, state_a); >> ++          IGNORE_CHARS (new_len_b, lenb, textb, copy_b, >> ++                        wc_b, mblength_b, state_b); >> ++          texta = copy_a; textb = copy_b; >> ++          lena = new_len_a; lenb = new_len_b; >> ++        } >> ++      else >> ++        { >> ++          /* Use the keys in-place, temporarily null-terminated.  */ >> ++          enda = texta[lena]; texta[lena] = '\0'; >> ++          endb = textb[lenb]; textb[lenb] = '\0'; >> ++        } >> ++ >> ++      if (key->random) >> ++        diff = compare_random (texta, lena, textb, lenb); >> ++      else if (key->numeric | key->general_numeric | >> key->human_numeric) >> ++        { >> ++          char savea = *lima, saveb = *limb; >> ++ >> ++          *lima = *limb = '\0'; >> ++          diff = (key->numeric ? numcompare (texta, textb) >> ++                  : key->general_numeric ? general_numcompare >> (texta, textb) >> ++                  : human_numcompare (texta, textb)); >> ++          *lima = savea, *limb = saveb; >> ++        } >> ++      else if (key->version) >> ++        diff = filevercmp (texta, textb); >> ++      else if (key->month) >> ++        diff = getmonth (texta, lena, NULL) - getmonth (textb, lenb, >> NULL); >> ++      else if (lena == 0) >> ++        diff = - NONZERO (lenb); >> ++      else if (lenb == 0) >> ++        diff = 1; >> ++      else if (hard_LC_COLLATE && !folding) >> ++        { >> ++          diff = xmemcoll0 (texta, lena + 1, textb, lenb + 1); >> ++        } >> ++      else >> ++        { >> ++          diff = memcmp (texta, textb, MIN (lena, lenb)); >> ++          if (diff == 0) >> ++            diff = lena < lenb ? -1 : lena != lenb; >> ++        } >> ++ >> ++      if (ignore || translate) >> ++        free (texta); >> ++      else >> ++        { >> ++          texta[lena] = enda; >> ++          textb[lenb] = endb; >> ++        } >> ++ >> ++      if (diff) >> ++        goto not_equal; >> ++ >> ++      key = key->next; >> ++      if (! key) >> ++        break; >> ++ >> ++      /* Find the beginning and limit of the next field.  */ >> ++      if (key->eword != -1) >> ++        lima = limfield (a, key), limb = limfield (b, key); >> ++      else >> ++        lima = a->text + a->length - 1, limb = b->text + b->length - >> 1; >> ++ >> ++      if (key->sword != -1) >> ++        texta = begfield (a, key), textb = begfield (b, key); >> ++      else >> ++        { >> ++          texta = a->text, textb = b->text; >> ++          if (key->skipsblanks) >> ++            { >> ++              while (texta < lima && ismbblank (texta, lima - texta, >> &mblength_a)) >> ++                texta += mblength_a; >> ++              while (textb < limb && ismbblank (textb, limb - textb, >> &mblength_b)) >> ++                textb += mblength_b; >> ++            } >> ++        } >> ++    } >> ++ >> ++not_equal: >> ++  if (key && key->reverse) >> ++    return -diff; >> ++  else >> ++    return diff; >> ++} >> ++#endif >> ++ >> + /* Compare two lines A and B, returning negative, zero, or positive >> +    depending on whether A compares less than, equal to, or greater >> than B. >> */ >> +  >> +@@ -2722,7 +3367,7 @@ compare (struct line const *a, struct li >> +     diff = - NONZERO (blen); >> +   else if (blen == 0) >> +     diff = 1; >> +-  else if (hard_LC_COLLATE) >> ++  else if (hard_LC_COLLATE && !folding) >> +     { >> +       /* Note xmemcoll0 is a performance enhancement as >> +          it will not unconditionally write '\0' after the >> +@@ -4121,6 +4766,7 @@ set_ordering (char const *s, struct keyf >> +           break; >> +         case 'f': >> +           key->translate = fold_toupper; >> ++          folding = true; >> +           break; >> +         case 'g': >> +           key->general_numeric = true; >> +@@ -4199,7 +4845,7 @@ main (int argc, char **argv) >> +   initialize_exit_failure (SORT_FAILURE); >> +  >> +   hard_LC_COLLATE = hard_locale (LC_COLLATE); >> +-#if HAVE_NL_LANGINFO >> ++#if HAVE_LANGINFO_CODESET >> +   hard_LC_TIME = hard_locale (LC_TIME); >> + #endif >> +  >> +@@ -4220,6 +4866,29 @@ main (int argc, char **argv) >> +       thousands_sep = -1; >> +   } >> +  >> ++#if HAVE_MBRTOWC >> ++  if (MB_CUR_MAX > 1) >> ++    { >> ++      inittables = inittables_mb; >> ++      begfield = begfield_mb; >> ++      limfield = limfield_mb; >> ++      skipblanks = skipblanks_mb; >> ++      getmonth = getmonth_mb; >> ++      keycompare = keycompare_mb; >> ++      numcompare = numcompare_mb; >> ++    } >> ++  else >> ++#endif >> ++    { >> ++      inittables = inittables_uni; >> ++      begfield = begfield_uni; >> ++      limfield = limfield_uni; >> ++      skipblanks = skipblanks_uni; >> ++      getmonth = getmonth_uni; >> ++      keycompare = keycompare_uni; >> ++      numcompare = numcompare_uni; >> ++    } >> ++ >> +   have_read_stdin = false; >> +   inittables (); >> +  >> +@@ -4494,13 +5163,34 @@ main (int argc, char **argv) >> +  >> +         case 't': >> +           { >> +-            char newtab = optarg[0]; >> +-            if (! newtab) >> ++            char newtab[MB_LEN_MAX + 1]; >> ++            size_t newtab_length = 1; >> ++            strncpy (newtab, optarg, MB_LEN_MAX); >> ++            if (! newtab[0]) >> +               error (SORT_FAILURE, 0, _("empty tab")); >> +-            if (optarg[1]) >> ++#if HAVE_MBRTOWC >> ++            if (MB_CUR_MAX > 1) >> ++              { >> ++                wchar_t wc; >> ++                mbstate_t state; >> ++ >> ++                memset (&state, '\0', sizeof (mbstate_t)); >> ++                newtab_length = mbrtowc (&wc, newtab, strnlen >> (newtab, >> ++                                                               MB_LEN_MAX), >> ++                                         &state); >> ++                switch (newtab_length) >> ++                  { >> ++                  case (size_t) -1: >> ++                  case (size_t) -2: >> ++                  case 0: >> ++                    newtab_length = 1; >> ++                  } >> ++              } >> ++#endif >> ++            if (newtab_length == 1 && optarg[1]) >> +               { >> +                 if (STREQ (optarg, "\\0")) >> +-                  newtab = '\0'; >> ++                  newtab[0] = '\0'; >> +                 else >> +                   { >> +                     /* Provoke with 'sort -txx'.  Complain about >> +@@ -4511,9 +5201,12 @@ main (int argc, char **argv) >> +                            quote (optarg)); >> +                   } >> +               } >> +-            if (tab != TAB_DEFAULT && tab != newtab) >> ++            if (tab_length >> ++                && (tab_length != newtab_length >> ++                    || memcmp (tab, newtab, tab_length) != 0)) >> +               error (SORT_FAILURE, 0, _("incompatible tabs")); >> +-            tab = newtab; >> ++            memcpy (tab, newtab, newtab_length); >> ++            tab_length = newtab_length; >> +           } >> +           break; >> +  >> +@@ -4751,12 +5444,10 @@ main (int argc, char **argv) >> +       sort (files, nfiles, outfile, nthreads); >> +     } >> +  >> +-#ifdef lint >> +   if (files_from) >> +     readtokens0_free (&tok); >> +   else >> +     free (files); >> +-#endif >> +  >> +   if (have_read_stdin && fclose (stdin) == EOF) >> +     die (_("close failed"), "-"); >> +diff -Naurp coreutils-8.25-orig/src/unexpand.c >> coreutils-8.25/src/unexpand.c >> +--- coreutils-8.25-orig/src/unexpand.c 2016-01-01 07:48:50.000000000 >> -0600 >> ++++ coreutils-8.25/src/unexpand.c 2016-02-08 19:07:10.311944651 -0600 >> +@@ -38,12 +38,29 @@ >> + #include >> + #include >> + #include >> ++ >> ++/* Get mbstate_t, mbrtowc(), wcwidth(). */ >> ++#if HAVE_WCHAR_H >> ++# include >> ++#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 "unexpand" >> +  >> +@@ -103,6 +120,210 @@ static struct option const longopts[] = >> +   {NULL, 0, NULL, 0} >> + }; >> +  >> ++static FILE *next_file (FILE *fp); >> ++ >> ++#if HAVE_MBRTOWC >> ++static void >> ++unexpand_multibyte (void) >> ++{ >> ++  FILE *fp; /* Input stream. */ >> ++  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. */ >> ++  wint_t wc; /* A gotten wide character. */ >> ++  size_t mblength; /* The byte size of a multibyte character >> ++    which shows as same character as WC. */ >> ++  bool prev_tab = false; >> ++ >> ++  /* Index in `tab_list' of next tabstop: */ >> ++  int tab_index = 0; /* For calculating width of pending >> tabs. */ >> ++  int print_tab_index = 0; /* For printing as many tabs as possible. >> */ >> ++  unsigned int column = 0; /* Column on screen of next char. */ >> ++  int next_tab_column; /* Column the next tab stop is on. */ >> ++  int convert = 1; /* If nonzero, perform translations. */ >> ++  unsigned int pending = 0; /* Pending columns of blanks. */ >> ++ >> ++  fp = next_file ((FILE *) NULL); >> ++  if (fp == NULL) >> ++    return; >> ++ >> ++  memset (&o_state, '\0', sizeof(mbstate_t)); >> ++  memset (&i_state, '\0', sizeof(mbstate_t)); >> ++ >> ++  for (;;) >> ++    { >> ++      if (buflen < MB_LEN_MAX && !feof(fp) && !ferror(fp)) >> ++ { >> ++   memmove (buf, bufpos, buflen); >> ++   buflen += fread (buf + buflen, sizeof(char), BUFSIZ, fp); >> ++   bufpos = buf; >> ++ } >> ++ >> ++      /* Get a wide character. */ >> ++      if (buflen < 1) >> ++ { >> ++   mblength = 1; >> ++   wc = WEOF; >> ++ } >> ++      else >> ++ { >> ++   i_state_bak = i_state; >> ++   mblength = mbrtowc ((wchar_t *)&wc, bufpos, buflen, &i_state); >> ++ } >> ++ >> ++      if (mblength == (size_t)-1 || mblength == (size_t)-2) >> ++ { >> ++   i_state = i_state_bak; >> ++   wc = L'\0'; >> ++ } >> ++ >> ++      if (wc == L' ' && convert && column < INT_MAX) >> ++ { >> ++   ++pending; >> ++   ++column; >> ++ } >> ++      else if (wc == L'\t' && convert) >> ++ { >> ++   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) >> ++ { >> ++   convert = 0; /* Ran out of tab stops. */ >> ++   goto flush_pend_mb; >> ++ } >> ++     } >> ++   else >> ++     { >> ++       next_tab_column = column + tab_size - column % tab_size; >> ++     } >> ++   pending += next_tab_column - column; >> ++   column = next_tab_column; >> ++ } >> ++      else >> ++ { >> ++flush_pend_mb: >> ++   /* Flush pending spaces.  Print as many tabs as possible, >> ++      then print the rest as spaces. */ >> ++   if (pending == 1 && column != 1 && !prev_tab) >> ++     { >> ++       putchar (' '); >> ++       pending = 0; >> ++     } >> ++   column -= pending; >> ++   while (pending > 0) >> ++     { >> ++       if (tab_size == 0) >> ++ { >> ++   /* Do not let print_tab_index == first_free_tab; >> ++      stop when it is 1 less. */ >> ++   while (print_tab_index < first_free_tab - 1 >> ++       && column >= tab_list[print_tab_index]) >> ++     print_tab_index++; >> ++   next_tab_column = tab_list[print_tab_index]; >> ++   if (print_tab_index < first_free_tab - 1) >> ++     print_tab_index++; >> ++ } >> ++       else >> ++ { >> ++   next_tab_column = >> ++     column + tab_size - column % tab_size; >> ++ } >> ++       if (next_tab_column - column <= pending) >> ++ { >> ++   putchar ('\t'); >> ++   pending -= next_tab_column - column; >> ++   column = next_tab_column; >> ++ } >> ++       else >> ++ { >> ++   --print_tab_index; >> ++   column += pending; >> ++   while (pending != 0) >> ++     { >> ++       putchar (' '); >> ++       pending--; >> ++     } >> ++ } >> ++     } >> ++ >> ++   if (wc == WEOF) >> ++     { >> ++       fp = next_file (fp); >> ++       if (fp == NULL) >> ++ break;          /* No more files. */ >> ++       else >> ++ { >> ++   memset (&i_state, '\0', sizeof(mbstate_t)); >> ++   continue; >> ++ } >> ++     } >> ++ >> ++   if (mblength == (size_t)-1 || mblength == (size_t)-2) >> ++     { >> ++       if (convert) >> ++ { >> ++   ++column; >> ++   if (convert_entire_line == 0) >> ++     convert = 0; >> ++ } >> ++       mblength = 1; >> ++       putchar (buf[0]); >> ++     } >> ++   else if (mblength == 0) >> ++     { >> ++       if (convert && convert_entire_line == 0) >> ++ convert = 0; >> ++       mblength = 1; >> ++       putchar ('\0'); >> ++     } >> ++   else >> ++     { >> ++       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; >> ++     } >> ++ } >> ++ >> ++       if (wc == L'\n') >> ++ { >> ++   tab_index = print_tab_index = 0; >> ++   column = pending = 0; >> ++   convert = 1; >> ++ } >> ++       fwrite (bufpos, sizeof(char), mblength, stdout); >> ++     } >> ++ } >> ++      prev_tab = wc == L'\t'; >> ++      buflen -= mblength; >> ++      bufpos += mblength; >> ++    } >> ++} >> ++#endif >> ++ >> ++ >> + void >> + usage (int status) >> + { >> +@@ -523,7 +744,12 @@ main (int argc, char **argv) >> +  >> +   file_list = (optind < argc ? &argv[optind] : stdin_argv); >> +  >> +-  unexpand (); >> ++#if HAVE_MBRTOWC >> ++  if (MB_CUR_MAX > 1) >> ++    unexpand_multibyte (); >> ++  else >> ++#endif >> ++    unexpand (); >> +  >> +   if (have_read_stdin && fclose (stdin) != 0) >> +     error (EXIT_FAILURE, errno, "-"); >> +diff -Naurp coreutils-8.25-orig/src/uniq.c coreutils-8.25/src/uniq.c >> +--- coreutils-8.25-orig/src/uniq.c 2016-01-13 05:08:59.000000000 >> -0600 >> ++++ coreutils-8.25/src/uniq.c 2016-02-08 19:07:10.312944654 -0600 >> +@@ -21,6 +21,17 @@ >> + #include >> + #include >> +  >> ++/* Get mbstate_t, mbrtowc(). */ >> ++#if HAVE_WCHAR_H >> ++# include >> ++#endif >> ++ >> ++/* Get isw* functions. */ >> ++#if HAVE_WCTYPE_H >> ++# include >> ++#endif >> ++#include >> ++ >> + #include "system.h" >> + #include "argmatch.h" >> + #include "linebuffer.h" >> +@@ -33,6 +44,18 @@ >> + #include "xstrtol.h" >> + #include "memcasecmp.h" >> + #include "quote.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" >> +@@ -143,6 +166,10 @@ enum >> +   GROUP_OPTION = CHAR_MAX + 1 >> + }; >> +  >> ++/* Function pointers. */ >> ++static char * >> ++(*find_field) (struct linebuffer *line); >> ++ >> + static struct option const longopts[] = >> + { >> +   {"count", no_argument, NULL, 'c'}, >> +@@ -252,7 +279,7 @@ size_opt (char const *opt, char const *m >> +    return a pointer to the beginning of the line's field to be >> compared. */ >> +  >> + static char * _GL_ATTRIBUTE_PURE >> +-find_field (struct linebuffer const *line) >> ++find_field_uni (struct linebuffer *line) >> + { >> +   size_t count; >> +   char const *lp = line->buffer; >> +@@ -272,6 +299,83 @@ find_field (struct linebuffer const *lin >> +   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 = 0; >> ++ >> ++  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) || wc == '\n')) >> ++            { >> ++              pos += mblength; >> ++              break; >> ++            } >> ++          pos += mblength; >> ++        } >> ++ >> ++      while (pos < size) >> ++        { >> ++          MBCHAR_TO_WCHAR (wc, mblength, lp, pos, size, statep, >> convfail); >> ++ >> ++          if (!convfail && (iswblank (wc) || wc == '\n')) >> ++            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. >> +@@ -280,6 +384,8 @@ find_field (struct linebuffer const *lin >> + 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) >> +@@ -287,15 +393,104 @@ different (char *old, char *new, size_t >> +  >> +   if (ignore_case) >> +     { >> +-      /* FIXME: This should invoke strcoll somehow.  */ >> +-      return oldlen != newlen || memcasecmp (old, new, oldlen); >> ++      size_t i; >> ++ >> ++      copy_old = xmalloc (oldlen + 1); >> ++      copy_new = xmalloc (oldlen + 1); >> ++ >> ++      for (i = 0; i < oldlen; i++) >> ++        { >> ++          copy_old[i] = toupper (old[i]); >> ++          copy_new[i] = toupper (new[i]); >> ++        } >> ++      bool rc = xmemcoll (copy_old, oldlen, copy_new, newlen); >> ++      free (copy_old); >> ++      free (copy_new); >> ++      return rc; >> +     } >> +-  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] = xmalloc (len[i] + 1); >> ++      memset (copy[i], '\0', 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; >> ++                      size_t mblen; >> ++ >> ++                      memset (&state_wc, '\0', sizeof(mbstate_t)); >> ++                      mblen = wcrtomb (copy[i] + j, uwc, &state_wc); >> ++                      assert (mblen != (size_t)-1); >> ++                    } >> ++                  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; >> ++    } >> ++  int rc = xmemcoll (copy[0], len[0], copy[1], len[1]); >> ++  free (copy[0]); >> ++  free (copy[1]); >> ++  return rc; >> ++ >> ++} >> ++#endif >> ++ >> + /* Output the line in linebuffer LINE to standard output >> +    provided that the switches say it should be output. >> +    MATCH is true if the line matches the previous line. >> +@@ -359,19 +554,38 @@ check_file (const char *infile, const ch >> +       char *prevfield IF_LINT ( = NULL); >> +       size_t prevlen IF_LINT ( = 0); >> +       bool first_group_printed = false; >> ++#if HAVE_MBRTOWC >> ++      mbstate_t prevstate; >> ++ >> ++      memset (&prevstate, '\0', sizeof (mbstate_t)); >> ++#endif >> +  >> +       while (!feof (stdin)) >> +         { >> +           char *thisfield; >> +           size_t thislen; >> +           bool new_group; >> ++#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; >> +  >> ++              new_group = (prevline->length == 0 >> ++                           || different_multi (thisfield, prevfield, >> ++                                               thislen, prevlen, >> ++                                               thisstate, >> prevstate)); >> ++            } >> ++          else >> ++#endif >> +           new_group = (prevline->length == 0 >> +                        || different (thisfield, prevfield, thislen, >> prevlen)); >> +  >> +@@ -389,6 +603,10 @@ check_file (const char *infile, const ch >> +               SWAP_LINES (prevline, thisline); >> +               prevfield = thisfield; >> +               prevlen = thislen; >> ++#if HAVE_MBRTOWC >> ++              if (MB_CUR_MAX > 1) >> ++                prevstate = thisstate; >> ++#endif >> +               first_group_printed = true; >> +             } >> +         } >> +@@ -401,17 +619,26 @@ check_file (const char *infile, const ch >> +       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 = thisline->state; >> ++#endif >> +           if (readlinebuffer_delim (thisline, stdin, delimiter) == >> 0) >> +             { >> +               if (ferror (stdin)) >> +@@ -420,6 +647,14 @@ check_file (const char *infile, const ch >> +             } >> +           thisfield = find_field (thisline); >> +           thislen = thisline->length - 1 - (thisfield - >> thisline->buffer); >> ++#if HAVE_MBRTOWC >> ++          if (MB_CUR_MAX > 1) >> ++            { >> ++              match = !different_multi (thisfield, prevfield, >> ++                                thislen, prevlen, thisstate, >> prevstate); >> ++            } >> ++          else >> ++#endif >> +           match = !different (thisfield, prevfield, thislen, >> prevlen); >> +           match_count += match; >> +  >> +@@ -452,6 +687,9 @@ check_file (const char *infile, const ch >> +               SWAP_LINES (prevline, thisline); >> +               prevfield = thisfield; >> +               prevlen = thislen; >> ++#if HAVE_MBRTOWC >> ++              prevstate = thisstate; >> ++#endif >> +               if (!match) >> +                 match_count = 0; >> +             } >> +@@ -498,6 +736,19 @@ main (int argc, char **argv) >> +  >> +   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; >> +diff -Naurp coreutils-8.25-orig/tests/i18n/sort-month.sh coreutils- >> 8.25/tests/i18n/sort-month.sh >> +--- coreutils-8.25-orig/tests/i18n/sort-month.sh 1969-12-31 >> 18:00:00.000000000 -0600 >> ++++ coreutils-8.25/tests/i18n/sort-month.sh 2016-02-08 >> 19:07:10.312944654 -0600 >> +@@ -0,0 +1,34 @@ >> ++#!/bin/sh >> ++# Verify sort -M multi-byte support. >> ++ >> ++. "${srcdir=.}/tests/init.sh"; path_prepend_ ./src >> ++print_ver_ sort >> ++require_valgrind_ >> ++ >> ++# Skip this test if some deallocations are >> ++# avoided at process end. >> ++grep '^#define lint 1' $CONFIG_HEADER > /dev/null || >> ++  skip_ 'Allocation checks only work reliably in "lint" mode' >> ++ >> ++export LC_ALL=en_US.UTF-8 >> ++locale -k LC_CTYPE | grep -q "charmap.*UTF-8" \ >> ++  || skip_ "No UTF-8 locale available" >> ++ >> ++# Note the use of ɑ here which expands to >> ++# a wider representation upon case conversion >> ++# which triggered an assertion in sort -M >> ++cat < exp >> ++. >> ++ɑ >> ++EOF >> ++ >> ++ >> ++# check large mem leak with --month-sort >> ++# https://bugzilla.redhat.com/show_bug.cgi?id=1259942 >> ++valgrind --leak-check=full \ >> ++         --error-exitcode=1 --errors-for-leak-kinds=definite \ >> ++         sort -M < exp > out || fail=1 >> ++compare exp out || { fail=1; cat out; } >> ++ >> ++ >> ++Exit $fail >> +diff -Naurp coreutils-8.25-orig/tests/i18n/sort.sh coreutils- >> 8.25/tests/i18n/sort.sh >> +--- coreutils-8.25-orig/tests/i18n/sort.sh 1969-12-31 >> 18:00:00.000000000 -0600 >> ++++ coreutils-8.25/tests/i18n/sort.sh 2016-02-08 19:07:10.312944654 >> -0600 >> +@@ -0,0 +1,29 @@ >> ++#!/bin/sh >> ++# Verify sort's multi-byte support. >> ++ >> ++. "${srcdir=.}/tests/init.sh"; path_prepend_ ./src >> ++print_ver_ sort >> ++ >> ++export LC_ALL=en_US.UTF-8 >> ++locale -k LC_CTYPE | grep -q "charmap.*UTF-8" \ >> ++  || skip_ "No UTF-8 locale available" >> ++ >> ++# Enable heap consistency checkng on older systems >> ++export MALLOC_CHECK_=2 >> ++ >> ++ >> ++# check buffer overflow issue due to >> ++# expanding multi-byte representation due to case conversion >> ++# https://bugzilla.suse.com/show_bug.cgi?id=928749 >> ++cat < exp >> ++. >> ++ɑ >> ++EOF >> ++cat < out || fail=1 >> ++. >> ++ɑ >> ++EOF >> ++compare exp out || { fail=1; cat out; } >> ++ >> ++ >> ++Exit $fail >> +diff -Naurp coreutils-8.25-orig/tests/local.mk >> coreutils-8.25/tests/local.mk >> +--- coreutils-8.25-orig/tests/local.mk 2016-01-16 12:18:13.000000000 >> -0600 >> ++++ coreutils-8.25/tests/local.mk 2016-02-08 19:07:10.313944658 -0600 >> +@@ -344,6 +344,9 @@ all_tests = \ >> +   tests/misc/sort-discrim.sh \ >> +   tests/misc/sort-files0-from.pl \ >> +   tests/misc/sort-float.sh \ >> ++  tests/misc/sort-mb-tests.sh \ >> ++  tests/i18n/sort.sh \ >> ++  tests/i18n/sort-month.sh \ >> +   tests/misc/sort-merge.pl \ >> +   tests/misc/sort-merge-fdlimit.sh \ >> +   tests/misc/sort-month.sh \ >> +diff -Naurp coreutils-8.25-orig/tests/misc/cut.pl coreutils- >> 8.25/tests/misc/cut.pl >> +--- coreutils-8.25-orig/tests/misc/cut.pl 2016-01-16 >> 12:18:13.000000000 -0600 >> ++++ coreutils-8.25/tests/misc/cut.pl 2016-02-08 19:07:10.314944661 >> -0600 >> +@@ -23,9 +23,11 @@ use strict; >> + # Turn off localization of executable's output. >> + @ENV{qw(LANGUAGE LANG LC_ALL)} = ('C') x 3; >> +  >> +-my $mb_locale = $ENV{LOCALE_FR_UTF8}; >> ++my $mb_locale; >> ++# uncommented enable multibyte paths >> ++$mb_locale = $ENV{LOCALE_FR_UTF8}; >> + ! defined $mb_locale || $mb_locale eq 'none' >> +-  and $mb_locale = 'C'; >> ++ and $mb_locale = 'C'; >> +  >> + my $prog = 'cut'; >> + my $try = "Try '$prog --help' for more information.\n"; >> +@@ -240,6 +242,7 @@ if ($mb_locale ne 'C') >> +         my @new_t = @$t; >> +         my $test_name = shift @new_t; >> +  >> ++        next if ($test_name =~ "newline-[12][0-9]"); >> +         push @new, ["$test_name-mb", @new_t, {ENV => >> "LC_ALL=$mb_locale"}]; >> +       } >> +     push @Tests, @new; >> +diff -Naurp coreutils-8.25-orig/tests/misc/expand.pl coreutils- >> 8.25/tests/misc/expand.pl >> +--- coreutils-8.25-orig/tests/misc/expand.pl 2016-01-16 >> 12:18:13.000000000 -0600 >> ++++ coreutils-8.25/tests/misc/expand.pl 2016-02-08 19:07:10.314944661 >> -0600 >> +@@ -23,6 +23,15 @@ use strict; >> + # Turn off localization of executable's output. >> + @ENV{qw(LANGUAGE LANG LC_ALL)} = ('C') x 3; >> +  >> ++#comment out next line to disable multibyte tests >> ++my $mb_locale = $ENV{LOCALE_FR_UTF8}; >> ++! defined $mb_locale || $mb_locale eq 'none' >> ++ and $mb_locale = 'C'; >> ++ >> ++my $prog = 'expand'; >> ++my $try = "Try \`$prog --help' for more information.\n"; >> ++my $inval = "$prog: invalid byte, character or field list\n$try"; >> ++ >> + my @Tests = >> +   ( >> +    ['t1', '--tabs=3',     {IN=>"a\tb"}, {OUT=>"a  b"}], >> +@@ -31,6 +40,37 @@ my @Tests = >> +    ['i2', '--tabs=3 -i', {IN=>" \ta\tb"}, {OUT=>"   a\tb"}], >> +   ); >> +  >> ++if ($mb_locale ne 'C') >> ++  { >> ++    # Duplicate each test vector, appending "-mb" to the test name >> and >> ++    # inserting {ENV => "LC_ALL=$mb_locale"} in the copy, so that we >> ++    # provide coverage for the distro-added multi-byte code paths. >> ++    my @new; >> ++    foreach my $t (@Tests) >> ++      { >> ++        my @new_t = @$t; >> ++        my $test_name = shift @new_t; >> ++ >> ++        # Depending on whether expand is multi-byte-patched, >> ++        # it emits different diagnostics: >> ++        #   non-MB: invalid byte or field list >> ++        #   MB:     invalid byte, character or field list >> ++        # Adjust the expected error output accordingly. >> ++        if (grep {ref $_ eq 'HASH' && exists $_->{ERR} && $_->{ERR} >> eq >> $inval} >> ++            (@new_t)) >> ++          { >> ++            my $sub = {ERR_SUBST => 's/, character//'}; >> ++            push @new_t, $sub; >> ++            push @$t, $sub; >> ++          } >> ++        push @new, ["$test_name-mb", @new_t, {ENV => >> "LC_ALL=$mb_locale"}]; >> ++      } >> ++    push @Tests, @new; >> ++  } >> ++ >> ++ >> ++(a)Tests = triple_test \@Tests; >> ++ >> + my $save_temps = $ENV{DEBUG}; >> + my $verbose = $ENV{VERBOSE}; >> +  >> +diff -Naurp coreutils-8.25-orig/tests/misc/fold.pl coreutils- >> 8.25/tests/misc/fold.pl >> +--- coreutils-8.25-orig/tests/misc/fold.pl 2016-01-16 >> 12:18:13.000000000 -0600 >> ++++ coreutils-8.25/tests/misc/fold.pl 2016-02-08 19:07:10.314944661 >> -0600 >> +@@ -20,9 +20,18 @@ use strict; >> +  >> + (my $program_name = $0) =~ s|.*/||; >> +  >> ++my $prog = 'fold'; >> ++my $try = "Try \`$prog --help' for more information.\n"; >> ++my $inval = "$prog: invalid byte, character or field list\n$try"; >> ++ >> + # Turn off localization of executable's output. >> + @ENV{qw(LANGUAGE LANG LC_ALL)} = ('C') x 3; >> +  >> ++# uncommented to enable multibyte paths >> ++my $mb_locale = $ENV{LOCALE_FR_UTF8}; >> ++! defined $mb_locale || $mb_locale eq 'none' >> ++ and $mb_locale = 'C'; >> ++ >> + my @Tests = >> +   ( >> +    ['s1', '-w2 -s', {IN=>"a\t"}, {OUT=>"a\n\t"}], >> +@@ -31,9 +40,48 @@ my @Tests = >> +    ['s4', '-w4 -s', {IN=>"abc ef\n"}, {OUT=>"abc \nef\n"}], >> +   ); >> +  >> ++# Add _POSIX2_VERSION=199209 to the environment of each test >> ++# that uses an old-style option like +1. >> ++if ($mb_locale ne 'C') >> ++  { >> ++    # Duplicate each test vector, appending "-mb" to the test name >> and >> ++    # inserting {ENV => "LC_ALL=$mb_locale"} in the copy, so that we >> ++    # provide coverage for the distro-added multi-byte code paths. >> ++    my @new; >> ++    foreach my $t (@Tests) >> ++      { >> ++        my @new_t = @$t; >> ++        my $test_name = shift @new_t; >> ++ >> ++        # Depending on whether fold is multi-byte-patched, >> ++        # it emits different diagnostics: >> ++        #   non-MB: invalid byte or field list >> ++        #   MB:     invalid byte, character or field list >> ++        # Adjust the expected error output accordingly. >> ++        if (grep {ref $_ eq 'HASH' && exists $_->{ERR} && $_->{ERR} >> eq >> $inval} >> ++            (@new_t)) >> ++          { >> ++            my $sub = {ERR_SUBST => 's/, character//'}; >> ++            push @new_t, $sub; >> ++            push @$t, $sub; >> ++          } >> ++        push @new, ["$test_name-mb", @new_t, {ENV => >> "LC_ALL=$mb_locale"}]; >> ++      } >> ++    push @Tests, @new; >> ++  } >> ++ >> ++(a)Tests = triple_test \@Tests; >> ++ >> ++# Remember that triple_test creates from each test with exactly one >> "IN" >> ++# file two more tests (.p and .r suffix on name) corresponding to >> reading >> ++# input from a file and from a pipe.  The pipe-reading test would >> fail >> ++# due to a race condition about 1 in 20 times. >> ++# Remove the IN_PIPE version of the "output-is-input" test above. >> ++# The others aren't susceptible because they have three inputs each. >> ++(a)Tests = grep {$_->[0] ne 'output-is-input.p'} @Tests; >> ++ >> + my $save_temps = $ENV{DEBUG}; >> + my $verbose = $ENV{VERBOSE}; >> +  >> +-my $prog = 'fold'; >> + my $fail = run_tests ($program_name, $prog, \@Tests, $save_temps, >> $verbose); >> + exit $fail; >> +diff -Naurp coreutils-8.25-orig/tests/misc/join.pl coreutils- >> 8.25/tests/misc/join.pl >> +--- coreutils-8.25-orig/tests/misc/join.pl 2016-01-16 >> 12:18:13.000000000 -0600 >> ++++ coreutils-8.25/tests/misc/join.pl 2016-02-08 19:07:10.315944664 >> -0600 >> +@@ -25,6 +25,15 @@ my $limits = getlimits (); >> +  >> + my $prog = 'join'; >> +  >> ++my $try = "Try \`$prog --help' for more information.\n"; >> ++my $inval = "$prog: invalid byte, character or field list\n$try"; >> ++ >> ++my $mb_locale; >> ++#Comment out next line to disable multibyte tests >> ++$mb_locale = $ENV{LOCALE_FR_UTF8}; >> ++! defined $mb_locale || $mb_locale eq 'none' >> ++  and $mb_locale = 'C'; >> ++ >> + my $delim = chr 0247; >> + sub t_subst ($) >> + { >> +@@ -329,8 +338,49 @@ foreach my $t (@tv) >> +     push @Tests, $new_ent; >> +   } >> +  >> ++# Add _POSIX2_VERSION=199209 to the environment of each test >> ++# that uses an old-style option like +1. >> ++if ($mb_locale ne 'C') >> ++  { >> ++    # Duplicate each test vector, appending "-mb" to the test name >> and >> ++    # inserting {ENV => "LC_ALL=$mb_locale"} in the copy, so that we >> ++    # provide coverage for the distro-added multi-byte code paths. >> ++    my @new; >> ++    foreach my $t (@Tests) >> ++      { >> ++        my @new_t = @$t; >> ++        my $test_name = shift @new_t; >> ++ >> ++        # Depending on whether join is multi-byte-patched, >> ++        # it emits different diagnostics: >> ++        #   non-MB: invalid byte or field list >> ++        #   MB:     invalid byte, character or field list >> ++        # Adjust the expected error output accordingly. >> ++        if (grep {ref $_ eq 'HASH' && exists $_->{ERR} && $_->{ERR} >> eq >> $inval} >> ++            (@new_t)) >> ++          { >> ++            my $sub = {ERR_SUBST => 's/, character//'}; >> ++            push @new_t, $sub; >> ++            push @$t, $sub; >> ++          } >> ++        #Adjust the output some error messages including test_name >> for mb >> ++        if (grep {ref $_ eq 'HASH' && exists $_->{ERR}} >> ++             (@new_t)) >> ++          { >> ++            my $sub2 = {ERR_SUBST => "s/$test_name-mb/$test_name/"}; >> ++            push @new_t, $sub2; >> ++            push @$t, $sub2; >> ++          } >> ++        push @new, ["$test_name-mb", @new_t, {ENV => >> "LC_ALL=$mb_locale"}]; >> ++      } >> ++    push @Tests, @new; >> ++  } >> ++ >> + @Tests = triple_test \@Tests; >> +  >> ++#skip invalid-j-mb test, it is failing because of the format >> ++(a)Tests = grep {$_->[0] ne 'invalid-j-mb'} @Tests; >> ++ >> + my $save_temps = $ENV{DEBUG}; >> + my $verbose = $ENV{VERBOSE}; >> +  >> +diff -Naurp coreutils-8.25-orig/tests/misc/sort-mb-tests.sh >> coreutils- >> 8.25/tests/misc/sort-mb-tests.sh >> +--- coreutils-8.25-orig/tests/misc/sort-mb-tests.sh 1969-12-31 >> 18:00:00.000000000 -0600 >> ++++ coreutils-8.25/tests/misc/sort-mb-tests.sh 2016-02-08 >> 19:07:10.315944664 -0600 >> +@@ -0,0 +1,45 @@ >> ++#!/bin/sh >> ++# Verify sort's multi-byte support. >> ++ >> ++. "${srcdir=.}/tests/init.sh"; path_prepend_ ./src >> ++print_ver_ sort >> ++ >> ++export LC_ALL=en_US.UTF-8 >> ++locale -k LC_CTYPE | grep -q "charmap.*UTF-8" \ >> ++  || skip_ "No UTF-8 locale available" >> ++ >> ++ >> ++cat < exp >> ++Banana＠5 >> ++Apple＠10 >> ++Citrus＠20 >> ++Cherry＠30 >> ++EOF >> ++ >> ++cat < out || fail=1 >> ++Apple＠10 >> ++Banana＠5 >> ++Citrus＠20 >> ++Cherry＠30 >> ++EOF >> ++ >> ++compare exp out || { fail=1; cat out; } >> ++ >> ++ >> ++cat < exp >> ++Citrus＠ＡＡ20＠＠5 >> ++Cherry＠ＡＡ30＠＠10 >> ++Apple＠ＡＡ10＠＠20 >> ++Banana＠ＡＡ5＠＠30 >> ++EOF >> ++ >> ++cat < out || fail=1 >> ++Apple＠ＡＡ10＠＠20 >> ++Banana＠ＡＡ5＠＠30 >> ++Citrus＠ＡＡ20＠＠5 >> ++Cherry＠ＡＡ30＠＠10 >> ++EOF >> ++ >> ++compare exp out || { fail=1; cat out; } >> ++ >> ++Exit $fail >> +diff -Naurp coreutils-8.25-orig/tests/misc/sort-merge.pl coreutils- >> 8.25/tests/misc/sort-merge.pl >> +--- coreutils-8.25-orig/tests/misc/sort-merge.pl 2016-01-16 >> 12:18:14.000000000 -0600 >> ++++ coreutils-8.25/tests/misc/sort-merge.pl 2016-02-08 >> 19:07:10.316944667 -0600 >> +@@ -26,6 +26,15 @@ my $prog = 'sort'; >> + # Turn off localization of executable's output. >> + @ENV{qw(LANGUAGE LANG LC_ALL)} = ('C') x 3; >> +  >> ++my $mb_locale; >> ++# uncommented according to upstream commit enabling multibyte paths >> ++$mb_locale = $ENV{LOCALE_FR_UTF8}; >> ++! defined $mb_locale || $mb_locale eq 'none' >> ++ and $mb_locale = 'C'; >> ++ >> ++my $try = "Try \`$prog --help' for more information.\n"; >> ++my $inval = "$prog: invalid byte, character or field list\n$try"; >> ++ >> + # three empty files and one that says 'foo' >> + my @inputs = (+(map{{IN=> {"empty$_"=> ''}}}1..3), {IN=> {foo=> >> "foo\n"}}); >> +  >> +@@ -77,6 +86,39 @@ my @Tests = >> +         {OUT=>$big_input}], >> +     ); >> +  >> ++# Add _POSIX2_VERSION=199209 to the environment of each test >> ++# that uses an old-style option like +1. >> ++if ($mb_locale ne 'C') >> ++  { >> ++    # Duplicate each test vector, appending "-mb" to the test name >> and >> ++    # inserting {ENV => "LC_ALL=$mb_locale"} in the copy, so that we >> ++    # provide coverage for the distro-added multi-byte code paths. >> ++    my @new; >> ++    foreach my $t (@Tests) >> ++      { >> ++        my @new_t = @$t; >> ++        my $test_name = shift @new_t; >> ++ >> ++        # Depending on whether sort is multi-byte-patched, >> ++        # it emits different diagnostics: >> ++        #   non-MB: invalid byte or field list >> ++        #   MB:     invalid byte, character or field list >> ++        # Adjust the expected error output accordingly. >> ++        if (grep {ref $_ eq 'HASH' && exists $_->{ERR} && $_->{ERR} >> eq >> $inval} >> ++            (@new_t)) >> ++          { >> ++            my $sub = {ERR_SUBST => 's/, character//'}; >> ++            push @new_t, $sub; >> ++            push @$t, $sub; >> ++          } >> ++        next if ($test_name =~ "nmerge-."); >> ++        push @new, ["$test_name-mb", @new_t, {ENV => >> "LC_ALL=$mb_locale"}]; >> ++      } >> ++    push @Tests, @new; >> ++  } >> ++ >> ++(a)Tests = triple_test \@Tests; >> ++ >> + my $save_temps = $ENV{DEBUG}; >> + my $verbose = $ENV{VERBOSE}; >> +  >> +diff -Naurp coreutils-8.25-orig/tests/misc/sort.pl coreutils- >> 8.25/tests/misc/sort.pl >> +--- coreutils-8.25-orig/tests/misc/sort.pl 2016-01-16 >> 12:18:14.000000000 -0600 >> ++++ coreutils-8.25/tests/misc/sort.pl 2016-02-08 19:07:10.316944667 >> -0600 >> +@@ -24,10 +24,15 @@ my $prog = 'sort'; >> + # Turn off localization of executable's output. >> + @ENV{qw(LANGUAGE LANG LC_ALL)} = ('C') x 3; >> +  >> +-my $mb_locale = $ENV{LOCALE_FR_UTF8}; >> ++my $mb_locale; >> ++#Comment out next line to disable multibyte tests >> ++$mb_locale = $ENV{LOCALE_FR_UTF8}; >> + ! defined $mb_locale || $mb_locale eq 'none' >> +   and $mb_locale = 'C'; >> +  >> ++my $try = "Try \`$prog --help' for more information.\n"; >> ++my $inval = "$prog: invalid byte, character or field list\n$try"; >> ++ >> + # Since each test is run with a file name and with redirected stdin, >> + # the name in the diagnostic is either the file name or "-". >> + # Normalize each diagnostic to use '-'. >> +@@ -424,6 +429,38 @@ foreach my $t (@Tests) >> +       } >> +   } >> +  >> ++if ($mb_locale ne 'C') >> ++   { >> ++    # Duplicate each test vector, appending "-mb" to the test name >> and >> ++    # inserting {ENV => "LC_ALL=$mb_locale"} in the copy, so that we >> ++    # provide coverage for the distro-added multi-byte code paths. >> ++    my @new; >> ++    foreach my $t (@Tests) >> ++       { >> ++        my @new_t = @$t; >> ++        my $test_name = shift @new_t; >> ++ >> ++        # Depending on whether sort is multi-byte-patched, >> ++        # it emits different diagnostics: >> ++        #   non-MB: invalid byte or field list >> ++        #   MB:     invalid byte, character or field list >> ++        # Adjust the expected error output accordingly. >> ++        if (grep {ref $_ eq 'HASH' && exists $_->{ERR} && $_->{ERR} >> eq >> $inval} >> ++            (@new_t)) >> ++          { >> ++            my $sub = {ERR_SUBST => 's/, character//'}; >> ++            push @new_t, $sub; >> ++            push @$t, $sub; >> ++          } >> ++        #disable several failing tests until investigation, disable >> all >> tests with envvars set >> ++        next if (grep {ref $_ eq 'HASH' && exists $_->{ENV}} >> (@new_t)); >> ++        next if ($test_name =~ "18g" or $test_name =~ "sort-numeric" >> or >> $test_name =~ "08[ab]" or $test_name =~ "03[def]" or $test_name =~ >> "h4" or >> $test_name =~ "n1" or $test_name =~ "2[01]a"); >> ++        next if ($test_name =~ "11[ab]"); # avoid FP: expected >> result >> differs to MB result due to collation rules. >> ++        push @new, ["$test_name-mb", @new_t, {ENV => >> "LC_ALL=$mb_locale"}]; >> ++       } >> ++    push @Tests, @new; >> ++   } >> ++ >> + @Tests = triple_test \@Tests; >> +  >> + # Remember that triple_test creates from each test with exactly one >> "IN" >> +@@ -433,6 +470,7 @@ foreach my $t (@Tests) >> + # Remove the IN_PIPE version of the "output-is-input" test above. >> + # The others aren't susceptible because they have three inputs each. >> + @Tests = grep {$_->[0] ne 'output-is-input.p'} @Tests; >> ++(a)Tests = grep {$_->[0] ne 'output-is-input-mb.p'} @Tests; >> +  >> + my $save_temps = $ENV{DEBUG}; >> + my $verbose = $ENV{VERBOSE}; >> +diff -Naurp coreutils-8.25-orig/tests/misc/unexpand.pl coreutils- >> 8.25/tests/misc/unexpand.pl >> +--- coreutils-8.25-orig/tests/misc/unexpand.pl 2016-01-16 >> 12:18:14.000000000 -0600 >> ++++ coreutils-8.25/tests/misc/unexpand.pl 2016-02-08 >> 19:07:10.317944671 -0600 >> +@@ -27,6 +27,14 @@ my $limits = getlimits (); >> +  >> + my $prog = 'unexpand'; >> +  >> ++# comment out next line to disable multibyte tests >> ++my $mb_locale = $ENV{LOCALE_FR_UTF8}; >> ++! defined $mb_locale || $mb_locale eq 'none' >> ++ and $mb_locale = 'C'; >> ++ >> ++my $try = "Try \`$prog --help' for more information.\n"; >> ++my $inval = "$prog: invalid byte, character or field list\n$try"; >> ++ >> + my @Tests = >> +     ( >> +      ['a1', {IN=> ' 'x 1 ."y\n"}, {OUT=> ' 'x 1 ."y\n"}], >> +@@ -92,6 +100,37 @@ my @Tests = >> +       {EXIT => 1}, {ERR => "$prog: tab stop value is too large\n"}], >> +     ); >> +  >> ++if ($mb_locale ne 'C') >> ++  { >> ++    # Duplicate each test vector, appending "-mb" to the test name >> and >> ++    # inserting {ENV => "LC_ALL=$mb_locale"} in the copy, so that we >> ++    # provide coverage for the distro-added multi-byte code paths. >> ++    my @new; >> ++    foreach my $t (@Tests) >> ++      { >> ++        my @new_t = @$t; >> ++        my $test_name = shift @new_t; >> ++ >> ++        # Depending on whether unexpand is multi-byte-patched, >> ++        # it emits different diagnostics: >> ++        #   non-MB: invalid byte or field list >> ++        #   MB:     invalid byte, character or field list >> ++        # Adjust the expected error output accordingly. >> ++        if (grep {ref $_ eq 'HASH' && exists $_->{ERR} && $_->{ERR} >> eq >> $inval} >> ++            (@new_t)) >> ++          { >> ++            my $sub = {ERR_SUBST => 's/, character//'}; >> ++            push @new_t, $sub; >> ++            push @$t, $sub; >> ++          } >> ++        next if ($test_name =~ 'b-1'); >> ++        push @new, ["$test_name-mb", @new_t, {ENV => >> "LC_ALL=$mb_locale"}]; >> ++      } >> ++    push @Tests, @new; >> ++  } >> ++ >> ++(a)Tests = triple_test \@Tests; >> ++ >> + my $save_temps = $ENV{DEBUG}; >> + my $verbose = $ENV{VERBOSE}; >> +  >> +diff -Naurp coreutils-8.25-orig/tests/misc/uniq.pl coreutils- >> 8.25/tests/misc/uniq.pl >> +--- coreutils-8.25-orig/tests/misc/uniq.pl 2016-01-16 >> 12:18:14.000000000 -0600 >> ++++ coreutils-8.25/tests/misc/uniq.pl 2016-02-08 19:07:10.317944671 >> -0600 >> +@@ -23,9 +23,17 @@ my $limits = getlimits (); >> + my $prog = 'uniq'; >> + my $try = "Try '$prog --help' for more information.\n"; >> +  >> ++my $inval = "$prog: invalid byte, character or field list\n$try"; >> ++ >> + # Turn off localization of executable's output. >> + @ENV{qw(LANGUAGE LANG LC_ALL)} = ('C') x 3; >> +  >> ++my $mb_locale; >> ++#Comment out next line to disable multibyte tests >> ++$mb_locale = $ENV{LOCALE_FR_UTF8}; >> ++! defined $mb_locale || $mb_locale eq 'none' >> ++  and $mb_locale = 'C'; >> ++ >> + # When possible, create a "-z"-testing variant of each test. >> + sub add_z_variants($) >> + { >> +@@ -262,6 +270,53 @@ foreach my $t (@Tests) >> +       and push @$t, {ENV=>'_POSIX2_VERSION=199209'}; >> +   } >> +  >> ++if ($mb_locale ne 'C') >> ++  { >> ++    # Duplicate each test vector, appending "-mb" to the test name >> and >> ++    # inserting {ENV => "LC_ALL=$mb_locale"} in the copy, so that we >> ++    # provide coverage for the distro-added multi-byte code paths. >> ++    my @new; >> ++    foreach my $t (@Tests) >> ++      { >> ++        my @new_t = @$t; >> ++        my $test_name = shift @new_t; >> ++ >> ++        # Depending on whether uniq is multi-byte-patched, >> ++        # it emits different diagnostics: >> ++        #   non-MB: invalid byte or field list >> ++        #   MB:     invalid byte, character or field list >> ++        # Adjust the expected error output accordingly. >> ++        if (grep {ref $_ eq 'HASH' && exists $_->{ERR} && $_->{ERR} >> eq >> $inval} >> ++            (@new_t)) >> ++          { >> ++            my $sub = {ERR_SUBST => 's/, character//'}; >> ++            push @new_t, $sub; >> ++            push @$t, $sub; >> ++          } >> ++        # In test #145, replace the each ‘...’ by '...'. >> ++        if ($test_name =~ "145") >> ++          { >> ++            my $sub = { ERR_SUBST => "s/‘([^’]+)’/'\$1'/g"}; >> ++            push @new_t, $sub; >> ++            push @$t, $sub; >> ++          } >> ++        next if (   $test_name =~ "schar" >> ++                 or $test_name =~ "^obs-plus" >> ++                 or $test_name =~ "119"); >> ++        push @new, ["$test_name-mb", @new_t, {ENV => >> "LC_ALL=$mb_locale"}]; >> ++      } >> ++    push @Tests, @new; >> ++   } >> ++ >> ++# Remember that triple_test creates from each test with exactly one >> "IN" >> ++# file two more tests (.p and .r suffix on name) corresponding to >> reading >> ++# input from a file and from a pipe.  The pipe-reading test would >> fail >> ++# due to a race condition about 1 in 20 times. >> ++# Remove the IN_PIPE version of the "output-is-input" test above. >> ++# The others aren't susceptible because they have three inputs each. >> ++ >> ++(a)Tests = grep {$_->[0] ne 'output-is-input.p'} @Tests; >> ++ >> + @Tests = add_z_variants \@Tests; >> + @Tests = triple_test \@Tests; >> +  >> +diff -Naurp coreutils-8.25-orig/tests/pr/pr-tests.pl coreutils- >> 8.25/tests/pr/pr-tests.pl >> +--- coreutils-8.25-orig/tests/pr/pr-tests.pl 2016-01-16 >> 12:18:14.000000000 -0600 >> ++++ coreutils-8.25/tests/pr/pr-tests.pl 2016-02-08 19:07:10.318944674 >> -0600 >> +@@ -24,6 +24,15 @@ use strict; >> + my $prog = 'pr'; >> + my $normalize_strerror = "s/': .*/'/"; >> +  >> ++my $mb_locale; >> ++#Uncomment the following line to enable multibyte tests >> ++$mb_locale = $ENV{LOCALE_FR_UTF8}; >> ++! defined $mb_locale || $mb_locale eq 'none' >> ++  and $mb_locale = 'C'; >> ++ >> ++my $try = "Try \`$prog --help' for more information.\n"; >> ++my $inval = "$prog: invalid byte, character or field list\n$try"; >> ++ >> + my @tv = ( >> +  >> + # -b option is no longer an official option. But it's still working >> to >> +@@ -467,8 +476,48 @@ push @Tests, >> +     {IN=>{3=>"x\ty\tz\n"}}, >> +      {OUT=>join("\t", qw(a b c m n o x y z)) . "\n"} ]; >> +  >> ++# Add _POSIX2_VERSION=199209 to the environment of each test >> ++# that uses an old-style option like +1. >> ++if ($mb_locale ne 'C') >> ++  { >> ++    # Duplicate each test vector, appending "-mb" to the test name >> and >> ++    # inserting {ENV => "LC_ALL=$mb_locale"} in the copy, so that we >> ++    # provide coverage for the distro-added multi-byte code paths. >> ++    my @new; >> ++    foreach my $t (@Tests) >> ++      { >> ++        my @new_t = @$t; >> ++        my $test_name = shift @new_t; >> ++ >> ++        # Depending on whether pr is multi-byte-patched, >> ++        # it emits different diagnostics: >> ++        #   non-MB: invalid byte or field list >> ++        #   MB:     invalid byte, character or field list >> ++        # Adjust the expected error output accordingly. >> ++        if (grep {ref $_ eq 'HASH' && exists $_->{ERR} && $_->{ERR} >> eq >> $inval} >> ++            (@new_t)) >> ++          { >> ++            my $sub = {ERR_SUBST => 's/, character//'}; >> ++            push @new_t, $sub; >> ++            push @$t, $sub; >> ++          } >> ++        #temporarily skip some failing tests >> ++        next if ($test_name =~ "col-0" or $test_name =~ >> "col-inval"); >> ++        push @new, ["$test_name-mb", @new_t, {ENV => >> "LC_ALL=$mb_locale"}]; >> ++      } >> ++    push @Tests, @new; >> ++  } >> ++ >> + @Tests = triple_test \@Tests; >> +  >> ++# Remember that triple_test creates from each test with exactly one >> "IN" >> ++# file two more tests (.p and .r suffix on name) corresponding to >> reading >> ++# input from a file and from a pipe.  The pipe-reading test would >> fail >> ++# due to a race condition about 1 in 20 times. >> ++# Remove the IN_PIPE version of the "output-is-input" test above. >> ++# The others aren't susceptible because they have three inputs each. >> ++(a)Tests = grep {$_->[0] ne 'output-is-input.p'} @Tests; >> ++ >> + my $save_temps = $ENV{DEBUG}; >> + my $verbose = $ENV{VERBOSE}; >> +