Tree - rpms/coreutils - CentOS Git server

rpms / coreutils

Blame SOURCES/coreutils-i18n.patch

Blob History Raw

		8d0e4d	`From 29117b2d07af00f4d4b87cf778e4294588ab1a83 Mon Sep 17 00:00:00 2001`
		8d0e4d	`From: Kamil Dudka <kdudka@redhat.com>`
		8d0e4d	`Date: Thu, 1 Dec 2016 15:10:04 +0100`
		8d0e4d	`Subject: [PATCH] coreutils-i18n.patch`
		8d0e4d
		8d0e4d	`TODO: merge upstream`
		8d0e4d	`---`
		8d0e4d	`lib/linebuffer.h \| 8 +`
		8d0e4d	`src/fold.c \| 308 ++++++++++++++++--`
		8d0e4d	`src/join.c \| 359 ++++++++++++++++++---`
		8d0e4d	`src/pr.c \| 443 ++++++++++++++++++++++---`
		8d0e4d	`src/sort.c \| 764 +++++++++++++++++++++++++++++++++++++++++---`
		8d0e4d	`src/uniq.c \| 265 ++++++++++++++-`
		8d0e4d	`tests/i18n/sort.sh \| 29 ++`
		8d0e4d	`tests/local.mk \| 2 +`
		8d0e4d	`tests/misc/expand.pl \| 42 +++`
		8d0e4d	`tests/misc/fold.pl \| 50 ++-`
		8d0e4d	`tests/misc/join.pl \| 50 +++`
		8d0e4d	`tests/misc/sort-mb-tests.sh \| 45 +++`
		8d0e4d	`tests/misc/sort-merge.pl \| 42 +++`
		8d0e4d	`tests/misc/sort.pl \| 40 ++-`
		8d0e4d	`tests/misc/unexpand.pl \| 39 +++`
		8d0e4d	`tests/misc/uniq.pl \| 55 ++++`
		8d0e4d	`tests/pr/pr-tests.pl \| 49 +++`
		8d0e4d	`17 files changed, 2430 insertions(+), 160 deletions(-)`
		8d0e4d	`create mode 100755 tests/i18n/sort.sh`
		8d0e4d	`create mode 100755 tests/misc/sort-mb-tests.sh`
		8d0e4d
		8d0e4d	`diff --git a/lib/linebuffer.h b/lib/linebuffer.h`
		8d0e4d	`index 64181af..9b8fe5a 100644`
		8d0e4d	`--- a/lib/linebuffer.h`
		8d0e4d	`+++ b/lib/linebuffer.h`
		8d0e4d	`@@ -21,6 +21,11 @@`
		8d0e4d
		8d0e4d	`# include <stdio.h>`
		8d0e4d
		8d0e4d	`+/* Get mbstate_t. */`
		8d0e4d	`+# if HAVE_WCHAR_H`
		8d0e4d	`+# include <wchar.h>`
		8d0e4d	`+# endif`
		8d0e4d	`+`
		8d0e4d	`/* A 'struct linebuffer' holds a line of text. */`
		8d0e4d
		8d0e4d	`struct linebuffer`
		8d0e4d	`@@ -28,6 +33,9 @@ struct linebuffer`
		8d0e4d	`size_t size; /* Allocated. */`
		8d0e4d	`size_t length; /* Used. */`
		8d0e4d	`char *buffer;`
		8d0e4d	`+# if HAVE_WCHAR_H`
		8d0e4d	`+ mbstate_t state;`
		8d0e4d	`+# endif`
		8d0e4d	`};`
		8d0e4d
		8d0e4d	`/* Initialize linebuffer LINEBUFFER for use. */`
		8d0e4d	`diff --git a/src/fold.c b/src/fold.c`
		8d0e4d	`index 8cd0d6b..d23edd5 100644`
		8d0e4d	`--- a/src/fold.c`
		8d0e4d	`+++ b/src/fold.c`
		8d0e4d	`@@ -22,12 +22,34 @@`
		8d0e4d	`#include <getopt.h>`
		8d0e4d	`#include <sys/types.h>`
		8d0e4d
		8d0e4d	`+/* Get mbstate_t, mbrtowc(), wcwidth(). */`
		8d0e4d	`+#if HAVE_WCHAR_H`
		8d0e4d	`+# include <wchar.h>`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`+/* Get iswprint(), iswblank(), wcwidth(). */`
		8d0e4d	`+#if HAVE_WCTYPE_H`
		8d0e4d	`+# include <wctype.h>`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`#include "system.h"`
		8d0e4d	`#include "die.h"`
		8d0e4d	`#include "error.h"`
		8d0e4d	`#include "fadvise.h"`
		8d0e4d	`#include "xdectoint.h"`
		8d0e4d
		8d0e4d	`+/* MB_LEN_MAX is incorrectly defined to be 1 in at least one GCC`
		8d0e4d	`+ installation; work around this configuration error. */`
		8d0e4d	`+#if !defined MB_LEN_MAX \|\| MB_LEN_MAX < 2`
		8d0e4d	`+# undef MB_LEN_MAX`
		8d0e4d	`+# define MB_LEN_MAX 16`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`+/* Some systems, like BeOS, have multibyte encodings but lack mbstate_t. */`
		8d0e4d	`+#if HAVE_MBRTOWC && defined mbstate_t`
		8d0e4d	`+# define mbrtowc(pwc, s, n, ps) (mbrtowc) (pwc, s, n, 0)`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`#define TAB_WIDTH 8`
		8d0e4d
		8d0e4d	`/* The official name of this program (e.g., no 'g' prefix). */`
		8d0e4d	`@@ -35,20 +57,41 @@`
		8d0e4d
		8d0e4d	`#define AUTHORS proper_name ("David MacKenzie")`
		8d0e4d
		8d0e4d	`+#define FATAL_ERROR(Message) \`
		8d0e4d	`+ do \`
		8d0e4d	`+ { \`
		8d0e4d	`+ error (0, 0, (Message)); \`
		8d0e4d	`+ usage (2); \`
		8d0e4d	`+ } \`
		8d0e4d	`+ while (0)`
		8d0e4d	`+`
		8d0e4d	`+enum operating_mode`
		8d0e4d	`+{`
		8d0e4d	`+ /* Fold texts by columns that are at the given positions. */`
		8d0e4d	`+ column_mode,`
		8d0e4d	`+`
		8d0e4d	`+ /* Fold texts by bytes that are at the given positions. */`
		8d0e4d	`+ byte_mode,`
		8d0e4d	`+`
		8d0e4d	`+ /* Fold texts by characters that are at the given positions. */`
		8d0e4d	`+ character_mode,`
		8d0e4d	`+};`
		8d0e4d	`+`
		8d0e4d	`+/* The argument shows current mode. (Default: column_mode) */`
		8d0e4d	`+static enum operating_mode operating_mode;`
		8d0e4d	`+`
		8d0e4d	`/* If nonzero, try to break on whitespace. */`
		8d0e4d	`static bool break_spaces;`
		8d0e4d
		8d0e4d	`-/* If nonzero, count bytes, not column positions. */`
		8d0e4d	`-static bool count_bytes;`
		8d0e4d	`-`
		8d0e4d	`/* If nonzero, at least one of the files we read was standard input. */`
		8d0e4d	`static bool have_read_stdin;`
		8d0e4d
		8d0e4d	`-static char const shortopts[] = "bsw:0::1::2::3::4::5::6::7::8::9::";`
		8d0e4d	`+static char const shortopts[] = "bcsw:0::1::2::3::4::5::6::7::8::9::";`
		8d0e4d
		8d0e4d	`static struct option const longopts[] =`
		8d0e4d	`{`
		8d0e4d	`{"bytes", no_argument, NULL, 'b'},`
		8d0e4d	`+ {"characters", no_argument, NULL, 'c'},`
		8d0e4d	`{"spaces", no_argument, NULL, 's'},`
		8d0e4d	`{"width", required_argument, NULL, 'w'},`
		8d0e4d	`{GETOPT_HELP_OPTION_DECL},`
		8d0e4d	`@@ -76,6 +119,7 @@ Wrap input lines in each FILE, writing to standard output.\n\`
		8d0e4d
		8d0e4d	`fputs (_("\`
		8d0e4d	`-b, --bytes count bytes rather than columns\n\`
		8d0e4d	`+ -c, --characters count characters rather than columns\n\`
		8d0e4d	`-s, --spaces break at spaces\n\`
		8d0e4d	`-w, --width=WIDTH use WIDTH columns instead of 80\n\`
		8d0e4d	`"), stdout);`
		8d0e4d	`@@ -93,7 +137,7 @@ Wrap input lines in each FILE, writing to standard output.\n\`
		8d0e4d	`static size_t`
		8d0e4d	`adjust_column (size_t column, char c)`
		8d0e4d	`{`
		8d0e4d	`- if (!count_bytes)`
		8d0e4d	`+ if (operating_mode != byte_mode)`
		8d0e4d	`{`
		8d0e4d	`if (c == '\b')`
		8d0e4d	`{`
		8d0e4d	`@@ -116,30 +160,14 @@ adjust_column (size_t column, char c)`
		8d0e4d	`to stdout, with maximum line length WIDTH.`
		8d0e4d	`Return true if successful. */`
		8d0e4d
		8d0e4d	`-static bool`
		8d0e4d	`-fold_file (char const *filename, size_t width)`
		8d0e4d	`+static void`
		8d0e4d	`+fold_text (FILE istream, size_t width, int saved_errno)`
		8d0e4d	`{`
		8d0e4d	`- FILE *istream;`
		8d0e4d	`int c;`
		8d0e4d	`size_t column = 0; /* Screen column where next char will go. */`
		8d0e4d	`size_t offset_out = 0; /* Index in 'line_out' for next char. */`
		8d0e4d	`static char *line_out = NULL;`
		8d0e4d	`static size_t allocated_out = 0;`
		8d0e4d	`- int saved_errno;`
		8d0e4d	`-`
		8d0e4d	`- if (STREQ (filename, "-"))`
		8d0e4d	`- {`
		8d0e4d	`- istream = stdin;`
		8d0e4d	`- have_read_stdin = true;`
		8d0e4d	`- }`
		8d0e4d	`- else`
		8d0e4d	`- istream = fopen (filename, "r");`
		8d0e4d	`-`
		8d0e4d	`- if (istream == NULL)`
		8d0e4d	`- {`
		8d0e4d	`- error (0, errno, "%s", quotef (filename));`
		8d0e4d	`- return false;`
		8d0e4d	`- }`
		8d0e4d
		8d0e4d	`fadvise (istream, FADVISE_SEQUENTIAL);`
		8d0e4d
		8d0e4d	`@@ -169,6 +197,15 @@ fold_file (char const *filename, size_t width)`
		8d0e4d	`bool found_blank = false;`
		8d0e4d	`size_t logical_end = offset_out;`
		8d0e4d
		8d0e4d	`+ /* If LINE_OUT has no wide character,`
		8d0e4d	`+ put a new wide character in LINE_OUT`
		8d0e4d	`+ if column is bigger than width. */`
		8d0e4d	`+ if (offset_out == 0)`
		8d0e4d	`+ {`
		8d0e4d	`+ line_out[offset_out++] = c;`
		8d0e4d	`+ continue;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`/* Look for the last blank. */`
		8d0e4d	`while (logical_end)`
		8d0e4d	`{`
		8d0e4d	`@@ -215,11 +252,221 @@ fold_file (char const *filename, size_t width)`
		8d0e4d	`line_out[offset_out++] = c;`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`- saved_errno = errno;`
		8d0e4d	`+ *saved_errno = errno;`
		8d0e4d
		8d0e4d	`if (offset_out)`
		8d0e4d	`fwrite (line_out, sizeof (char), (size_t) offset_out, stdout);`
		8d0e4d
		8d0e4d	`+}`
		8d0e4d	`+`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+static void`
		8d0e4d	`+fold_multibyte_text (FILE istream, size_t width, int saved_errno)`
		8d0e4d	`+{`
		8d0e4d	`+ char buf[MB_LEN_MAX + BUFSIZ]; /* For spooling a read byte sequence. */`
		8d0e4d	`+ size_t buflen = 0; /* The length of the byte sequence in buf. */`
		8d0e4d	`+ char bufpos = buf; / Next read position of BUF. */`
		8d0e4d	`+ wint_t wc; /* A gotten wide character. */`
		8d0e4d	`+ size_t mblength; /* The byte size of a multibyte character which shows`
		8d0e4d	`+ as same character as WC. */`
		8d0e4d	`+ mbstate_t state, state_bak; /* State of the stream. */`
		8d0e4d	`+ int convfail = 0; /* 1, when conversion is failed. Otherwise 0. */`
		8d0e4d	`+`
		8d0e4d	`+ static char *line_out = NULL;`
		8d0e4d	+ size_t offset_out = 0; /* Index in `line_out' for next char. */
		8d0e4d	`+ static size_t allocated_out = 0;`
		8d0e4d	`+`
		8d0e4d	`+ int increment;`
		8d0e4d	`+ size_t column = 0;`
		8d0e4d	`+`
		8d0e4d	`+ size_t last_blank_pos;`
		8d0e4d	`+ size_t last_blank_column;`
		8d0e4d	`+ int is_blank_seen;`
		8d0e4d	`+ int last_blank_increment = 0;`
		8d0e4d	`+ int is_bs_following_last_blank;`
		8d0e4d	`+ size_t bs_following_last_blank_num;`
		8d0e4d	`+ int is_cr_after_last_blank;`
		8d0e4d	`+`
		8d0e4d	`+#define CLEAR_FLAGS \`
		8d0e4d	`+ do \`
		8d0e4d	`+ { \`
		8d0e4d	`+ last_blank_pos = 0; \`
		8d0e4d	`+ last_blank_column = 0; \`
		8d0e4d	`+ is_blank_seen = 0; \`
		8d0e4d	`+ is_bs_following_last_blank = 0; \`
		8d0e4d	`+ bs_following_last_blank_num = 0; \`
		8d0e4d	`+ is_cr_after_last_blank = 0; \`
		8d0e4d	`+ } \`
		8d0e4d	`+ while (0)`
		8d0e4d	`+`
		8d0e4d	`+#define START_NEW_LINE \`
		8d0e4d	`+ do \`
		8d0e4d	`+ { \`
		8d0e4d	`+ putchar ('\n'); \`
		8d0e4d	`+ column = 0; \`
		8d0e4d	`+ offset_out = 0; \`
		8d0e4d	`+ CLEAR_FLAGS; \`
		8d0e4d	`+ } \`
		8d0e4d	`+ while (0)`
		8d0e4d	`+`
		8d0e4d	`+ CLEAR_FLAGS;`
		8d0e4d	`+ memset (&state, '\0', sizeof(mbstate_t));`
		8d0e4d	`+`
		8d0e4d	`+ for (;; bufpos += mblength, buflen -= mblength)`
		8d0e4d	`+ {`
		8d0e4d	`+ if (buflen < MB_LEN_MAX && !feof (istream) && !ferror (istream))`
		8d0e4d	`+ {`
		8d0e4d	`+ memmove (buf, bufpos, buflen);`
		8d0e4d	`+ buflen += fread (buf + buflen, sizeof(char), BUFSIZ, istream);`
		8d0e4d	`+ bufpos = buf;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ if (buflen < 1)`
		8d0e4d	`+ break;`
		8d0e4d	`+`
		8d0e4d	`+ /* Get a wide character. */`
		8d0e4d	`+ state_bak = state;`
		8d0e4d	`+ mblength = mbrtowc ((wchar_t *)&wc, bufpos, buflen, &state);`
		8d0e4d	`+`
		8d0e4d	`+ switch (mblength)`
		8d0e4d	`+ {`
		8d0e4d	`+ case (size_t)-1:`
		8d0e4d	`+ case (size_t)-2:`
		8d0e4d	`+ convfail++;`
		8d0e4d	`+ state = state_bak;`
		8d0e4d	`+ /* Fall through. */`
		8d0e4d	`+`
		8d0e4d	`+ case 0:`
		8d0e4d	`+ mblength = 1;`
		8d0e4d	`+ break;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+rescan:`
		8d0e4d	`+ if (operating_mode == byte_mode) /* byte mode */`
		8d0e4d	`+ increment = mblength;`
		8d0e4d	`+ else if (operating_mode == character_mode) /* character mode */`
		8d0e4d	`+ increment = 1;`
		8d0e4d	`+ else /* column mode */`
		8d0e4d	`+ {`
		8d0e4d	`+ if (convfail)`
		8d0e4d	`+ increment = 1;`
		8d0e4d	`+ else`
		8d0e4d	`+ {`
		8d0e4d	`+ switch (wc)`
		8d0e4d	`+ {`
		8d0e4d	`+ case L'\n':`
		8d0e4d	`+ fwrite (line_out, sizeof(char), offset_out, stdout);`
		8d0e4d	`+ START_NEW_LINE;`
		8d0e4d	`+ continue;`
		8d0e4d	`+`
		8d0e4d	`+ case L'\b':`
		8d0e4d	`+ increment = (column > 0) ? -1 : 0;`
		8d0e4d	`+ break;`
		8d0e4d	`+`
		8d0e4d	`+ case L'\r':`
		8d0e4d	`+ increment = -1 * column;`
		8d0e4d	`+ break;`
		8d0e4d	`+`
		8d0e4d	`+ case L'\t':`
		8d0e4d	`+ increment = 8 - column % 8;`
		8d0e4d	`+ break;`
		8d0e4d	`+`
		8d0e4d	`+ default:`
		8d0e4d	`+ increment = wcwidth (wc);`
		8d0e4d	`+ increment = (increment < 0) ? 0 : increment;`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ if (column + increment > width && break_spaces && last_blank_pos)`
		8d0e4d	`+ {`
		8d0e4d	`+ fwrite (line_out, sizeof(char), last_blank_pos, stdout);`
		8d0e4d	`+ putchar ('\n');`
		8d0e4d	`+`
		8d0e4d	`+ offset_out = offset_out - last_blank_pos;`
		8d0e4d	`+ column = column - last_blank_column + ((is_cr_after_last_blank)`
		8d0e4d	`+ ? last_blank_increment : bs_following_last_blank_num);`
		8d0e4d	`+ memmove (line_out, line_out + last_blank_pos, offset_out);`
		8d0e4d	`+ CLEAR_FLAGS;`
		8d0e4d	`+ goto rescan;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ if (column + increment > width && column != 0)`
		8d0e4d	`+ {`
		8d0e4d	`+ fwrite (line_out, sizeof(char), offset_out, stdout);`
		8d0e4d	`+ START_NEW_LINE;`
		8d0e4d	`+ goto rescan;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ if (allocated_out < offset_out + mblength)`
		8d0e4d	`+ {`
		8d0e4d	`+ line_out = X2REALLOC (line_out, &allocated_out);`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ memcpy (line_out + offset_out, bufpos, mblength);`
		8d0e4d	`+ offset_out += mblength;`
		8d0e4d	`+ column += increment;`
		8d0e4d	`+`
		8d0e4d	`+ if (is_blank_seen && !convfail && wc == L'\r')`
		8d0e4d	`+ is_cr_after_last_blank = 1;`
		8d0e4d	`+`
		8d0e4d	`+ if (is_bs_following_last_blank && !convfail && wc == L'\b')`
		8d0e4d	`+ ++bs_following_last_blank_num;`
		8d0e4d	`+ else`
		8d0e4d	`+ is_bs_following_last_blank = 0;`
		8d0e4d	`+`
		8d0e4d	`+ if (break_spaces && !convfail && iswblank (wc))`
		8d0e4d	`+ {`
		8d0e4d	`+ last_blank_pos = offset_out;`
		8d0e4d	`+ last_blank_column = column;`
		8d0e4d	`+ is_blank_seen = 1;`
		8d0e4d	`+ last_blank_increment = increment;`
		8d0e4d	`+ is_bs_following_last_blank = 1;`
		8d0e4d	`+ bs_following_last_blank_num = 0;`
		8d0e4d	`+ is_cr_after_last_blank = 0;`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ *saved_errno = errno;`
		8d0e4d	`+`
		8d0e4d	`+ if (offset_out)`
		8d0e4d	`+ fwrite (line_out, sizeof (char), (size_t) offset_out, stdout);`
		8d0e4d	`+`
		8d0e4d	`+}`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`+/* Fold file FILENAME, or standard input if FILENAME is "-",`
		8d0e4d	`+ to stdout, with maximum line length WIDTH.`
		8d0e4d	`+ Return 0 if successful, 1 if an error occurs. */`
		8d0e4d	`+`
		8d0e4d	`+static bool`
		8d0e4d	`+fold_file (char const *filename, size_t width)`
		8d0e4d	`+{`
		8d0e4d	`+ FILE *istream;`
		8d0e4d	`+ int saved_errno;`
		8d0e4d	`+`
		8d0e4d	`+ if (STREQ (filename, "-"))`
		8d0e4d	`+ {`
		8d0e4d	`+ istream = stdin;`
		8d0e4d	`+ have_read_stdin = 1;`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+ istream = fopen (filename, "r");`
		8d0e4d	`+`
		8d0e4d	`+ if (istream == NULL)`
		8d0e4d	`+ {`
		8d0e4d	`+ error (0, errno, "%s", filename);`
		8d0e4d	`+ return 1;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ /* Define how ISTREAM is being folded. */`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ if (MB_CUR_MAX > 1)`
		8d0e4d	`+ fold_multibyte_text (istream, width, &saved_errno);`
		8d0e4d	`+ else`
		8d0e4d	`+#endif`
		8d0e4d	`+ fold_text (istream, width, &saved_errno);`
		8d0e4d	`+`
		8d0e4d	`if (ferror (istream))`
		8d0e4d	`{`
		8d0e4d	`error (0, saved_errno, "%s", quotef (filename));`
		8d0e4d	`@@ -252,7 +499,8 @@ main (int argc, char **argv)`
		8d0e4d
		8d0e4d	`atexit (close_stdout);`
		8d0e4d
		8d0e4d	`- break_spaces = count_bytes = have_read_stdin = false;`
		8d0e4d	`+ operating_mode = column_mode;`
		8d0e4d	`+ break_spaces = have_read_stdin = false;`
		8d0e4d
		8d0e4d	`while ((optc = getopt_long (argc, argv, shortopts, longopts, NULL)) != -1)`
		8d0e4d	`{`
		8d0e4d	`@@ -261,7 +509,15 @@ main (int argc, char **argv)`
		8d0e4d	`switch (optc)`
		8d0e4d	`{`
		8d0e4d	`case 'b': /* Count bytes rather than columns. */`
		8d0e4d	`- count_bytes = true;`
		8d0e4d	`+ if (operating_mode != column_mode)`
		8d0e4d	`+ FATAL_ERROR (_("only one way of folding may be specified"));`
		8d0e4d	`+ operating_mode = byte_mode;`
		8d0e4d	`+ break;`
		8d0e4d	`+`
		8d0e4d	`+ case 'c':`
		8d0e4d	`+ if (operating_mode != column_mode)`
		8d0e4d	`+ FATAL_ERROR (_("only one way of folding may be specified"));`
		8d0e4d	`+ operating_mode = character_mode;`
		8d0e4d	`break;`
		8d0e4d
		8d0e4d	`case 's': /* Break at word boundaries. */`
		8d0e4d	`diff --git a/src/join.c b/src/join.c`
		8d0e4d	`index 98b461c..9990f38 100644`
		8d0e4d	`--- a/src/join.c`
		8d0e4d	`+++ b/src/join.c`
		8d0e4d	`@@ -22,19 +22,33 @@`
		8d0e4d	`#include <sys/types.h>`
		8d0e4d	`#include <getopt.h>`
		8d0e4d
		8d0e4d	`+/* Get mbstate_t, mbrtowc(), mbrtowc(), wcwidth(). */`
		8d0e4d	`+#if HAVE_WCHAR_H`
		8d0e4d	`+# include <wchar.h>`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`+/* Get iswblank(), towupper. */`
		8d0e4d	`+#if HAVE_WCTYPE_H`
		8d0e4d	`+# include <wctype.h>`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`#include "system.h"`
		8d0e4d	`#include "die.h"`
		8d0e4d	`#include "error.h"`
		8d0e4d	`#include "fadvise.h"`
		8d0e4d	`#include "hard-locale.h"`
		8d0e4d	`#include "linebuffer.h"`
		8d0e4d	`-#include "memcasecmp.h"`
		8d0e4d	`#include "quote.h"`
		8d0e4d	`#include "stdio--.h"`
		8d0e4d	`#include "xmemcoll.h"`
		8d0e4d	`#include "xstrtol.h"`
		8d0e4d	`#include "argmatch.h"`
		8d0e4d
		8d0e4d	`+/* Some systems, like BeOS, have multibyte encodings but lack mbstate_t. */`
		8d0e4d	`+#if HAVE_MBRTOWC && defined mbstate_t`
		8d0e4d	`+# define mbrtowc(pwc, s, n, ps) (mbrtowc) (pwc, s, n, 0)`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`/* The official name of this program (e.g., no 'g' prefix). */`
		8d0e4d	`#define PROGRAM_NAME "join"`
		8d0e4d
		8d0e4d	`@@ -136,10 +150,12 @@ static struct outlist outlist_head;`
		8d0e4d	`/* Last element in 'outlist', where a new element can be added. */`
		8d0e4d	`static struct outlist *outlist_end = &outlist_head;`
		8d0e4d
		8d0e4d	`-/* Tab character separating fields. If negative, fields are separated`
		8d0e4d	`- by any nonempty string of blanks, otherwise by exactly one`
		8d0e4d	`- tab character whose value (when cast to unsigned char) equals TAB. */`
		8d0e4d	`-static int tab = -1;`
		8d0e4d	`+/* Tab character separating fields. If NULL, fields are separated`
		8d0e4d	`+ by any nonempty string of blanks. */`
		8d0e4d	`+static char *tab = NULL;`
		8d0e4d	`+`
		8d0e4d	`+/* The number of bytes used for tab. */`
		8d0e4d	`+static size_t tablen = 0;`
		8d0e4d
		8d0e4d	`/* If nonzero, check that the input is correctly ordered. */`
		8d0e4d	`static enum`
		8d0e4d	`@@ -276,13 +292,14 @@ xfields (struct line *line)`
		8d0e4d	`if (ptr == lim)`
		8d0e4d	`return;`
		8d0e4d
		8d0e4d	`- if (0 <= tab && tab != '\n')`
		8d0e4d	`+ if (tab != NULL)`
		8d0e4d	`{`
		8d0e4d	`+ unsigned char t = tab[0];`
		8d0e4d	`char *sep;`
		8d0e4d	`- for (; (sep = memchr (ptr, tab, lim - ptr)) != NULL; ptr = sep + 1)`
		8d0e4d	`+ for (; (sep = memchr (ptr, t, lim - ptr)) != NULL; ptr = sep + 1)`
		8d0e4d	`extract_field (line, ptr, sep - ptr);`
		8d0e4d	`}`
		8d0e4d	`- else if (tab < 0)`
		8d0e4d	`+ else`
		8d0e4d	`{`
		8d0e4d	`/* Skip leading blanks before the first field. */`
		8d0e4d	`while (field_sep (*ptr))`
		8d0e4d	`@@ -306,6 +323,147 @@ xfields (struct line *line)`
		8d0e4d	`extract_field (line, ptr, lim - ptr);`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+static void`
		8d0e4d	`+xfields_multibyte (struct line *line)`
		8d0e4d	`+{`
		8d0e4d	`+ char *ptr = line->buf.buffer;`
		8d0e4d	`+ char const *lim = ptr + line->buf.length - 1;`
		8d0e4d	`+ wchar_t wc = 0;`
		8d0e4d	`+ size_t mblength = 1;`
		8d0e4d	`+ mbstate_t state, state_bak;`
		8d0e4d	`+`
		8d0e4d	`+ memset (&state, 0, sizeof (mbstate_t));`
		8d0e4d	`+`
		8d0e4d	`+ if (ptr >= lim)`
		8d0e4d	`+ return;`
		8d0e4d	`+`
		8d0e4d	`+ if (tab != NULL)`
		8d0e4d	`+ {`
		8d0e4d	`+ char *sep = ptr;`
		8d0e4d	`+ for (; ptr < lim; ptr = sep + mblength)`
		8d0e4d	`+ {`
		8d0e4d	`+ sep = ptr;`
		8d0e4d	`+ while (sep < lim)`
		8d0e4d	`+ {`
		8d0e4d	`+ state_bak = state;`
		8d0e4d	`+ mblength = mbrtowc (&wc, sep, lim - sep + 1, &state);`
		8d0e4d	`+`
		8d0e4d	`+ if (mblength == (size_t)-1 \|\| mblength == (size_t)-2)`
		8d0e4d	`+ {`
		8d0e4d	`+ mblength = 1;`
		8d0e4d	`+ state = state_bak;`
		8d0e4d	`+ }`
		8d0e4d	`+ mblength = (mblength < 1) ? 1 : mblength;`
		8d0e4d	`+`
		8d0e4d	`+ if (mblength == tablen && !memcmp (sep, tab, mblength))`
		8d0e4d	`+ break;`
		8d0e4d	`+ else`
		8d0e4d	`+ {`
		8d0e4d	`+ sep += mblength;`
		8d0e4d	`+ continue;`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ if (sep >= lim)`
		8d0e4d	`+ break;`
		8d0e4d	`+`
		8d0e4d	`+ extract_field (line, ptr, sep - ptr);`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+ {`
		8d0e4d	`+ /* Skip leading blanks before the first field. */`
		8d0e4d	`+ while(ptr < lim)`
		8d0e4d	`+ {`
		8d0e4d	`+ state_bak = state;`
		8d0e4d	`+ mblength = mbrtowc (&wc, ptr, lim - ptr + 1, &state);`
		8d0e4d	`+`
		8d0e4d	`+ if (mblength == (size_t)-1 \|\| mblength == (size_t)-2)`
		8d0e4d	`+ {`
		8d0e4d	`+ mblength = 1;`
		8d0e4d	`+ state = state_bak;`
		8d0e4d	`+ break;`
		8d0e4d	`+ }`
		8d0e4d	`+ mblength = (mblength < 1) ? 1 : mblength;`
		8d0e4d	`+`
		8d0e4d	`+ if (!iswblank(wc) && wc != '\n')`
		8d0e4d	`+ break;`
		8d0e4d	`+ ptr += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ do`
		8d0e4d	`+ {`
		8d0e4d	`+ char *sep;`
		8d0e4d	`+ state_bak = state;`
		8d0e4d	`+ mblength = mbrtowc (&wc, ptr, lim - ptr + 1, &state);`
		8d0e4d	`+ if (mblength == (size_t)-1 \|\| mblength == (size_t)-2)`
		8d0e4d	`+ {`
		8d0e4d	`+ mblength = 1;`
		8d0e4d	`+ state = state_bak;`
		8d0e4d	`+ break;`
		8d0e4d	`+ }`
		8d0e4d	`+ mblength = (mblength < 1) ? 1 : mblength;`
		8d0e4d	`+`
		8d0e4d	`+ sep = ptr + mblength;`
		8d0e4d	`+ while (sep < lim)`
		8d0e4d	`+ {`
		8d0e4d	`+ state_bak = state;`
		8d0e4d	`+ mblength = mbrtowc (&wc, sep, lim - sep + 1, &state);`
		8d0e4d	`+ if (mblength == (size_t)-1 \|\| mblength == (size_t)-2)`
		8d0e4d	`+ {`
		8d0e4d	`+ mblength = 1;`
		8d0e4d	`+ state = state_bak;`
		8d0e4d	`+ break;`
		8d0e4d	`+ }`
		8d0e4d	`+ mblength = (mblength < 1) ? 1 : mblength;`
		8d0e4d	`+`
		8d0e4d	`+ if (iswblank (wc) \|\| wc == '\n')`
		8d0e4d	`+ break;`
		8d0e4d	`+`
		8d0e4d	`+ sep += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ extract_field (line, ptr, sep - ptr);`
		8d0e4d	`+ if (sep >= lim)`
		8d0e4d	`+ return;`
		8d0e4d	`+`
		8d0e4d	`+ state_bak = state;`
		8d0e4d	`+ mblength = mbrtowc (&wc, sep, lim - sep + 1, &state);`
		8d0e4d	`+ if (mblength == (size_t)-1 \|\| mblength == (size_t)-2)`
		8d0e4d	`+ {`
		8d0e4d	`+ mblength = 1;`
		8d0e4d	`+ state = state_bak;`
		8d0e4d	`+ break;`
		8d0e4d	`+ }`
		8d0e4d	`+ mblength = (mblength < 1) ? 1 : mblength;`
		8d0e4d	`+`
		8d0e4d	`+ ptr = sep + mblength;`
		8d0e4d	`+ while (ptr < lim)`
		8d0e4d	`+ {`
		8d0e4d	`+ state_bak = state;`
		8d0e4d	`+ mblength = mbrtowc (&wc, ptr, lim - ptr + 1, &state);`
		8d0e4d	`+ if (mblength == (size_t)-1 \|\| mblength == (size_t)-2)`
		8d0e4d	`+ {`
		8d0e4d	`+ mblength = 1;`
		8d0e4d	`+ state = state_bak;`
		8d0e4d	`+ break;`
		8d0e4d	`+ }`
		8d0e4d	`+ mblength = (mblength < 1) ? 1 : mblength;`
		8d0e4d	`+`
		8d0e4d	`+ if (!iswblank (wc) && wc != '\n')`
		8d0e4d	`+ break;`
		8d0e4d	`+`
		8d0e4d	`+ ptr += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+ while (ptr < lim);`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ extract_field (line, ptr, lim - ptr);`
		8d0e4d	`+}`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`static void`
		8d0e4d	`freeline (struct line *line)`
		8d0e4d	`{`
		8d0e4d	`@@ -327,56 +485,133 @@ keycmp (struct line const line1, struct line const line2,`
		8d0e4d	`size_t jf_1, size_t jf_2)`
		8d0e4d	`{`
		8d0e4d	`/* Start of field to compare in each file. */`
		8d0e4d	`- char *beg1;`
		8d0e4d	`- char *beg2;`
		8d0e4d	`-`
		8d0e4d	`- size_t len1;`
		8d0e4d	`- size_t len2; /* Length of fields to compare. */`
		8d0e4d	`+ char *beg[2];`
		8d0e4d	`+ char *copy[2];`
		8d0e4d	`+ size_t len[2]; /* Length of fields to compare. */`
		8d0e4d	`int diff;`
		8d0e4d	`+ int i, j;`
		8d0e4d	`+ int mallocd = 0;`
		8d0e4d
		8d0e4d	`if (jf_1 < line1->nfields)`
		8d0e4d	`{`
		8d0e4d	`- beg1 = line1->fields[jf_1].beg;`
		8d0e4d	`- len1 = line1->fields[jf_1].len;`
		8d0e4d	`+ beg[0] = line1->fields[jf_1].beg;`
		8d0e4d	`+ len[0] = line1->fields[jf_1].len;`
		8d0e4d	`}`
		8d0e4d	`else`
		8d0e4d	`{`
		8d0e4d	`- beg1 = NULL;`
		8d0e4d	`- len1 = 0;`
		8d0e4d	`+ beg[0] = NULL;`
		8d0e4d	`+ len[0] = 0;`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`if (jf_2 < line2->nfields)`
		8d0e4d	`{`
		8d0e4d	`- beg2 = line2->fields[jf_2].beg;`
		8d0e4d	`- len2 = line2->fields[jf_2].len;`
		8d0e4d	`+ beg[1] = line2->fields[jf_2].beg;`
		8d0e4d	`+ len[1] = line2->fields[jf_2].len;`
		8d0e4d	`}`
		8d0e4d	`else`
		8d0e4d	`{`
		8d0e4d	`- beg2 = NULL;`
		8d0e4d	`- len2 = 0;`
		8d0e4d	`+ beg[1] = NULL;`
		8d0e4d	`+ len[1] = 0;`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`- if (len1 == 0)`
		8d0e4d	`- return len2 == 0 ? 0 : -1;`
		8d0e4d	`- if (len2 == 0)`
		8d0e4d	`+ if (len[0] == 0)`
		8d0e4d	`+ return len[1] == 0 ? 0 : -1;`
		8d0e4d	`+ if (len[1] == 0)`
		8d0e4d	`return 1;`
		8d0e4d
		8d0e4d	`if (ignore_case)`
		8d0e4d	`{`
		8d0e4d	`- /* FIXME: ignore_case does not work with NLS (in particular,`
		8d0e4d	`- with multibyte chars). */`
		8d0e4d	`- diff = memcasecmp (beg1, beg2, MIN (len1, len2));`
		8d0e4d	`+#ifdef HAVE_MBRTOWC`
		8d0e4d	`+ if (MB_CUR_MAX > 1)`
		8d0e4d	`+ {`
		8d0e4d	`+ size_t mblength;`
		8d0e4d	`+ wchar_t wc, uwc;`
		8d0e4d	`+ mbstate_t state, state_bak;`
		8d0e4d	`+`
		8d0e4d	`+ memset (&state, '\0', sizeof (mbstate_t));`
		8d0e4d	`+`
		8d0e4d	`+ for (i = 0; i < 2; i++)`
		8d0e4d	`+ {`
		8d0e4d	`+ mallocd = 1;`
		8d0e4d	`+ copy[i] = xmalloc (len[i] + 1);`
		8d0e4d	`+ memset (copy[i], '\0',len[i] + 1);`
		8d0e4d	`+`
		8d0e4d	`+ for (j = 0; j < MIN (len[0], len[1]);)`
		8d0e4d	`+ {`
		8d0e4d	`+ state_bak = state;`
		8d0e4d	`+ mblength = mbrtowc (&wc, beg[i] + j, len[i] - j, &state);`
		8d0e4d	`+`
		8d0e4d	`+ switch (mblength)`
		8d0e4d	`+ {`
		8d0e4d	`+ case (size_t) -1:`
		8d0e4d	`+ case (size_t) -2:`
		8d0e4d	`+ state = state_bak;`
		8d0e4d	`+ /* Fall through */`
		8d0e4d	`+ case 0:`
		8d0e4d	`+ mblength = 1;`
		8d0e4d	`+ break;`
		8d0e4d	`+`
		8d0e4d	`+ default:`
		8d0e4d	`+ uwc = towupper (wc);`
		8d0e4d	`+`
		8d0e4d	`+ if (uwc != wc)`
		8d0e4d	`+ {`
		8d0e4d	`+ mbstate_t state_wc;`
		8d0e4d	`+ size_t mblen;`
		8d0e4d	`+`
		8d0e4d	`+ memset (&state_wc, '\0', sizeof (mbstate_t));`
		8d0e4d	`+ mblen = wcrtomb (copy[i] + j, uwc, &state_wc);`
		8d0e4d	`+ assert (mblen != (size_t)-1);`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+ memcpy (copy[i] + j, beg[i] + j, mblength);`
		8d0e4d	`+ }`
		8d0e4d	`+ j += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+ copy[i][j] = '\0';`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+#endif`
		8d0e4d	`+ {`
		8d0e4d	`+ for (i = 0; i < 2; i++)`
		8d0e4d	`+ {`
		8d0e4d	`+ mallocd = 1;`
		8d0e4d	`+ copy[i] = xmalloc (len[i] + 1);`
		8d0e4d	`+`
		8d0e4d	`+ for (j = 0; j < MIN (len[0], len[1]); j++)`
		8d0e4d	`+ copy[i][j] = toupper (beg[i][j]);`
		8d0e4d	`+`
		8d0e4d	`+ copy[i][j] = '\0';`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`}`
		8d0e4d	`else`
		8d0e4d	`{`
		8d0e4d	`- if (hard_LC_COLLATE)`
		8d0e4d	`- return xmemcoll (beg1, len1, beg2, len2);`
		8d0e4d	`- diff = memcmp (beg1, beg2, MIN (len1, len2));`
		8d0e4d	`+ copy[0] = beg[0];`
		8d0e4d	`+ copy[1] = beg[1];`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`+ if (hard_LC_COLLATE)`
		8d0e4d	`+ {`
		8d0e4d	`+ diff = xmemcoll ((char ) copy[0], len[0], (char ) copy[1], len[1]);`
		8d0e4d	`+`
		8d0e4d	`+ if (mallocd)`
		8d0e4d	`+ for (i = 0; i < 2; i++)`
		8d0e4d	`+ free (copy[i]);`
		8d0e4d	`+`
		8d0e4d	`+ return diff;`
		8d0e4d	`+ }`
		8d0e4d	`+ diff = memcmp (copy[0], copy[1], MIN (len[0], len[1]));`
		8d0e4d	`+`
		8d0e4d	`+ if (mallocd)`
		8d0e4d	`+ for (i = 0; i < 2; i++)`
		8d0e4d	`+ free (copy[i]);`
		8d0e4d	`+`
		8d0e4d	`+`
		8d0e4d	`if (diff)`
		8d0e4d	`return diff;`
		8d0e4d	`- return len1 < len2 ? -1 : len1 != len2;`
		8d0e4d	`+ return len[0] - len[1];`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`/* Check that successive input lines PREV and CURRENT from input file`
		8d0e4d	`@@ -468,6 +703,11 @@ get_line (FILE fp, struct line *linep, int which)`
		8d0e4d	`}`
		8d0e4d	`++line_no[which - 1];`
		8d0e4d
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ if (MB_CUR_MAX > 1)`
		8d0e4d	`+ xfields_multibyte (line);`
		8d0e4d	`+ else`
		8d0e4d	`+#endif`
		8d0e4d	`xfields (line);`
		8d0e4d
		8d0e4d	`if (prevline[which - 1])`
		8d0e4d	`@@ -563,21 +803,28 @@ prfield (size_t n, struct line const *line)`
		8d0e4d
		8d0e4d	`/* Output all the fields in line, other than the join field. */`
		8d0e4d
		8d0e4d	`+#define PUT_TAB_CHAR \`
		8d0e4d	`+ do \`
		8d0e4d	`+ { \`
		8d0e4d	`+ (tab != NULL) ? \`
		8d0e4d	`+ fwrite(tab, sizeof(char), tablen, stdout) : putchar (' '); \`
		8d0e4d	`+ } \`
		8d0e4d	`+ while (0)`
		8d0e4d	`+`
		8d0e4d	`static void`
		8d0e4d	`prfields (struct line const *line, size_t join_field, size_t autocount)`
		8d0e4d	`{`
		8d0e4d	`size_t i;`
		8d0e4d	`size_t nfields = autoformat ? autocount : line->nfields;`
		8d0e4d	`- char output_separator = tab < 0 ? ' ' : tab;`
		8d0e4d
		8d0e4d	`for (i = 0; i < join_field && i < nfields; ++i)`
		8d0e4d	`{`
		8d0e4d	`- putchar (output_separator);`
		8d0e4d	`+ PUT_TAB_CHAR;`
		8d0e4d	`prfield (i, line);`
		8d0e4d	`}`
		8d0e4d	`for (i = join_field + 1; i < nfields; ++i)`
		8d0e4d	`{`
		8d0e4d	`- putchar (output_separator);`
		8d0e4d	`+ PUT_TAB_CHAR;`
		8d0e4d	`prfield (i, line);`
		8d0e4d	`}`
		8d0e4d	`}`
		8d0e4d	`@@ -588,7 +835,6 @@ static void`
		8d0e4d	`prjoin (struct line const line1, struct line const line2)`
		8d0e4d	`{`
		8d0e4d	`const struct outlist *outlist;`
		8d0e4d	`- char output_separator = tab < 0 ? ' ' : tab;`
		8d0e4d	`size_t field;`
		8d0e4d	`struct line const *line;`
		8d0e4d
		8d0e4d	`@@ -622,7 +868,7 @@ prjoin (struct line const line1, struct line const line2)`
		8d0e4d	`o = o->next;`
		8d0e4d	`if (o == NULL)`
		8d0e4d	`break;`
		8d0e4d	`- putchar (output_separator);`
		8d0e4d	`+ PUT_TAB_CHAR;`
		8d0e4d	`}`
		8d0e4d	`putchar (eolchar);`
		8d0e4d	`}`
		8d0e4d	`@@ -1099,20 +1345,43 @@ main (int argc, char **argv)`
		8d0e4d
		8d0e4d	`case 't':`
		8d0e4d	`{`
		8d0e4d	`- unsigned char newtab = optarg[0];`
		8d0e4d	`+ char *newtab = NULL;`
		8d0e4d	`+ size_t newtablen;`
		8d0e4d	`+ newtab = xstrdup (optarg);`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ if (MB_CUR_MAX > 1)`
		8d0e4d	`+ {`
		8d0e4d	`+ mbstate_t state;`
		8d0e4d	`+`
		8d0e4d	`+ memset (&state, 0, sizeof (mbstate_t));`
		8d0e4d	`+ newtablen = mbrtowc (NULL, newtab,`
		8d0e4d	`+ strnlen (newtab, MB_LEN_MAX),`
		8d0e4d	`+ &state);`
		8d0e4d	`+ if (newtablen == (size_t) 0`
		8d0e4d	`+ \|\| newtablen == (size_t) -1`
		8d0e4d	`+ \|\| newtablen == (size_t) -2)`
		8d0e4d	`+ newtablen = 1;`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+#endif`
		8d0e4d	`+ newtablen = 1;`
		8d0e4d	`if (! newtab)`
		8d0e4d	`- newtab = '\n'; /* '' => process the whole line. */`
		8d0e4d	`+ newtab = (char)"\n"; / '' => process the whole line. */`
		8d0e4d	`else if (optarg[1])`
		8d0e4d	`{`
		8d0e4d	`- if (STREQ (optarg, "\\0"))`
		8d0e4d	`- newtab = '\0';`
		8d0e4d	`- else`
		8d0e4d	`- die (EXIT_FAILURE, 0, _("multi-character tab %s"),`
		8d0e4d	`- quote (optarg));`
		8d0e4d	`+ if (newtablen == 1 && newtab[1])`
		8d0e4d	`+ {`
		8d0e4d	`+ if (STREQ (newtab, "\\0"))`
		8d0e4d	`+ newtab[0] = '\0';`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+ if (tab != NULL && strcmp (tab, newtab))`
		8d0e4d	`+ {`
		8d0e4d	`+ free (newtab);`
		8d0e4d	`+ die (EXIT_FAILURE, 0, _("incompatible tabs"));`
		8d0e4d	`}`
		8d0e4d	`- if (0 <= tab && tab != newtab)`
		8d0e4d	`- die (EXIT_FAILURE, 0, _("incompatible tabs"));`
		8d0e4d	`tab = newtab;`
		8d0e4d	`+ tablen = newtablen;`
		8d0e4d	`}`
		8d0e4d	`break;`
		8d0e4d
		8d0e4d	`diff --git a/src/pr.c b/src/pr.c`
		8d0e4d	`index 26f221f..633f50e 100644`
		8d0e4d	`--- a/src/pr.c`
		8d0e4d	`+++ b/src/pr.c`
		8d0e4d	`@@ -311,6 +311,24 @@`
		8d0e4d
		8d0e4d	`#include <getopt.h>`
		8d0e4d	`#include <sys/types.h>`
		8d0e4d	`+`
		8d0e4d	`+/* Get MB_LEN_MAX. */`
		8d0e4d	`+#include <limits.h>`
		8d0e4d	`+/* MB_LEN_MAX is incorrectly defined to be 1 in at least one GCC`
		8d0e4d	`+ installation; work around this configuration error. */`
		8d0e4d	`+#if !defined MB_LEN_MAX \|\| MB_LEN_MAX == 1`
		8d0e4d	`+# define MB_LEN_MAX 16`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`+/* Get MB_CUR_MAX. */`
		8d0e4d	`+#include <stdlib.h>`
		8d0e4d	`+`
		8d0e4d	`+/* Solaris 2.5 has a bug: <wchar.h> must be included before <wctype.h>. */`
		8d0e4d	`+/* Get mbstate_t, mbrtowc(), wcwidth(). */`
		8d0e4d	`+#if HAVE_WCHAR_H`
		8d0e4d	`+# include <wchar.h>`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`#include "system.h"`
		8d0e4d	`#include "die.h"`
		8d0e4d	`#include "error.h"`
		8d0e4d	`@@ -324,6 +342,18 @@`
		8d0e4d	`#include "xstrtol.h"`
		8d0e4d	`#include "xdectoint.h"`
		8d0e4d
		8d0e4d	`+/* Some systems, like BeOS, have multibyte encodings but lack mbstate_t. */`
		8d0e4d	`+#if HAVE_MBRTOWC && defined mbstate_t`
		8d0e4d	`+# define mbrtowc(pwc, s, n, ps) (mbrtowc) (pwc, s, n, 0)`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`+#ifndef HAVE_DECL_WCWIDTH`
		8d0e4d	`+"this configure-time declaration test was not run"`
		8d0e4d	`+#endif`
		8d0e4d	`+#if !HAVE_DECL_WCWIDTH`
		8d0e4d	`+extern int wcwidth ();`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`/* The official name of this program (e.g., no 'g' prefix). */`
		8d0e4d	`#define PROGRAM_NAME "pr"`
		8d0e4d
		8d0e4d	`@@ -416,7 +446,20 @@ struct COLUMN`
		8d0e4d
		8d0e4d	`typedef struct COLUMN COLUMN;`
		8d0e4d
		8d0e4d	`-static int char_to_clump (char c);`
		8d0e4d	`+/* Funtion pointers to switch functions for single byte locale or for`
		8d0e4d	`+ multibyte locale. If multibyte functions do not exist in your sysytem,`
		8d0e4d	`+ these pointers always point the function for single byte locale. */`
		8d0e4d	`+static void (*print_char) (char c);`
		8d0e4d	`+static int (*char_to_clump) (char c);`
		8d0e4d	`+`
		8d0e4d	`+/* Functions for single byte locale. */`
		8d0e4d	`+static void print_char_single (char c);`
		8d0e4d	`+static int char_to_clump_single (char c);`
		8d0e4d	`+`
		8d0e4d	`+/* Functions for multibyte locale. */`
		8d0e4d	`+static void print_char_multi (char c);`
		8d0e4d	`+static int char_to_clump_multi (char c);`
		8d0e4d	`+`
		8d0e4d	`static bool read_line (COLUMN *p);`
		8d0e4d	`static bool print_page (void);`
		8d0e4d	`static bool print_stored (COLUMN *p);`
		8d0e4d	`@@ -428,6 +471,7 @@ static void add_line_number (COLUMN *p);`
		8d0e4d	`static void getoptnum (const char n_str, int min, int num,`
		8d0e4d	`const char *errfmt);`
		8d0e4d	`static void getoptarg (char arg, char switch_char, char character,`
		8d0e4d	`+ int character_length, int character_width,`
		8d0e4d	`int *number);`
		8d0e4d	`static void print_files (int number_of_files, char **av);`
		8d0e4d	`static void init_parameters (int number_of_files);`
		8d0e4d	`@@ -441,7 +485,6 @@ static void store_char (char c);`
		8d0e4d	`static void pad_down (unsigned int lines);`
		8d0e4d	`static void read_rest_of_line (COLUMN *p);`
		8d0e4d	`static void skip_read (COLUMN *p, int column_number);`
		8d0e4d	`-static void print_char (char c);`
		8d0e4d	`static void cleanup (void);`
		8d0e4d	`static void print_sep_string (void);`
		8d0e4d	`static void separator_string (const char *optarg_S);`
		8d0e4d	`@@ -453,7 +496,7 @@ static COLUMN *column_vector;`
		8d0e4d	`we store the leftmost columns contiguously in buff.`
		8d0e4d	`To print a line from buff, get the index of the first character`
		8d0e4d	`from line_vector[i], and print up to line_vector[i + 1]. */`
		8d0e4d	`-static char *buff;`
		8d0e4d	`+static unsigned char *buff;`
		8d0e4d
		8d0e4d	`/* Index of the position in buff where the next character`
		8d0e4d	`will be stored. */`
		8d0e4d	`@@ -557,7 +600,7 @@ static int chars_per_column;`
		8d0e4d	`static bool untabify_input = false;`
		8d0e4d
		8d0e4d	`/* (-e) The input tab character. */`
		8d0e4d	`-static char input_tab_char = '\t';`
		8d0e4d	`+static char input_tab_char[MB_LEN_MAX] = "\t";`
		8d0e4d
		8d0e4d	`/* (-e) Tabstops are at chars_per_tab, 2chars_per_tab, 3chars_per_tab, ...`
		8d0e4d	`where the leftmost column is 1. */`
		8d0e4d	`@@ -567,7 +610,10 @@ static int chars_per_input_tab = 8;`
		8d0e4d	`static bool tabify_output = false;`
		8d0e4d
		8d0e4d	`/* (-i) The output tab character. */`
		8d0e4d	`-static char output_tab_char = '\t';`
		8d0e4d	`+static char output_tab_char[MB_LEN_MAX] = "\t";`
		8d0e4d	`+`
		8d0e4d	`+/* (-i) The byte length of output tab character. */`
		8d0e4d	`+static int output_tab_char_length = 1;`
		8d0e4d
		8d0e4d	`/* (-i) The width of the output tab. */`
		8d0e4d	`static int chars_per_output_tab = 8;`
		8d0e4d	`@@ -637,7 +683,13 @@ static int line_number;`
		8d0e4d	`static bool numbered_lines = false;`
		8d0e4d
		8d0e4d	`/* (-n) Character which follows each line number. */`
		8d0e4d	`-static char number_separator = '\t';`
		8d0e4d	`+static char number_separator[MB_LEN_MAX] = "\t";`
		8d0e4d	`+`
		8d0e4d	`+/* (-n) The byte length of the character which follows each line number. */`
		8d0e4d	`+static int number_separator_length = 1;`
		8d0e4d	`+`
		8d0e4d	`+/* (-n) The character width of the character which follows each line number. */`
		8d0e4d	`+static int number_separator_width = 0;`
		8d0e4d
		8d0e4d	`/* (-n) line counting starts with 1st line of input file (not with 1st`
		8d0e4d	`line of 1st page printed). */`
		8d0e4d	`@@ -690,6 +742,7 @@ static bool use_col_separator = false;`
		8d0e4d	`-a\|COLUMN\|-m is a 'space' and with the -J option a 'tab'. */`
		8d0e4d	`static char const *col_sep_string = "";`
		8d0e4d	`static int col_sep_length = 0;`
		8d0e4d	`+static int col_sep_width = 0;`
		8d0e4d	`static char column_separator = (char ) " ";`
		8d0e4d	`static char line_separator = (char ) "\t";`
		8d0e4d
		8d0e4d	`@@ -851,6 +904,13 @@ separator_string (const char *optarg_S)`
		8d0e4d	`integer_overflow ();`
		8d0e4d	`col_sep_length = len;`
		8d0e4d	`col_sep_string = optarg_S;`
		8d0e4d	`+`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ if (MB_CUR_MAX > 1)`
		8d0e4d	`+ col_sep_width = mbswidth (col_sep_string, 0);`
		8d0e4d	`+ else`
		8d0e4d	`+#endif`
		8d0e4d	`+ col_sep_width = col_sep_length;`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`int`
		8d0e4d	`@@ -875,6 +935,21 @@ main (int argc, char **argv)`
		8d0e4d
		8d0e4d	`atexit (close_stdout);`
		8d0e4d
		8d0e4d	`+/* Define which functions are used, the ones for single byte locale or the ones`
		8d0e4d	`+ for multibyte locale. */`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ if (MB_CUR_MAX > 1)`
		8d0e4d	`+ {`
		8d0e4d	`+ print_char = print_char_multi;`
		8d0e4d	`+ char_to_clump = char_to_clump_multi;`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+#endif`
		8d0e4d	`+ {`
		8d0e4d	`+ print_char = print_char_single;`
		8d0e4d	`+ char_to_clump = char_to_clump_single;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`n_files = 0;`
		8d0e4d	`file_names = (argc > 1`
		8d0e4d	`? xnmalloc (argc - 1, sizeof (char *))`
		8d0e4d	`@@ -951,8 +1026,12 @@ main (int argc, char **argv)`
		8d0e4d	`break;`
		8d0e4d	`case 'e':`
		8d0e4d	`if (optarg)`
		8d0e4d	`- getoptarg (optarg, 'e', &input_tab_char,`
		8d0e4d	`- &chars_per_input_tab);`
		8d0e4d	`+ {`
		8d0e4d	`+ int dummy_length, dummy_width;`
		8d0e4d	`+`
		8d0e4d	`+ getoptarg (optarg, 'e', input_tab_char, &dummy_length,`
		8d0e4d	`+ &dummy_width, &chars_per_input_tab);`
		8d0e4d	`+ }`
		8d0e4d	`/* Could check tab width > 0. */`
		8d0e4d	`untabify_input = true;`
		8d0e4d	`break;`
		8d0e4d	`@@ -965,8 +1044,12 @@ main (int argc, char **argv)`
		8d0e4d	`break;`
		8d0e4d	`case 'i':`
		8d0e4d	`if (optarg)`
		8d0e4d	`- getoptarg (optarg, 'i', &output_tab_char,`
		8d0e4d	`- &chars_per_output_tab);`
		8d0e4d	`+ {`
		8d0e4d	`+ int dummy_width;`
		8d0e4d	`+`
		8d0e4d	`+ getoptarg (optarg, 'i', output_tab_char, &output_tab_char_length,`
		8d0e4d	`+ &dummy_width, &chars_per_output_tab);`
		8d0e4d	`+ }`
		8d0e4d	`/* Could check tab width > 0. */`
		8d0e4d	`tabify_output = true;`
		8d0e4d	`break;`
		8d0e4d	`@@ -984,8 +1067,8 @@ main (int argc, char **argv)`
		8d0e4d	`case 'n':`
		8d0e4d	`numbered_lines = true;`
		8d0e4d	`if (optarg)`
		8d0e4d	`- getoptarg (optarg, 'n', &number_separator,`
		8d0e4d	`- &chars_per_number);`
		8d0e4d	`+ getoptarg (optarg, 'n', number_separator, &number_separator_length,`
		8d0e4d	`+ &number_separator_width, &chars_per_number);`
		8d0e4d	`break;`
		8d0e4d	`case 'N':`
		8d0e4d	`skip_count = false;`
		8d0e4d	`@@ -1010,6 +1093,7 @@ main (int argc, char **argv)`
		8d0e4d	`/* Reset an additional input of -s, -S dominates -s */`
		8d0e4d	`col_sep_string = "";`
		8d0e4d	`col_sep_length = 0;`
		8d0e4d	`+ col_sep_width = 0;`
		8d0e4d	`use_col_separator = true;`
		8d0e4d	`if (optarg)`
		8d0e4d	`separator_string (optarg);`
		8d0e4d	`@@ -1165,10 +1249,45 @@ getoptnum (const char n_str, int min, int num, const char *err)`
		8d0e4d	`a number. */`
		8d0e4d
		8d0e4d	`static void`
		8d0e4d	`-getoptarg (char arg, char switch_char, char character, int *number)`
		8d0e4d	`+getoptarg (char arg, char switch_char, char character, int *character_length,`
		8d0e4d	`+ int character_width, int number)`
		8d0e4d	`{`
		8d0e4d	`if (!ISDIGIT (*arg))`
		8d0e4d	`- character = arg++;`
		8d0e4d	`+ {`
		8d0e4d	`+#ifdef HAVE_MBRTOWC`
		8d0e4d	`+ if (MB_CUR_MAX > 1) /* for multibyte locale. */`
		8d0e4d	`+ {`
		8d0e4d	`+ wchar_t wc;`
		8d0e4d	`+ size_t mblength;`
		8d0e4d	`+ int width;`
		8d0e4d	`+ mbstate_t state = {'\0'};`
		8d0e4d	`+`
		8d0e4d	`+ mblength = mbrtowc (&wc, arg, strnlen(arg, MB_LEN_MAX), &state);`
		8d0e4d	`+`
		8d0e4d	`+ if (mblength == (size_t)-1 \|\| mblength == (size_t)-2)`
		8d0e4d	`+ {`
		8d0e4d	`+ *character_length = 1;`
		8d0e4d	`+ *character_width = 1;`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+ {`
		8d0e4d	`+ *character_length = (mblength < 1) ? 1 : mblength;`
		8d0e4d	`+ width = wcwidth (wc);`
		8d0e4d	`+ *character_width = (width < 0) ? 0 : width;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ strncpy (character, arg, *character_length);`
		8d0e4d	`+ arg += *character_length;`
		8d0e4d	`+ }`
		8d0e4d	`+ else /* for single byte locale. */`
		8d0e4d	`+#endif`
		8d0e4d	`+ {`
		8d0e4d	`+ character = arg++;`
		8d0e4d	`+ *character_length = 1;`
		8d0e4d	`+ *character_width = 1;`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`if (*arg)`
		8d0e4d	`{`
		8d0e4d	`long int tmp_long;`
		8d0e4d	`@@ -1190,6 +1309,11 @@ static void`
		8d0e4d	`init_parameters (int number_of_files)`
		8d0e4d	`{`
		8d0e4d	`int chars_used_by_number = 0;`
		8d0e4d	`+ int mb_len = 1;`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ if (MB_CUR_MAX > 1)`
		8d0e4d	`+ mb_len = MB_LEN_MAX;`
		8d0e4d	`+#endif`
		8d0e4d
		8d0e4d	`lines_per_body = lines_per_page - lines_per_header - lines_per_footer;`
		8d0e4d	`if (lines_per_body <= 0)`
		8d0e4d	`@@ -1227,7 +1351,7 @@ init_parameters (int number_of_files)`
		8d0e4d	`else`
		8d0e4d	`col_sep_string = column_separator;`
		8d0e4d
		8d0e4d	`- col_sep_length = 1;`
		8d0e4d	`+ col_sep_length = col_sep_width = 1;`
		8d0e4d	`use_col_separator = true;`
		8d0e4d	`}`
		8d0e4d	`/* It's rather pointless to define a TAB separator with column`
		8d0e4d	`@@ -1257,11 +1381,11 @@ init_parameters (int number_of_files)`
		8d0e4d	`+ TAB_WIDTH (chars_per_input_tab, chars_per_number); */`
		8d0e4d
		8d0e4d	`/* Estimate chars_per_text without any margin and keep it constant. */`
		8d0e4d	`- if (number_separator == '\t')`
		8d0e4d	`+ if (number_separator[0] == '\t')`
		8d0e4d	`number_width = (chars_per_number`
		8d0e4d	`+ TAB_WIDTH (chars_per_default_tab, chars_per_number));`
		8d0e4d	`else`
		8d0e4d	`- number_width = chars_per_number + 1;`
		8d0e4d	`+ number_width = chars_per_number + number_separator_width;`
		8d0e4d
		8d0e4d	`/* The number is part of the column width unless we are`
		8d0e4d	`printing files in parallel. */`
		8d0e4d	`@@ -1270,7 +1394,7 @@ init_parameters (int number_of_files)`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`int sep_chars, useful_chars;`
		8d0e4d	`- if (INT_MULTIPLY_WRAPV (columns - 1, col_sep_length, &sep_chars))`
		8d0e4d	`+ if (INT_MULTIPLY_WRAPV (columns - 1, col_sep_width, &sep_chars))`
		8d0e4d	`sep_chars = INT_MAX;`
		8d0e4d	`if (INT_SUBTRACT_WRAPV (chars_per_line - chars_used_by_number, sep_chars,`
		8d0e4d	`&useful_chars))`
		8d0e4d	`@@ -1293,7 +1417,7 @@ init_parameters (int number_of_files)`
		8d0e4d	`We've to use 8 as the lower limit, if we use chars_per_default_tab = 8`
		8d0e4d	`to expand a tab which is not an input_tab-char. */`
		8d0e4d	`free (clump_buff);`
		8d0e4d	`- clump_buff = xmalloc (MAX (8, chars_per_input_tab));`
		8d0e4d	`+ clump_buff = xmalloc (mb_len * MAX (8, chars_per_input_tab));`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`/* Open the necessary files,`
		8d0e4d	`@@ -1399,7 +1523,7 @@ init_funcs (void)`
		8d0e4d
		8d0e4d	`/* Enlarge p->start_position of first column to use the same form of`
		8d0e4d	`padding_not_printed with all columns. */`
		8d0e4d	`- h = h + col_sep_length;`
		8d0e4d	`+ h = h + col_sep_width;`
		8d0e4d
		8d0e4d	`/* This loop takes care of all but the rightmost column. */`
		8d0e4d
		8d0e4d	`@@ -1433,7 +1557,7 @@ init_funcs (void)`
		8d0e4d	`}`
		8d0e4d	`else`
		8d0e4d	`{`
		8d0e4d	`- h = h_next + col_sep_length;`
		8d0e4d	`+ h = h_next + col_sep_width;`
		8d0e4d	`h_next = h + chars_per_column;`
		8d0e4d	`}`
		8d0e4d	`}`
		8d0e4d	`@@ -1724,9 +1848,9 @@ static void`
		8d0e4d	`align_column (COLUMN *p)`
		8d0e4d	`{`
		8d0e4d	`padding_not_printed = p->start_position;`
		8d0e4d	`- if (col_sep_length < padding_not_printed)`
		8d0e4d	`+ if (col_sep_width < padding_not_printed)`
		8d0e4d	`{`
		8d0e4d	`- pad_across_to (padding_not_printed - col_sep_length);`
		8d0e4d	`+ pad_across_to (padding_not_printed - col_sep_width);`
		8d0e4d	`padding_not_printed = ANYWHERE;`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`@@ -2001,13 +2125,13 @@ store_char (char c)`
		8d0e4d	`/* May be too generous. */`
		8d0e4d	`buff = X2REALLOC (buff, &buff_allocated);`
		8d0e4d	`}`
		8d0e4d	`- buff[buff_current++] = c;`
		8d0e4d	`+ buff[buff_current++] = (unsigned char) c;`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`static void`
		8d0e4d	`add_line_number (COLUMN *p)`
		8d0e4d	`{`
		8d0e4d	`- int i;`
		8d0e4d	`+ int i, j;`
		8d0e4d	`char *s;`
		8d0e4d	`int num_width;`
		8d0e4d
		8d0e4d	`@@ -2024,22 +2148,24 @@ add_line_number (COLUMN *p)`
		8d0e4d	`/* Tabification is assumed for multiple columns, also for n-separators,`
		8d0e4d	`but 'default n-separator = TAB' hasn't been given priority over`
		8d0e4d	`equal column_width also specified by POSIX. */`
		8d0e4d	`- if (number_separator == '\t')`
		8d0e4d	`+ if (number_separator[0] == '\t')`
		8d0e4d	`{`
		8d0e4d	`i = number_width - chars_per_number;`
		8d0e4d	`while (i-- > 0)`
		8d0e4d	`(p->char_func) (' ');`
		8d0e4d	`}`
		8d0e4d	`else`
		8d0e4d	`- (p->char_func) (number_separator);`
		8d0e4d	`+ for (j = 0; j < number_separator_length; j++)`
		8d0e4d	`+ (p->char_func) (number_separator[j]);`
		8d0e4d	`}`
		8d0e4d	`else`
		8d0e4d	`/* To comply with POSIX, we avoid any expansion of default TAB`
		8d0e4d	`separator with a single column output. No column_width requirement`
		8d0e4d	`has to be considered. */`
		8d0e4d	`{`
		8d0e4d	`- (p->char_func) (number_separator);`
		8d0e4d	`- if (number_separator == '\t')`
		8d0e4d	`+ for (j = 0; j < number_separator_length; j++)`
		8d0e4d	`+ (p->char_func) (number_separator[j]);`
		8d0e4d	`+ if (number_separator[0] == '\t')`
		8d0e4d	`output_position = POS_AFTER_TAB (chars_per_output_tab,`
		8d0e4d	`output_position);`
		8d0e4d	`}`
		8d0e4d	`@@ -2198,7 +2324,7 @@ print_white_space (void)`
		8d0e4d	`while (goal - h_old > 1`
		8d0e4d	`&& (h_new = POS_AFTER_TAB (chars_per_output_tab, h_old)) <= goal)`
		8d0e4d	`{`
		8d0e4d	`- putchar (output_tab_char);`
		8d0e4d	`+ fwrite (output_tab_char, sizeof(char), output_tab_char_length, stdout);`
		8d0e4d	`h_old = h_new;`
		8d0e4d	`}`
		8d0e4d	`while (++h_old <= goal)`
		8d0e4d	`@@ -2218,6 +2344,7 @@ print_sep_string (void)`
		8d0e4d	`{`
		8d0e4d	`char const *s = col_sep_string;`
		8d0e4d	`int l = col_sep_length;`
		8d0e4d	`+ int not_space_flag;`
		8d0e4d
		8d0e4d	`if (separators_not_printed <= 0)`
		8d0e4d	`{`
		8d0e4d	`@@ -2229,6 +2356,7 @@ print_sep_string (void)`
		8d0e4d	`{`
		8d0e4d	`for (; separators_not_printed > 0; --separators_not_printed)`
		8d0e4d	`{`
		8d0e4d	`+ not_space_flag = 0;`
		8d0e4d	`while (l-- > 0)`
		8d0e4d	`{`
		8d0e4d	`/* 3 types of sep_strings: spaces only, spaces and chars,`
		8d0e4d	`@@ -2242,12 +2370,15 @@ print_sep_string (void)`
		8d0e4d	`}`
		8d0e4d	`else`
		8d0e4d	`{`
		8d0e4d	`+ not_space_flag = 1;`
		8d0e4d	`if (spaces_not_printed > 0)`
		8d0e4d	`print_white_space ();`
		8d0e4d	`putchar (*s++);`
		8d0e4d	`- ++output_position;`
		8d0e4d	`}`
		8d0e4d	`}`
		8d0e4d	`+ if (not_space_flag)`
		8d0e4d	`+ output_position += col_sep_width;`
		8d0e4d	`+`
		8d0e4d	`/* sep_string ends with some spaces */`
		8d0e4d	`if (spaces_not_printed > 0)`
		8d0e4d	`print_white_space ();`
		8d0e4d	`@@ -2275,7 +2406,7 @@ print_clump (COLUMN p, int n, char clump)`
		8d0e4d	`required number of tabs and spaces. */`
		8d0e4d
		8d0e4d	`static void`
		8d0e4d	`-print_char (char c)`
		8d0e4d	`+print_char_single (char c)`
		8d0e4d	`{`
		8d0e4d	`if (tabify_output)`
		8d0e4d	`{`
		8d0e4d	`@@ -2299,6 +2430,74 @@ print_char (char c)`
		8d0e4d	`putchar (c);`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`+#ifdef HAVE_MBRTOWC`
		8d0e4d	`+static void`
		8d0e4d	`+print_char_multi (char c)`
		8d0e4d	`+{`
		8d0e4d	`+ static size_t mbc_pos = 0;`
		8d0e4d	`+ static char mbc[MB_LEN_MAX] = {'\0'};`
		8d0e4d	`+ static mbstate_t state = {'\0'};`
		8d0e4d	`+ mbstate_t state_bak;`
		8d0e4d	`+ wchar_t wc;`
		8d0e4d	`+ size_t mblength;`
		8d0e4d	`+ int width;`
		8d0e4d	`+`
		8d0e4d	`+ if (tabify_output)`
		8d0e4d	`+ {`
		8d0e4d	`+ state_bak = state;`
		8d0e4d	`+ mbc[mbc_pos++] = c;`
		8d0e4d	`+ mblength = mbrtowc (&wc, mbc, mbc_pos, &state);`
		8d0e4d	`+`
		8d0e4d	`+ while (mbc_pos > 0)`
		8d0e4d	`+ {`
		8d0e4d	`+ switch (mblength)`
		8d0e4d	`+ {`
		8d0e4d	`+ case (size_t)-2:`
		8d0e4d	`+ state = state_bak;`
		8d0e4d	`+ return;`
		8d0e4d	`+`
		8d0e4d	`+ case (size_t)-1:`
		8d0e4d	`+ state = state_bak;`
		8d0e4d	`+ ++output_position;`
		8d0e4d	`+ putchar (mbc[0]);`
		8d0e4d	`+ memmove (mbc, mbc + 1, MB_CUR_MAX - 1);`
		8d0e4d	`+ --mbc_pos;`
		8d0e4d	`+ break;`
		8d0e4d	`+`
		8d0e4d	`+ case 0:`
		8d0e4d	`+ mblength = 1;`
		8d0e4d	`+`
		8d0e4d	`+ default:`
		8d0e4d	`+ if (wc == L' ')`
		8d0e4d	`+ {`
		8d0e4d	`+ memmove (mbc, mbc + mblength, MB_CUR_MAX - mblength);`
		8d0e4d	`+ --mbc_pos;`
		8d0e4d	`+ ++spaces_not_printed;`
		8d0e4d	`+ return;`
		8d0e4d	`+ }`
		8d0e4d	`+ else if (spaces_not_printed > 0)`
		8d0e4d	`+ print_white_space ();`
		8d0e4d	`+`
		8d0e4d	`+ /* Nonprintables are assumed to have width 0, except L'\b'. */`
		8d0e4d	`+ if ((width = wcwidth (wc)) < 1)`
		8d0e4d	`+ {`
		8d0e4d	`+ if (wc == L'\b')`
		8d0e4d	`+ --output_position;`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+ output_position += width;`
		8d0e4d	`+`
		8d0e4d	`+ fwrite (mbc, sizeof(char), mblength, stdout);`
		8d0e4d	`+ memmove (mbc, mbc + mblength, MB_CUR_MAX - mblength);`
		8d0e4d	`+ mbc_pos -= mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+ return;`
		8d0e4d	`+ }`
		8d0e4d	`+ putchar (c);`
		8d0e4d	`+}`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`/* Skip to page PAGE before printing.`
		8d0e4d	`PAGE may be larger than total number of pages. */`
		8d0e4d
		8d0e4d	`@@ -2476,9 +2675,9 @@ read_line (COLUMN *p)`
		8d0e4d	`align_empty_cols = false;`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`- if (col_sep_length < padding_not_printed)`
		8d0e4d	`+ if (col_sep_width < padding_not_printed)`
		8d0e4d	`{`
		8d0e4d	`- pad_across_to (padding_not_printed - col_sep_length);`
		8d0e4d	`+ pad_across_to (padding_not_printed - col_sep_width);`
		8d0e4d	`padding_not_printed = ANYWHERE;`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`@@ -2547,7 +2746,7 @@ print_stored (COLUMN *p)`
		8d0e4d	`COLUMN *q;`
		8d0e4d
		8d0e4d	`int line = p->current_line++;`
		8d0e4d	`- char *first = &buff[line_vector[line]];`
		8d0e4d	`+ unsigned char *first = &buff[line_vector[line]];`
		8d0e4d	`/* FIXME`
		8d0e4d	`UMR: Uninitialized memory read:`
		8d0e4d	`* This is occurring while in:`
		8d0e4d	`@@ -2559,7 +2758,7 @@ print_stored (COLUMN *p)`
		8d0e4d	`xmalloc [xmalloc.c:94]`
		8d0e4d	`init_store_cols [pr.c:1648]`
		8d0e4d	`*/`
		8d0e4d	`- char *last = &buff[line_vector[line + 1]];`
		8d0e4d	`+ unsigned char *last = &buff[line_vector[line + 1]];`
		8d0e4d
		8d0e4d	`pad_vertically = true;`
		8d0e4d
		8d0e4d	`@@ -2579,9 +2778,9 @@ print_stored (COLUMN *p)`
		8d0e4d	`}`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`- if (col_sep_length < padding_not_printed)`
		8d0e4d	`+ if (col_sep_width < padding_not_printed)`
		8d0e4d	`{`
		8d0e4d	`- pad_across_to (padding_not_printed - col_sep_length);`
		8d0e4d	`+ pad_across_to (padding_not_printed - col_sep_width);`
		8d0e4d	`padding_not_printed = ANYWHERE;`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`@@ -2594,8 +2793,8 @@ print_stored (COLUMN *p)`
		8d0e4d	`if (spaces_not_printed == 0)`
		8d0e4d	`{`
		8d0e4d	`output_position = p->start_position + end_vector[line];`
		8d0e4d	`- if (p->start_position - col_sep_length == chars_per_margin)`
		8d0e4d	`- output_position -= col_sep_length;`
		8d0e4d	`+ if (p->start_position - col_sep_width == chars_per_margin)`
		8d0e4d	`+ output_position -= col_sep_width;`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`return true;`
		8d0e4d	`@@ -2614,7 +2813,7 @@ print_stored (COLUMN *p)`
		8d0e4d	`number of characters is 1.) */`
		8d0e4d
		8d0e4d	`static int`
		8d0e4d	`-char_to_clump (char c)`
		8d0e4d	`+char_to_clump_single (char c)`
		8d0e4d	`{`
		8d0e4d	`unsigned char uc = c;`
		8d0e4d	`char *s = clump_buff;`
		8d0e4d	`@@ -2624,10 +2823,10 @@ char_to_clump (char c)`
		8d0e4d	`int chars;`
		8d0e4d	`int chars_per_c = 8;`
		8d0e4d
		8d0e4d	`- if (c == input_tab_char)`
		8d0e4d	`+ if (c == input_tab_char[0])`
		8d0e4d	`chars_per_c = chars_per_input_tab;`
		8d0e4d
		8d0e4d	`- if (c == input_tab_char \|\| c == '\t')`
		8d0e4d	`+ if (c == input_tab_char[0] \|\| c == '\t')`
		8d0e4d	`{`
		8d0e4d	`width = TAB_WIDTH (chars_per_c, input_position);`
		8d0e4d
		8d0e4d	`@@ -2708,6 +2907,164 @@ char_to_clump (char c)`
		8d0e4d	`return chars;`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`+#ifdef HAVE_MBRTOWC`
		8d0e4d	`+static int`
		8d0e4d	`+char_to_clump_multi (char c)`
		8d0e4d	`+{`
		8d0e4d	`+ static size_t mbc_pos = 0;`
		8d0e4d	`+ static char mbc[MB_LEN_MAX] = {'\0'};`
		8d0e4d	`+ static mbstate_t state = {'\0'};`
		8d0e4d	`+ mbstate_t state_bak;`
		8d0e4d	`+ wchar_t wc;`
		8d0e4d	`+ size_t mblength;`
		8d0e4d	`+ int wc_width;`
		8d0e4d	`+ register char *s = clump_buff;`
		8d0e4d	`+ register int i, j;`
		8d0e4d	`+ char esc_buff[4];`
		8d0e4d	`+ int width;`
		8d0e4d	`+ int chars;`
		8d0e4d	`+ int chars_per_c = 8;`
		8d0e4d	`+`
		8d0e4d	`+ state_bak = state;`
		8d0e4d	`+ mbc[mbc_pos++] = c;`
		8d0e4d	`+ mblength = mbrtowc (&wc, mbc, mbc_pos, &state);`
		8d0e4d	`+`
		8d0e4d	`+ width = 0;`
		8d0e4d	`+ chars = 0;`
		8d0e4d	`+ while (mbc_pos > 0)`
		8d0e4d	`+ {`
		8d0e4d	`+ switch (mblength)`
		8d0e4d	`+ {`
		8d0e4d	`+ case (size_t)-2:`
		8d0e4d	`+ state = state_bak;`
		8d0e4d	`+ return 0;`
		8d0e4d	`+`
		8d0e4d	`+ case (size_t)-1:`
		8d0e4d	`+ state = state_bak;`
		8d0e4d	`+ mblength = 1;`
		8d0e4d	`+`
		8d0e4d	`+ if (use_esc_sequence \|\| use_cntrl_prefix)`
		8d0e4d	`+ {`
		8d0e4d	`+ width = +4;`
		8d0e4d	`+ chars = +4;`
		8d0e4d	`+ *s++ = '\\';`
		8d0e4d	`+ sprintf (esc_buff, "%03o", (unsigned char) mbc[0]);`
		8d0e4d	`+ for (i = 0; i <= 2; ++i)`
		8d0e4d	`+ *s++ = (int) esc_buff[i];`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+ {`
		8d0e4d	`+ width += 1;`
		8d0e4d	`+ chars += 1;`
		8d0e4d	`+ *s++ = mbc[0];`
		8d0e4d	`+ }`
		8d0e4d	`+ break;`
		8d0e4d	`+`
		8d0e4d	`+ case 0:`
		8d0e4d	`+ mblength = 1;`
		8d0e4d	`+ /* Fall through */`
		8d0e4d	`+`
		8d0e4d	`+ default:`
		8d0e4d	`+ if (memcmp (mbc, input_tab_char, mblength) == 0)`
		8d0e4d	`+ chars_per_c = chars_per_input_tab;`
		8d0e4d	`+`
		8d0e4d	`+ if (memcmp (mbc, input_tab_char, mblength) == 0 \|\| c == '\t')`
		8d0e4d	`+ {`
		8d0e4d	`+ int width_inc;`
		8d0e4d	`+`
		8d0e4d	`+ width_inc = TAB_WIDTH (chars_per_c, input_position);`
		8d0e4d	`+ width += width_inc;`
		8d0e4d	`+`
		8d0e4d	`+ if (untabify_input)`
		8d0e4d	`+ {`
		8d0e4d	`+ for (i = width_inc; i; --i)`
		8d0e4d	`+ *s++ = ' ';`
		8d0e4d	`+ chars += width_inc;`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+ {`
		8d0e4d	`+ for (i = 0; i < mblength; i++)`
		8d0e4d	`+ *s++ = mbc[i];`
		8d0e4d	`+ chars += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+ else if ((wc_width = wcwidth (wc)) < 1)`
		8d0e4d	`+ {`
		8d0e4d	`+ if (use_esc_sequence)`
		8d0e4d	`+ {`
		8d0e4d	`+ for (i = 0; i < mblength; i++)`
		8d0e4d	`+ {`
		8d0e4d	`+ width += 4;`
		8d0e4d	`+ chars += 4;`
		8d0e4d	`+ *s++ = '\\';`
		8d0e4d	`+ sprintf (esc_buff, "%03o", (unsigned char) mbc[i]);`
		8d0e4d	`+ for (j = 0; j <= 2; ++j)`
		8d0e4d	`+ *s++ = (int) esc_buff[j];`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+ else if (use_cntrl_prefix)`
		8d0e4d	`+ {`
		8d0e4d	`+ if (wc < 0200)`
		8d0e4d	`+ {`
		8d0e4d	`+ width += 2;`
		8d0e4d	`+ chars += 2;`
		8d0e4d	`+ *s++ = '^';`
		8d0e4d	`+ *s++ = wc ^ 0100;`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+ {`
		8d0e4d	`+ for (i = 0; i < mblength; i++)`
		8d0e4d	`+ {`
		8d0e4d	`+ width += 4;`
		8d0e4d	`+ chars += 4;`
		8d0e4d	`+ *s++ = '\\';`
		8d0e4d	`+ sprintf (esc_buff, "%03o", (unsigned char) mbc[i]);`
		8d0e4d	`+ for (j = 0; j <= 2; ++j)`
		8d0e4d	`+ *s++ = (int) esc_buff[j];`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+ else if (wc == L'\b')`
		8d0e4d	`+ {`
		8d0e4d	`+ width += -1;`
		8d0e4d	`+ chars += 1;`
		8d0e4d	`+ *s++ = c;`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+ {`
		8d0e4d	`+ width += 0;`
		8d0e4d	`+ chars += mblength;`
		8d0e4d	`+ for (i = 0; i < mblength; i++)`
		8d0e4d	`+ *s++ = mbc[i];`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+ {`
		8d0e4d	`+ width += wc_width;`
		8d0e4d	`+ chars += mblength;`
		8d0e4d	`+ for (i = 0; i < mblength; i++)`
		8d0e4d	`+ *s++ = mbc[i];`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+ memmove (mbc, mbc + mblength, MB_CUR_MAX - mblength);`
		8d0e4d	`+ mbc_pos -= mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ /* Too many backspaces must put us in position 0 -- never negative. */`
		8d0e4d	`+ if (width < 0 && input_position == 0)`
		8d0e4d	`+ {`
		8d0e4d	`+ chars = 0;`
		8d0e4d	`+ input_position = 0;`
		8d0e4d	`+ }`
		8d0e4d	`+ else if (width < 0 && input_position <= -width)`
		8d0e4d	`+ input_position = 0;`
		8d0e4d	`+ else`
		8d0e4d	`+ input_position += width;`
		8d0e4d	`+`
		8d0e4d	`+ return chars;`
		8d0e4d	`+}`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`/* We've just printed some files and need to clean up things before`
		8d0e4d	`looking for more options and printing the next batch of files.`
		8d0e4d
		8d0e4d	`diff --git a/src/sort.c b/src/sort.c`
		8d0e4d	`index 6d2eec5..f189a0d 100644`
		8d0e4d	`--- a/src/sort.c`
		8d0e4d	`+++ b/src/sort.c`
		8d0e4d	`@@ -29,6 +29,14 @@`
		8d0e4d	`#include <sys/wait.h>`
		8d0e4d	`#include <signal.h>`
		8d0e4d	`#include <assert.h>`
		8d0e4d	`+#if HAVE_WCHAR_H`
		8d0e4d	`+# include <wchar.h>`
		8d0e4d	`+#endif`
		8d0e4d	`+/* Get isw* functions. */`
		8d0e4d	`+#if HAVE_WCTYPE_H`
		8d0e4d	`+# include <wctype.h>`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`#include "system.h"`
		8d0e4d	`#include "argmatch.h"`
		8d0e4d	`#include "die.h"`
		8d0e4d	`@@ -169,14 +177,39 @@ static int decimal_point;`
		8d0e4d	`/* Thousands separator; if -1, then there isn't one. */`
		8d0e4d	`static int thousands_sep;`
		8d0e4d
		8d0e4d	`+/* True if -f is specified. */`
		8d0e4d	`+static bool folding;`
		8d0e4d	`+`
		8d0e4d	`/* Nonzero if the corresponding locales are hard. */`
		8d0e4d	`static bool hard_LC_COLLATE;`
		8d0e4d	`-#if HAVE_NL_LANGINFO`
		8d0e4d	`+#if HAVE_LANGINFO_CODESET`
		8d0e4d	`static bool hard_LC_TIME;`
		8d0e4d	`#endif`
		8d0e4d
		8d0e4d	`#define NONZERO(x) ((x) != 0)`
		8d0e4d
		8d0e4d	`+/* get a multibyte character's byte length. */`
		8d0e4d	`+#define GET_BYTELEN_OF_CHAR(LIM, PTR, MBLENGTH, STATE) \`
		8d0e4d	`+ do \`
		8d0e4d	`+ { \`
		8d0e4d	`+ wchar_t wc; \`
		8d0e4d	`+ mbstate_t state_bak; \`
		8d0e4d	`+ \`
		8d0e4d	`+ state_bak = STATE; \`
		8d0e4d	`+ mblength = mbrtowc (&wc, PTR, LIM - PTR, &STATE); \`
		8d0e4d	`+ \`
		8d0e4d	`+ switch (MBLENGTH) \`
		8d0e4d	`+ { \`
		8d0e4d	`+ case (size_t)-1: \`
		8d0e4d	`+ case (size_t)-2: \`
		8d0e4d	`+ STATE = state_bak; \`
		8d0e4d	`+ /* Fall through. */ \`
		8d0e4d	`+ case 0: \`
		8d0e4d	`+ MBLENGTH = 1; \`
		8d0e4d	`+ } \`
		8d0e4d	`+ } \`
		8d0e4d	`+ while (0)`
		8d0e4d	`+`
		8d0e4d	`/* The kind of blanks for '-b' to skip in various options. */`
		8d0e4d	`enum blanktype { bl_start, bl_end, bl_both };`
		8d0e4d
		8d0e4d	`@@ -350,13 +383,11 @@ static bool reverse;`
		8d0e4d	`they were read if all keys compare equal. */`
		8d0e4d	`static bool stable;`
		8d0e4d
		8d0e4d	`-/* If TAB has this value, blanks separate fields. */`
		8d0e4d	`-enum { TAB_DEFAULT = CHAR_MAX + 1 };`
		8d0e4d	`-`
		8d0e4d	`-/* Tab character separating fields. If TAB_DEFAULT, then fields are`
		8d0e4d	`+/* Tab character separating fields. If tab_length is 0, then fields are`
		8d0e4d	`separated by the empty string between a non-blank character and a blank`
		8d0e4d	`character. */`
		8d0e4d	`-static int tab = TAB_DEFAULT;`
		8d0e4d	`+static char tab[MB_LEN_MAX + 1];`
		8d0e4d	`+static size_t tab_length = 0;`
		8d0e4d
		8d0e4d	`/* Flag to remove consecutive duplicate lines from the output.`
		8d0e4d	`Only the last of a sequence of equal lines will be output. */`
		8d0e4d	`@@ -814,6 +845,46 @@ reap_all (void)`
		8d0e4d	`reap (-1);`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`+/* Function pointers. */`
		8d0e4d	`+static void`
		8d0e4d	`+(*inittables) (void);`
		8d0e4d	`+static char *`
		8d0e4d	`+(begfield) (const struct line, const struct keyfield *);`
		8d0e4d	`+static char *`
		8d0e4d	`+(limfield) (const struct line, const struct keyfield *);`
		8d0e4d	`+static void`
		8d0e4d	`+(skipblanks) (char ptr, char lim);`
		8d0e4d	`+static int`
		8d0e4d	`+(getmonth) (char const , size_t, char **);`
		8d0e4d	`+static int`
		8d0e4d	`+(keycompare) (const struct line , const struct line *);`
		8d0e4d	`+static int`
		8d0e4d	`+(numcompare) (const char , const char *);`
		8d0e4d	`+`
		8d0e4d	`+/* Test for white space multibyte character.`
		8d0e4d	`+ Set LENGTH the byte length of investigated multibyte character. */`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+static int`
		8d0e4d	`+ismbblank (const char str, size_t len, size_t length)`
		8d0e4d	`+{`
		8d0e4d	`+ size_t mblength;`
		8d0e4d	`+ wchar_t wc;`
		8d0e4d	`+ mbstate_t state;`
		8d0e4d	`+`
		8d0e4d	`+ memset (&state, '\0', sizeof(mbstate_t));`
		8d0e4d	`+ mblength = mbrtowc (&wc, str, len, &state);`
		8d0e4d	`+`
		8d0e4d	`+ if (mblength == (size_t)-1 \|\| mblength == (size_t)-2)`
		8d0e4d	`+ {`
		8d0e4d	`+ *length = 1;`
		8d0e4d	`+ return 0;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ *length = (mblength < 1) ? 1 : mblength;`
		8d0e4d	`+ return iswblank (wc) \|\| wc == '\n';`
		8d0e4d	`+}`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`/* Clean up any remaining temporary files. */`
		8d0e4d
		8d0e4d	`static void`
		8d0e4d	`@@ -1264,7 +1335,7 @@ zaptemp (char const *name)`
		8d0e4d	`free (node);`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`-#if HAVE_NL_LANGINFO`
		8d0e4d	`+#if HAVE_LANGINFO_CODESET`
		8d0e4d
		8d0e4d	`static int`
		8d0e4d	`struct_month_cmp (void const m1, void const m2)`
		8d0e4d	`@@ -1279,7 +1350,7 @@ struct_month_cmp (void const m1, void const m2)`
		8d0e4d	`/* Initialize the character class tables. */`
		8d0e4d
		8d0e4d	`static void`
		8d0e4d	`-inittables (void)`
		8d0e4d	`+inittables_uni (void)`
		8d0e4d	`{`
		8d0e4d	`size_t i;`
		8d0e4d
		8d0e4d	`@@ -1291,7 +1362,7 @@ inittables (void)`
		8d0e4d	`fold_toupper[i] = toupper (i);`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`-#if HAVE_NL_LANGINFO`
		8d0e4d	`+#if HAVE_LANGINFO_CODESET`
		8d0e4d	`/* If we're not in the "C" locale, read different names for months. */`
		8d0e4d	`if (hard_LC_TIME)`
		8d0e4d	`{`
		8d0e4d	`@@ -1373,6 +1444,84 @@ specify_nmerge (int oi, char c, char const *s)`
		8d0e4d	`xstrtol_fatal (e, oi, c, long_options, s);`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+static void`
		8d0e4d	`+inittables_mb (void)`
		8d0e4d	`+{`
		8d0e4d	`+ int i, j, k, l;`
		8d0e4d	`+ char name, s, lc_time, lc_ctype;`
		8d0e4d	`+ size_t s_len, mblength;`
		8d0e4d	`+ char mbc[MB_LEN_MAX];`
		8d0e4d	`+ wchar_t wc, pwc;`
		8d0e4d	`+ mbstate_t state_mb, state_wc;`
		8d0e4d	`+`
		8d0e4d	`+ lc_time = setlocale (LC_TIME, "");`
		8d0e4d	`+ if (lc_time)`
		8d0e4d	`+ lc_time = xstrdup (lc_time);`
		8d0e4d	`+`
		8d0e4d	`+ lc_ctype = setlocale (LC_CTYPE, "");`
		8d0e4d	`+ if (lc_ctype)`
		8d0e4d	`+ lc_ctype = xstrdup (lc_ctype);`
		8d0e4d	`+`
		8d0e4d	`+ if (lc_time && lc_ctype)`
		8d0e4d	`+ /* temporarily set LC_CTYPE to match LC_TIME, so that we can convert`
		8d0e4d	`+ * the names of months to upper case */`
		8d0e4d	`+ setlocale (LC_CTYPE, lc_time);`
		8d0e4d	`+`
		8d0e4d	`+ for (i = 0; i < MONTHS_PER_YEAR; i++)`
		8d0e4d	`+ {`
		8d0e4d	`+ s = (char *) nl_langinfo (ABMON_1 + i);`
		8d0e4d	`+ s_len = strlen (s);`
		8d0e4d	`+ monthtab[i].name = name = (char *) xmalloc (s_len + 1);`
		8d0e4d	`+ monthtab[i].val = i + 1;`
		8d0e4d	`+`
		8d0e4d	`+ memset (&state_mb, '\0', sizeof (mbstate_t));`
		8d0e4d	`+ memset (&state_wc, '\0', sizeof (mbstate_t));`
		8d0e4d	`+`
		8d0e4d	`+ for (j = 0; j < s_len;)`
		8d0e4d	`+ {`
		8d0e4d	`+ if (!ismbblank (s + j, s_len - j, &mblength))`
		8d0e4d	`+ break;`
		8d0e4d	`+ j += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ for (k = 0; j < s_len;)`
		8d0e4d	`+ {`
		8d0e4d	`+ mblength = mbrtowc (&wc, (s + j), (s_len - j), &state_mb);`
		8d0e4d	`+ assert (mblength != (size_t)-1 && mblength != (size_t)-2);`
		8d0e4d	`+ if (mblength == 0)`
		8d0e4d	`+ break;`
		8d0e4d	`+`
		8d0e4d	`+ pwc = towupper (wc);`
		8d0e4d	`+ if (pwc == wc)`
		8d0e4d	`+ {`
		8d0e4d	`+ memcpy (mbc, s + j, mblength);`
		8d0e4d	`+ j += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+ {`
		8d0e4d	`+ j += mblength;`
		8d0e4d	`+ mblength = wcrtomb (mbc, pwc, &state_wc);`
		8d0e4d	`+ assert (mblength != (size_t)0 && mblength != (size_t)-1);`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ for (l = 0; l < mblength; l++)`
		8d0e4d	`+ name[k++] = mbc[l];`
		8d0e4d	`+ }`
		8d0e4d	`+ name[k] = '\0';`
		8d0e4d	`+ }`
		8d0e4d	`+ qsort ((void *) monthtab, MONTHS_PER_YEAR,`
		8d0e4d	`+ sizeof (struct month), struct_month_cmp);`
		8d0e4d	`+`
		8d0e4d	`+ if (lc_time && lc_ctype)`
		8d0e4d	`+ /* restore the original locales */`
		8d0e4d	`+ setlocale (LC_CTYPE, lc_ctype);`
		8d0e4d	`+`
		8d0e4d	`+ free (lc_ctype);`
		8d0e4d	`+ free (lc_time);`
		8d0e4d	`+}`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`/* Specify the amount of main memory to use when sorting. */`
		8d0e4d	`static void`
		8d0e4d	`specify_sort_size (int oi, char c, char const *s)`
		8d0e4d	`@@ -1604,7 +1753,7 @@ buffer_linelim (struct buffer const *buf)`
		8d0e4d	`by KEY in LINE. */`
		8d0e4d
		8d0e4d	`static char *`
		8d0e4d	`-begfield (struct line const line, struct keyfield const key)`
		8d0e4d	`+begfield_uni (const struct line line, const struct keyfield key)`
		8d0e4d	`{`
		8d0e4d	`char ptr = line->text, lim = ptr + line->length - 1;`
		8d0e4d	`size_t sword = key->sword;`
		8d0e4d	`@@ -1613,10 +1762,10 @@ begfield (struct line const line, struct keyfield const key)`
		8d0e4d	`/* The leading field separator itself is included in a field when -t`
		8d0e4d	`is absent. */`
		8d0e4d
		8d0e4d	`- if (tab != TAB_DEFAULT)`
		8d0e4d	`+ if (tab_length)`
		8d0e4d	`while (ptr < lim && sword--)`
		8d0e4d	`{`
		8d0e4d	`- while (ptr < lim && *ptr != tab)`
		8d0e4d	`+ while (ptr < lim && *ptr != tab[0])`
		8d0e4d	`++ptr;`
		8d0e4d	`if (ptr < lim)`
		8d0e4d	`++ptr;`
		8d0e4d	`@@ -1642,11 +1791,70 @@ begfield (struct line const line, struct keyfield const key)`
		8d0e4d	`return ptr;`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+static char *`
		8d0e4d	`+begfield_mb (const struct line line, const struct keyfield key)`
		8d0e4d	`+{`
		8d0e4d	`+ int i;`
		8d0e4d	`+ char ptr = line->text, lim = ptr + line->length - 1;`
		8d0e4d	`+ size_t sword = key->sword;`
		8d0e4d	`+ size_t schar = key->schar;`
		8d0e4d	`+ size_t mblength;`
		8d0e4d	`+ mbstate_t state;`
		8d0e4d	`+`
		8d0e4d	`+ memset (&state, '\0', sizeof(mbstate_t));`
		8d0e4d	`+`
		8d0e4d	`+ if (tab_length)`
		8d0e4d	`+ while (ptr < lim && sword--)`
		8d0e4d	`+ {`
		8d0e4d	`+ while (ptr < lim && memcmp (ptr, tab, tab_length) != 0)`
		8d0e4d	`+ {`
		8d0e4d	`+ GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state);`
		8d0e4d	`+ ptr += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+ if (ptr < lim)`
		8d0e4d	`+ {`
		8d0e4d	`+ GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state);`
		8d0e4d	`+ ptr += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+ while (ptr < lim && sword--)`
		8d0e4d	`+ {`
		8d0e4d	`+ while (ptr < lim && ismbblank (ptr, lim - ptr, &mblength))`
		8d0e4d	`+ ptr += mblength;`
		8d0e4d	`+ if (ptr < lim)`
		8d0e4d	`+ {`
		8d0e4d	`+ GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state);`
		8d0e4d	`+ ptr += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+ while (ptr < lim && !ismbblank (ptr, lim - ptr, &mblength))`
		8d0e4d	`+ ptr += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ if (key->skipsblanks)`
		8d0e4d	`+ while (ptr < lim && ismbblank (ptr, lim - ptr, &mblength))`
		8d0e4d	`+ ptr += mblength;`
		8d0e4d	`+`
		8d0e4d	`+ for (i = 0; i < schar; i++)`
		8d0e4d	`+ {`
		8d0e4d	`+ GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state);`
		8d0e4d	`+`
		8d0e4d	`+ if (ptr + mblength > lim)`
		8d0e4d	`+ break;`
		8d0e4d	`+ else`
		8d0e4d	`+ ptr += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ return ptr;`
		8d0e4d	`+}`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`/* Return the limit of (a pointer to the first character after) the field`
		8d0e4d	`in LINE specified by KEY. */`
		8d0e4d
		8d0e4d	`static char *`
		8d0e4d	`-limfield (struct line const line, struct keyfield const key)`
		8d0e4d	`+limfield_uni (const struct line line, const struct keyfield key)`
		8d0e4d	`{`
		8d0e4d	`char ptr = line->text, lim = ptr + line->length - 1;`
		8d0e4d	`size_t eword = key->eword, echar = key->echar;`
		8d0e4d	`@@ -1661,10 +1869,10 @@ limfield (struct line const line, struct keyfield const key)`
		8d0e4d	`'beginning' is the first character following the delimiting TAB.`
		8d0e4d	`Otherwise, leave PTR pointing at the first 'blank' character after`
		8d0e4d	`the preceding field. */`
		8d0e4d	`- if (tab != TAB_DEFAULT)`
		8d0e4d	`+ if (tab_length)`
		8d0e4d	`while (ptr < lim && eword--)`
		8d0e4d	`{`
		8d0e4d	`- while (ptr < lim && *ptr != tab)`
		8d0e4d	`+ while (ptr < lim && *ptr != tab[0])`
		8d0e4d	`++ptr;`
		8d0e4d	`if (ptr < lim && (eword \|\| echar))`
		8d0e4d	`++ptr;`
		8d0e4d	`@@ -1710,10 +1918,10 @@ limfield (struct line const line, struct keyfield const key)`
		8d0e4d	`*/`
		8d0e4d
		8d0e4d	`/* Make LIM point to the end of (one byte past) the current field. */`
		8d0e4d	`- if (tab != TAB_DEFAULT)`
		8d0e4d	`+ if (tab_length)`
		8d0e4d	`{`
		8d0e4d	`char *newlim;`
		8d0e4d	`- newlim = memchr (ptr, tab, lim - ptr);`
		8d0e4d	`+ newlim = memchr (ptr, tab[0], lim - ptr);`
		8d0e4d	`if (newlim)`
		8d0e4d	`lim = newlim;`
		8d0e4d	`}`
		8d0e4d	`@@ -1744,6 +1952,130 @@ limfield (struct line const line, struct keyfield const key)`
		8d0e4d	`return ptr;`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+static char *`
		8d0e4d	`+limfield_mb (const struct line line, const struct keyfield key)`
		8d0e4d	`+{`
		8d0e4d	`+ char ptr = line->text, lim = ptr + line->length - 1;`
		8d0e4d	`+ size_t eword = key->eword, echar = key->echar;`
		8d0e4d	`+ int i;`
		8d0e4d	`+ size_t mblength;`
		8d0e4d	`+ mbstate_t state;`
		8d0e4d	`+`
		8d0e4d	`+ if (echar == 0)`
		8d0e4d	`+ eword++; /* skip all of end field. */`
		8d0e4d	`+`
		8d0e4d	`+ memset (&state, '\0', sizeof(mbstate_t));`
		8d0e4d	`+`
		8d0e4d	`+ if (tab_length)`
		8d0e4d	`+ while (ptr < lim && eword--)`
		8d0e4d	`+ {`
		8d0e4d	`+ while (ptr < lim && memcmp (ptr, tab, tab_length) != 0)`
		8d0e4d	`+ {`
		8d0e4d	`+ GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state);`
		8d0e4d	`+ ptr += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+ if (ptr < lim && (eword \| echar))`
		8d0e4d	`+ {`
		8d0e4d	`+ GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state);`
		8d0e4d	`+ ptr += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+ while (ptr < lim && eword--)`
		8d0e4d	`+ {`
		8d0e4d	`+ while (ptr < lim && ismbblank (ptr, lim - ptr, &mblength))`
		8d0e4d	`+ ptr += mblength;`
		8d0e4d	`+ if (ptr < lim)`
		8d0e4d	`+ {`
		8d0e4d	`+ GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state);`
		8d0e4d	`+ ptr += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+ while (ptr < lim && !ismbblank (ptr, lim - ptr, &mblength))`
		8d0e4d	`+ ptr += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+`
		8d0e4d	`+# ifdef POSIX_UNSPECIFIED`
		8d0e4d	`+ /* Make LIM point to the end of (one byte past) the current field. */`
		8d0e4d	`+ if (tab_length)`
		8d0e4d	`+ {`
		8d0e4d	`+ char newlim, p;`
		8d0e4d	`+`
		8d0e4d	`+ newlim = NULL;`
		8d0e4d	`+ for (p = ptr; p < lim;)`
		8d0e4d	`+ {`
		8d0e4d	`+ if (memcmp (p, tab, tab_length) == 0)`
		8d0e4d	`+ {`
		8d0e4d	`+ newlim = p;`
		8d0e4d	`+ break;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state);`
		8d0e4d	`+ p += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+ {`
		8d0e4d	`+ char *newlim;`
		8d0e4d	`+ newlim = ptr;`
		8d0e4d	`+`
		8d0e4d	`+ while (newlim < lim && ismbblank (newlim, lim - newlim, &mblength))`
		8d0e4d	`+ newlim += mblength;`
		8d0e4d	`+ if (ptr < lim)`
		8d0e4d	`+ {`
		8d0e4d	`+ GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state);`
		8d0e4d	`+ ptr += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+ while (newlim < lim && !ismbblank (newlim, lim - newlim, &mblength))`
		8d0e4d	`+ newlim += mblength;`
		8d0e4d	`+ lim = newlim;`
		8d0e4d	`+ }`
		8d0e4d	`+# endif`
		8d0e4d	`+`
		8d0e4d	`+ if (echar != 0)`
		8d0e4d	`+ {`
		8d0e4d	`+ /* If we're skipping leading blanks, don't start counting characters`
		8d0e4d	`+ * until after skipping past any leading blanks. */`
		8d0e4d	`+ if (key->skipeblanks)`
		8d0e4d	`+ while (ptr < lim && ismbblank (ptr, lim - ptr, &mblength))`
		8d0e4d	`+ ptr += mblength;`
		8d0e4d	`+`
		8d0e4d	`+ memset (&state, '\0', sizeof(mbstate_t));`
		8d0e4d	`+`
		8d0e4d	`+ /* Advance PTR by ECHAR (if possible), but no further than LIM. */`
		8d0e4d	`+ for (i = 0; i < echar; i++)`
		8d0e4d	`+ {`
		8d0e4d	`+ GET_BYTELEN_OF_CHAR (lim, ptr, mblength, state);`
		8d0e4d	`+`
		8d0e4d	`+ if (ptr + mblength > lim)`
		8d0e4d	`+ break;`
		8d0e4d	`+ else`
		8d0e4d	`+ ptr += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ return ptr;`
		8d0e4d	`+}`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`+static void`
		8d0e4d	`+skipblanks_uni (char *ptr, char lim)`
		8d0e4d	`+{`
		8d0e4d	`+ while (ptr < lim && blanks[to_uchar (*ptr)])`
		8d0e4d	`+ ++(*ptr);`
		8d0e4d	`+}`
		8d0e4d	`+`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+static void`
		8d0e4d	`+skipblanks_mb (char *ptr, char lim)`
		8d0e4d	`+{`
		8d0e4d	`+ size_t mblength;`
		8d0e4d	`+ while (ptr < lim && ismbblank (ptr, lim - *ptr, &mblength))`
		8d0e4d	`+ (*ptr) += mblength;`
		8d0e4d	`+}`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`/* Fill BUF reading from FP, moving buf->left bytes from the end`
		8d0e4d	`of buf->buf to the beginning first. If EOF is reached and the`
		8d0e4d	`file wasn't terminated by a newline, supply one. Set up BUF's line`
		8d0e4d	`@@ -1830,8 +2162,22 @@ fillbuf (struct buffer buf, FILE fp, char const *file)`
		8d0e4d	`else`
		8d0e4d	`{`
		8d0e4d	`if (key->skipsblanks)`
		8d0e4d	`- while (blanks[to_uchar (*line_start)])`
		8d0e4d	`- line_start++;`
		8d0e4d	`+ {`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ if (MB_CUR_MAX > 1)`
		8d0e4d	`+ {`
		8d0e4d	`+ size_t mblength;`
		8d0e4d	`+ while (line_start < line->keylim &&`
		8d0e4d	`+ ismbblank (line_start,`
		8d0e4d	`+ line->keylim - line_start,`
		8d0e4d	`+ &mblength))`
		8d0e4d	`+ line_start += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+#endif`
		8d0e4d	`+ while (blanks[to_uchar (*line_start)])`
		8d0e4d	`+ line_start++;`
		8d0e4d	`+ }`
		8d0e4d	`line->keybeg = line_start;`
		8d0e4d	`}`
		8d0e4d	`}`
		8d0e4d	`@@ -1981,7 +2327,7 @@ human_numcompare (char const a, char const b)`
		8d0e4d	`hideously fast. */`
		8d0e4d
		8d0e4d	`static int`
		8d0e4d	`-numcompare (char const a, char const b)`
		8d0e4d	`+numcompare_uni (const char a, const char b)`
		8d0e4d	`{`
		8d0e4d	`while (blanks[to_uchar (*a)])`
		8d0e4d	`a++;`
		8d0e4d	`@@ -1991,6 +2337,25 @@ numcompare (char const a, char const b)`
		8d0e4d	`return strnumcmp (a, b, decimal_point, thousands_sep);`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+static int`
		8d0e4d	`+numcompare_mb (const char a, const char b)`
		8d0e4d	`+{`
		8d0e4d	`+ size_t mblength, len;`
		8d0e4d	`+ len = strlen (a); /* okay for UTF-8 */`
		8d0e4d	`+ while (*a && ismbblank (a, len > MB_CUR_MAX ? MB_CUR_MAX : len, &mblength))`
		8d0e4d	`+ {`
		8d0e4d	`+ a += mblength;`
		8d0e4d	`+ len -= mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+ len = strlen (b); /* okay for UTF-8 */`
		8d0e4d	`+ while (*b && ismbblank (b, len > MB_CUR_MAX ? MB_CUR_MAX : len, &mblength))`
		8d0e4d	`+ b += mblength;`
		8d0e4d	`+`
		8d0e4d	`+ return strnumcmp (a, b, decimal_point, thousands_sep);`
		8d0e4d	`+}`
		8d0e4d	`+#endif /* HAV_EMBRTOWC */`
		8d0e4d	`+`
		8d0e4d	`/* Work around a problem whereby the long double value returned by glibc's`
		8d0e4d	`strtold ("NaN", ...) contains uninitialized bits: clear all bytes of`
		8d0e4d	`A and B before calling strtold. FIXME: remove this function once`
		8d0e4d	`@@ -2041,7 +2406,7 @@ general_numcompare (char const sa, char const sb)`
		8d0e4d	`Return 0 if the name in S is not recognized. */`
		8d0e4d
		8d0e4d	`static int`
		8d0e4d	`-getmonth (char const month, char *ea)`
		8d0e4d	`+getmonth_uni (char const month, size_t len, char *ea)`
		8d0e4d	`{`
		8d0e4d	`size_t lo = 0;`
		8d0e4d	`size_t hi = MONTHS_PER_YEAR;`
		8d0e4d	`@@ -2317,15 +2682,14 @@ debug_key (struct line const line, struct keyfield const key)`
		8d0e4d	`char saved = *lim;`
		8d0e4d	`*lim = '\0';`
		8d0e4d
		8d0e4d	`- while (blanks[to_uchar (*beg)])`
		8d0e4d	`- beg++;`
		8d0e4d	`+ skipblanks (&beg, lim);`
		8d0e4d
		8d0e4d	`char *tighter_lim = beg;`
		8d0e4d
		8d0e4d	`if (lim < beg)`
		8d0e4d	`tighter_lim = lim;`
		8d0e4d	`else if (key->month)`
		8d0e4d	`- getmonth (beg, &tighter_lim);`
		8d0e4d	`+ getmonth (beg, lim-beg, &tighter_lim);`
		8d0e4d	`else if (key->general_numeric)`
		8d0e4d	`ignore_value (strtold (beg, &tighter_lim));`
		8d0e4d	`else if (key->numeric \|\| key->human_numeric)`
		8d0e4d	`@@ -2459,7 +2823,7 @@ key_warnings (struct keyfield const *gkey, bool gkey_only)`
		8d0e4d	`/* Warn about significant leading blanks. */`
		8d0e4d	`bool implicit_skip = key_numeric (key) \|\| key->month;`
		8d0e4d	`bool line_offset = key->eword == 0 && key->echar != 0; /* -k1.x,1.y */`
		8d0e4d	`- if (!zero_width && !gkey_only && tab == TAB_DEFAULT && !line_offset`
		8d0e4d	`+ if (!zero_width && !gkey_only && !tab_length && !line_offset`
		8d0e4d	`&& ((!key->skipsblanks && !implicit_skip)`
		8d0e4d	`\|\| (!key->skipsblanks && key->schar)`
		8d0e4d	`\|\| (!key->skipeblanks && key->echar)))`
		8d0e4d	`@@ -2517,11 +2881,87 @@ key_warnings (struct keyfield const *gkey, bool gkey_only)`
		8d0e4d	`error (0, 0, _("option '-r' only applies to last-resort comparison"));`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+static int`
		8d0e4d	`+getmonth_mb (const char s, size_t len, char *ea)`
		8d0e4d	`+{`
		8d0e4d	`+ char *month;`
		8d0e4d	`+ register size_t i;`
		8d0e4d	`+ register int lo = 0, hi = MONTHS_PER_YEAR, result;`
		8d0e4d	`+ char *tmp;`
		8d0e4d	`+ size_t wclength, mblength;`
		8d0e4d	`+ const char *pp;`
		8d0e4d	`+ const wchar_t *wpp;`
		8d0e4d	`+ wchar_t *month_wcs;`
		8d0e4d	`+ mbstate_t state;`
		8d0e4d	`+`
		8d0e4d	`+ while (len > 0 && ismbblank (s, len, &mblength))`
		8d0e4d	`+ {`
		8d0e4d	`+ s += mblength;`
		8d0e4d	`+ len -= mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ if (len == 0)`
		8d0e4d	`+ return 0;`
		8d0e4d	`+`
		8d0e4d	`+ if (SIZE_MAX - len < 1)`
		8d0e4d	`+ xalloc_die ();`
		8d0e4d	`+`
		8d0e4d	`+ month = (char *) xnmalloc (len + 1, MB_CUR_MAX);`
		8d0e4d	`+`
		8d0e4d	`+ pp = tmp = (char *) xnmalloc (len + 1, MB_CUR_MAX);`
		8d0e4d	`+ memcpy (tmp, s, len);`
		8d0e4d	`+ tmp[len] = '\0';`
		8d0e4d	`+ wpp = month_wcs = (wchar_t *) xnmalloc (len + 1, sizeof (wchar_t));`
		8d0e4d	`+ memset (&state, '\0', sizeof (mbstate_t));`
		8d0e4d	`+`
		8d0e4d	`+ wclength = mbsrtowcs (month_wcs, &pp, len + 1, &state);`
		8d0e4d	`+ if (wclength == (size_t)-1 \|\| pp != NULL)`
		8d0e4d	`+ error (SORT_FAILURE, 0, _("Invalid multibyte input %s."), quote(s));`
		8d0e4d	`+`
		8d0e4d	`+ for (i = 0; i < wclength; i++)`
		8d0e4d	`+ {`
		8d0e4d	`+ month_wcs[i] = towupper(month_wcs[i]);`
		8d0e4d	`+ if (iswblank (month_wcs[i]))`
		8d0e4d	`+ {`
		8d0e4d	`+ month_wcs[i] = L'\0';`
		8d0e4d	`+ break;`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ mblength = wcsrtombs (month, &wpp, (len + 1) * MB_CUR_MAX, &state);`
		8d0e4d	`+ assert (mblength != (-1) && wpp == NULL);`
		8d0e4d	`+`
		8d0e4d	`+ do`
		8d0e4d	`+ {`
		8d0e4d	`+ int ix = (lo + hi) / 2;`
		8d0e4d	`+`
		8d0e4d	`+ if (strncmp (month, monthtab[ix].name, strlen (monthtab[ix].name)) < 0)`
		8d0e4d	`+ hi = ix;`
		8d0e4d	`+ else`
		8d0e4d	`+ lo = ix;`
		8d0e4d	`+ }`
		8d0e4d	`+ while (hi - lo > 1);`
		8d0e4d	`+`
		8d0e4d	`+ result = (!strncmp (month, monthtab[lo].name, strlen (monthtab[lo].name))`
		8d0e4d	`+ ? monthtab[lo].val : 0);`
		8d0e4d	`+`
		8d0e4d	`+ if (ea && result)`
		8d0e4d	`+ ea = (char) s + strlen (monthtab[lo].name);`
		8d0e4d	`+`
		8d0e4d	`+ free (month);`
		8d0e4d	`+ free (tmp);`
		8d0e4d	`+ free (month_wcs);`
		8d0e4d	`+`
		8d0e4d	`+ return result;`
		8d0e4d	`+}`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`/* Compare two lines A and B trying every key in sequence until there`
		8d0e4d	`are no more keys or a difference is found. */`
		8d0e4d
		8d0e4d	`static int`
		8d0e4d	`-keycompare (struct line const a, struct line const b)`
		8d0e4d	`+keycompare_uni (const struct line a, const struct line b)`
		8d0e4d	`{`
		8d0e4d	`struct keyfield *key = keylist;`
		8d0e4d
		8d0e4d	`@@ -2606,7 +3046,7 @@ keycompare (struct line const a, struct line const b)`
		8d0e4d	`else if (key->human_numeric)`
		8d0e4d	`diff = human_numcompare (ta, tb);`
		8d0e4d	`else if (key->month)`
		8d0e4d	`- diff = getmonth (ta, NULL) - getmonth (tb, NULL);`
		8d0e4d	`+ diff = getmonth (ta, tlena, NULL) - getmonth (tb, tlenb, NULL);`
		8d0e4d	`else if (key->random)`
		8d0e4d	`diff = compare_random (ta, tlena, tb, tlenb);`
		8d0e4d	`else if (key->version)`
		8d0e4d	`@@ -2722,6 +3162,211 @@ keycompare (struct line const a, struct line const b)`
		8d0e4d	`return key->reverse ? -diff : diff;`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+static int`
		8d0e4d	`+keycompare_mb (const struct line a, const struct line b)`
		8d0e4d	`+{`
		8d0e4d	`+ struct keyfield *key = keylist;`
		8d0e4d	`+`
		8d0e4d	`+ /* For the first iteration only, the key positions have been`
		8d0e4d	`+ precomputed for us. */`
		8d0e4d	`+ char *texta = a->keybeg;`
		8d0e4d	`+ char *textb = b->keybeg;`
		8d0e4d	`+ char *lima = a->keylim;`
		8d0e4d	`+ char *limb = b->keylim;`
		8d0e4d	`+`
		8d0e4d	`+ size_t mblength_a, mblength_b;`
		8d0e4d	`+ wchar_t wc_a, wc_b;`
		8d0e4d	`+ mbstate_t state_a, state_b;`
		8d0e4d	`+`
		8d0e4d	`+ int diff = 0;`
		8d0e4d	`+`
		8d0e4d	`+ memset (&state_a, '\0', sizeof(mbstate_t));`
		8d0e4d	`+ memset (&state_b, '\0', sizeof(mbstate_t));`
		8d0e4d	`+ /* Ignore keys with start after end. */`
		8d0e4d	`+ if (a->keybeg - a->keylim > 0)`
		8d0e4d	`+ return 0;`
		8d0e4d	`+`
		8d0e4d	`+`
		8d0e4d	`+ /* Ignore and/or translate chars before comparing. */`
		8d0e4d	`+# define IGNORE_CHARS(NEW_LEN, LEN, TEXT, COPY, WC, MBLENGTH, STATE) \`
		8d0e4d	`+ do \`
		8d0e4d	`+ { \`
		8d0e4d	`+ wchar_t uwc; \`
		8d0e4d	`+ char mbc[MB_LEN_MAX]; \`
		8d0e4d	`+ mbstate_t state_wc; \`
		8d0e4d	`+ \`
		8d0e4d	`+ for (NEW_LEN = i = 0; i < LEN;) \`
		8d0e4d	`+ { \`
		8d0e4d	`+ mbstate_t state_bak; \`
		8d0e4d	`+ \`
		8d0e4d	`+ state_bak = STATE; \`
		8d0e4d	`+ MBLENGTH = mbrtowc (&WC, TEXT + i, LEN - i, &STATE); \`
		8d0e4d	`+ \`
		8d0e4d	`+ if (MBLENGTH == (size_t)-2 \|\| MBLENGTH == (size_t)-1 \`
		8d0e4d	`+ \|\| MBLENGTH == 0) \`
		8d0e4d	`+ { \`
		8d0e4d	`+ if (MBLENGTH == (size_t)-2 \|\| MBLENGTH == (size_t)-1) \`
		8d0e4d	`+ STATE = state_bak; \`
		8d0e4d	`+ if (!ignore) \`
		8d0e4d	`+ COPY[NEW_LEN++] = TEXT[i]; \`
		8d0e4d	`+ i++; \`
		8d0e4d	`+ continue; \`
		8d0e4d	`+ } \`
		8d0e4d	`+ \`
		8d0e4d	`+ if (ignore) \`
		8d0e4d	`+ { \`
		8d0e4d	`+ if ((ignore == nonprinting && !iswprint (WC)) \`
		8d0e4d	`+ \|\| (ignore == nondictionary \`
		8d0e4d	`+ && !iswalnum (WC) && !iswblank (WC))) \`
		8d0e4d	`+ { \`
		8d0e4d	`+ i += MBLENGTH; \`
		8d0e4d	`+ continue; \`
		8d0e4d	`+ } \`
		8d0e4d	`+ } \`
		8d0e4d	`+ \`
		8d0e4d	`+ if (translate) \`
		8d0e4d	`+ { \`
		8d0e4d	`+ \`
		8d0e4d	`+ uwc = towupper(WC); \`
		8d0e4d	`+ if (WC == uwc) \`
		8d0e4d	`+ { \`
		8d0e4d	`+ memcpy (mbc, TEXT + i, MBLENGTH); \`
		8d0e4d	`+ i += MBLENGTH; \`
		8d0e4d	`+ } \`
		8d0e4d	`+ else \`
		8d0e4d	`+ { \`
		8d0e4d	`+ i += MBLENGTH; \`
		8d0e4d	`+ WC = uwc; \`
		8d0e4d	`+ memset (&state_wc, '\0', sizeof (mbstate_t)); \`
		8d0e4d	`+ \`
		8d0e4d	`+ MBLENGTH = wcrtomb (mbc, WC, &state_wc); \`
		8d0e4d	`+ assert (MBLENGTH != (size_t)-1 && MBLENGTH != 0); \`
		8d0e4d	`+ } \`
		8d0e4d	`+ \`
		8d0e4d	`+ for (j = 0; j < MBLENGTH; j++) \`
		8d0e4d	`+ COPY[NEW_LEN++] = mbc[j]; \`
		8d0e4d	`+ } \`
		8d0e4d	`+ else \`
		8d0e4d	`+ for (j = 0; j < MBLENGTH; j++) \`
		8d0e4d	`+ COPY[NEW_LEN++] = TEXT[i++]; \`
		8d0e4d	`+ } \`
		8d0e4d	`+ COPY[NEW_LEN] = '\0'; \`
		8d0e4d	`+ } \`
		8d0e4d	`+ while (0)`
		8d0e4d	`+`
		8d0e4d	`+ /* Actually compare the fields. */`
		8d0e4d	`+`
		8d0e4d	`+ for (;;)`
		8d0e4d	`+ {`
		8d0e4d	`+ /* Find the lengths. */`
		8d0e4d	`+ size_t lena = lima <= texta ? 0 : lima - texta;`
		8d0e4d	`+ size_t lenb = limb <= textb ? 0 : limb - textb;`
		8d0e4d	`+`
		8d0e4d	`+ char enda IF_LINT (= 0);`
		8d0e4d	`+ char endb IF_LINT (= 0);`
		8d0e4d	`+`
		8d0e4d	`+ char const *translate = key->translate;`
		8d0e4d	`+ bool const *ignore = key->ignore;`
		8d0e4d	`+`
		8d0e4d	`+ if (ignore \|\| translate)`
		8d0e4d	`+ {`
		8d0e4d	`+ if (SIZE_MAX - lenb - 2 < lena)`
		8d0e4d	`+ xalloc_die ();`
		8d0e4d	`+ char copy_a = (char ) xnmalloc (lena + lenb + 2, MB_CUR_MAX);`
		8d0e4d	`+ char copy_b = copy_a + lena MB_CUR_MAX + 1;`
		8d0e4d	`+ size_t new_len_a, new_len_b;`
		8d0e4d	`+ size_t i, j;`
		8d0e4d	`+`
		8d0e4d	`+ IGNORE_CHARS (new_len_a, lena, texta, copy_a,`
		8d0e4d	`+ wc_a, mblength_a, state_a);`
		8d0e4d	`+ IGNORE_CHARS (new_len_b, lenb, textb, copy_b,`
		8d0e4d	`+ wc_b, mblength_b, state_b);`
		8d0e4d	`+ texta = copy_a; textb = copy_b;`
		8d0e4d	`+ lena = new_len_a; lenb = new_len_b;`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+ {`
		8d0e4d	`+ /* Use the keys in-place, temporarily null-terminated. */`
		8d0e4d	`+ enda = texta[lena]; texta[lena] = '\0';`
		8d0e4d	`+ endb = textb[lenb]; textb[lenb] = '\0';`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ if (key->random)`
		8d0e4d	`+ diff = compare_random (texta, lena, textb, lenb);`
		8d0e4d	`+ else if (key->numeric \| key->general_numeric \| key->human_numeric)`
		8d0e4d	`+ {`
		8d0e4d	`+ char savea = lima, saveb = limb;`
		8d0e4d	`+`
		8d0e4d	`+ lima = limb = '\0';`
		8d0e4d	`+ diff = (key->numeric ? numcompare (texta, textb)`
		8d0e4d	`+ : key->general_numeric ? general_numcompare (texta, textb)`
		8d0e4d	`+ : human_numcompare (texta, textb));`
		8d0e4d	`+ lima = savea, limb = saveb;`
		8d0e4d	`+ }`
		8d0e4d	`+ else if (key->version)`
		8d0e4d	`+ diff = filevercmp (texta, textb);`
		8d0e4d	`+ else if (key->month)`
		8d0e4d	`+ diff = getmonth (texta, lena, NULL) - getmonth (textb, lenb, NULL);`
		8d0e4d	`+ else if (lena == 0)`
		8d0e4d	`+ diff = - NONZERO (lenb);`
		8d0e4d	`+ else if (lenb == 0)`
		8d0e4d	`+ diff = 1;`
		8d0e4d	`+ else if (hard_LC_COLLATE && !folding)`
		8d0e4d	`+ {`
		8d0e4d	`+ diff = xmemcoll0 (texta, lena + 1, textb, lenb + 1);`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+ {`
		8d0e4d	`+ diff = memcmp (texta, textb, MIN (lena, lenb));`
		8d0e4d	`+ if (diff == 0)`
		8d0e4d	`+ diff = lena < lenb ? -1 : lena != lenb;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ if (ignore \|\| translate)`
		8d0e4d	`+ free (texta);`
		8d0e4d	`+ else`
		8d0e4d	`+ {`
		8d0e4d	`+ texta[lena] = enda;`
		8d0e4d	`+ textb[lenb] = endb;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ if (diff)`
		8d0e4d	`+ goto not_equal;`
		8d0e4d	`+`
		8d0e4d	`+ key = key->next;`
		8d0e4d	`+ if (! key)`
		8d0e4d	`+ break;`
		8d0e4d	`+`
		8d0e4d	`+ /* Find the beginning and limit of the next field. */`
		8d0e4d	`+ if (key->eword != -1)`
		8d0e4d	`+ lima = limfield (a, key), limb = limfield (b, key);`
		8d0e4d	`+ else`
		8d0e4d	`+ lima = a->text + a->length - 1, limb = b->text + b->length - 1;`
		8d0e4d	`+`
		8d0e4d	`+ if (key->sword != -1)`
		8d0e4d	`+ texta = begfield (a, key), textb = begfield (b, key);`
		8d0e4d	`+ else`
		8d0e4d	`+ {`
		8d0e4d	`+ texta = a->text, textb = b->text;`
		8d0e4d	`+ if (key->skipsblanks)`
		8d0e4d	`+ {`
		8d0e4d	`+ while (texta < lima && ismbblank (texta, lima - texta, &mblength_a))`
		8d0e4d	`+ texta += mblength_a;`
		8d0e4d	`+ while (textb < limb && ismbblank (textb, limb - textb, &mblength_b))`
		8d0e4d	`+ textb += mblength_b;`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+not_equal:`
		8d0e4d	`+ if (key && key->reverse)`
		8d0e4d	`+ return -diff;`
		8d0e4d	`+ else`
		8d0e4d	`+ return diff;`
		8d0e4d	`+}`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`/* Compare two lines A and B, returning negative, zero, or positive`
		8d0e4d	`depending on whether A compares less than, equal to, or greater than B. */`
		8d0e4d
		8d0e4d	`@@ -2749,7 +3394,7 @@ compare (struct line const a, struct line const b)`
		8d0e4d	`diff = - NONZERO (blen);`
		8d0e4d	`else if (blen == 0)`
		8d0e4d	`diff = 1;`
		8d0e4d	`- else if (hard_LC_COLLATE)`
		8d0e4d	`+ else if (hard_LC_COLLATE && !folding)`
		8d0e4d	`{`
		8d0e4d	`/* xmemcoll0 is a performance enhancement as`
		8d0e4d	`it will not unconditionally write '\0' after the`
		8d0e4d	`@@ -4144,6 +4789,7 @@ set_ordering (char const s, struct keyfield key, enum blanktype blanktype)`
		8d0e4d	`break;`
		8d0e4d	`case 'f':`
		8d0e4d	`key->translate = fold_toupper;`
		8d0e4d	`+ folding = true;`
		8d0e4d	`break;`
		8d0e4d	`case 'g':`
		8d0e4d	`key->general_numeric = true;`
		8d0e4d	`@@ -4223,7 +4869,7 @@ main (int argc, char **argv)`
		8d0e4d	`initialize_exit_failure (SORT_FAILURE);`
		8d0e4d
		8d0e4d	`hard_LC_COLLATE = hard_locale (LC_COLLATE);`
		8d0e4d	`-#if HAVE_NL_LANGINFO`
		8d0e4d	`+#if HAVE_LANGINFO_CODESET`
		8d0e4d	`hard_LC_TIME = hard_locale (LC_TIME);`
		8d0e4d	`#endif`
		8d0e4d
		8d0e4d	`@@ -4244,6 +4890,29 @@ main (int argc, char **argv)`
		8d0e4d	`thousands_sep = -1;`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ if (MB_CUR_MAX > 1)`
		8d0e4d	`+ {`
		8d0e4d	`+ inittables = inittables_mb;`
		8d0e4d	`+ begfield = begfield_mb;`
		8d0e4d	`+ limfield = limfield_mb;`
		8d0e4d	`+ skipblanks = skipblanks_mb;`
		8d0e4d	`+ getmonth = getmonth_mb;`
		8d0e4d	`+ keycompare = keycompare_mb;`
		8d0e4d	`+ numcompare = numcompare_mb;`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+#endif`
		8d0e4d	`+ {`
		8d0e4d	`+ inittables = inittables_uni;`
		8d0e4d	`+ begfield = begfield_uni;`
		8d0e4d	`+ limfield = limfield_uni;`
		8d0e4d	`+ skipblanks = skipblanks_uni;`
		8d0e4d	`+ getmonth = getmonth_uni;`
		8d0e4d	`+ keycompare = keycompare_uni;`
		8d0e4d	`+ numcompare = numcompare_uni;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`have_read_stdin = false;`
		8d0e4d	`inittables ();`
		8d0e4d
		8d0e4d	`@@ -4518,13 +5187,34 @@ main (int argc, char **argv)`
		8d0e4d
		8d0e4d	`case 't':`
		8d0e4d	`{`
		8d0e4d	`- char newtab = optarg[0];`
		8d0e4d	`- if (! newtab)`
		8d0e4d	`+ char newtab[MB_LEN_MAX + 1];`
		8d0e4d	`+ size_t newtab_length = 1;`
		8d0e4d	`+ strncpy (newtab, optarg, MB_LEN_MAX);`
		8d0e4d	`+ if (! newtab[0])`
		8d0e4d	`die (SORT_FAILURE, 0, _("empty tab"));`
		8d0e4d	`- if (optarg[1])`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ if (MB_CUR_MAX > 1)`
		8d0e4d	`+ {`
		8d0e4d	`+ wchar_t wc;`
		8d0e4d	`+ mbstate_t state;`
		8d0e4d	`+`
		8d0e4d	`+ memset (&state, '\0', sizeof (mbstate_t));`
		8d0e4d	`+ newtab_length = mbrtowc (&wc, newtab, strnlen (newtab,`
		8d0e4d	`+ MB_LEN_MAX),`
		8d0e4d	`+ &state);`
		8d0e4d	`+ switch (newtab_length)`
		8d0e4d	`+ {`
		8d0e4d	`+ case (size_t) -1:`
		8d0e4d	`+ case (size_t) -2:`
		8d0e4d	`+ case 0:`
		8d0e4d	`+ newtab_length = 1;`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+#endif`
		8d0e4d	`+ if (newtab_length == 1 && optarg[1])`
		8d0e4d	`{`
		8d0e4d	`if (STREQ (optarg, "\\0"))`
		8d0e4d	`- newtab = '\0';`
		8d0e4d	`+ newtab[0] = '\0';`
		8d0e4d	`else`
		8d0e4d	`{`
		8d0e4d	`/* Provoke with 'sort -txx'. Complain about`
		8d0e4d	`@@ -4535,9 +5225,11 @@ main (int argc, char **argv)`
		8d0e4d	`quote (optarg));`
		8d0e4d	`}`
		8d0e4d	`}`
		8d0e4d	`- if (tab != TAB_DEFAULT && tab != newtab)`
		8d0e4d	`+ if (tab_length && (tab_length != newtab_length`
		8d0e4d	`+ \|\| memcmp (tab, newtab, tab_length) != 0))`
		8d0e4d	`die (SORT_FAILURE, 0, _("incompatible tabs"));`
		8d0e4d	`- tab = newtab;`
		8d0e4d	`+ memcpy (tab, newtab, newtab_length);`
		8d0e4d	`+ tab_length = newtab_length;`
		8d0e4d	`}`
		8d0e4d	`break;`
		8d0e4d
		8d0e4d	`@@ -4765,12 +5457,10 @@ main (int argc, char **argv)`
		8d0e4d	`sort (files, nfiles, outfile, nthreads);`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`-#ifdef lint`
		8d0e4d	`if (files_from)`
		8d0e4d	`readtokens0_free (&tok;;`
		8d0e4d	`else`
		8d0e4d	`free (files);`
		8d0e4d	`-#endif`
		8d0e4d
		8d0e4d	`if (have_read_stdin && fclose (stdin) == EOF)`
		8d0e4d	`sort_die (_("close failed"), "-");`
		8d0e4d	`diff --git a/src/uniq.c b/src/uniq.c`
		8d0e4d	`index 87a0c93..9f755d9 100644`
		8d0e4d	`--- a/src/uniq.c`
		8d0e4d	`+++ b/src/uniq.c`
		8d0e4d	`@@ -21,6 +21,17 @@`
		8d0e4d	`#include <getopt.h>`
		8d0e4d	`#include <sys/types.h>`
		8d0e4d
		8d0e4d	`+/* Get mbstate_t, mbrtowc(). */`
		8d0e4d	`+#if HAVE_WCHAR_H`
		8d0e4d	`+# include <wchar.h>`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`+/* Get isw* functions. */`
		8d0e4d	`+#if HAVE_WCTYPE_H`
		8d0e4d	`+# include <wctype.h>`
		8d0e4d	`+#endif`
		8d0e4d	`+#include <assert.h>`
		8d0e4d	`+`
		8d0e4d	`#include "system.h"`
		8d0e4d	`#include "argmatch.h"`
		8d0e4d	`#include "linebuffer.h"`
		8d0e4d	`@@ -32,9 +43,21 @@`
		8d0e4d	`#include "stdio--.h"`
		8d0e4d	`#include "xmemcoll.h"`
		8d0e4d	`#include "xstrtol.h"`
		8d0e4d	`-#include "memcasecmp.h"`
		8d0e4d	`+#include "xmemcoll.h"`
		8d0e4d	`#include "quote.h"`
		8d0e4d
		8d0e4d	`+/* MB_LEN_MAX is incorrectly defined to be 1 in at least one GCC`
		8d0e4d	`+ installation; work around this configuration error. */`
		8d0e4d	`+#if !defined MB_LEN_MAX \|\| MB_LEN_MAX < 2`
		8d0e4d	`+# define MB_LEN_MAX 16`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`+/* Some systems, like BeOS, have multibyte encodings but lack mbstate_t. */`
		8d0e4d	`+#if HAVE_MBRTOWC && defined mbstate_t`
		8d0e4d	`+# define mbrtowc(pwc, s, n, ps) (mbrtowc) (pwc, s, n, 0)`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`+`
		8d0e4d	`/* The official name of this program (e.g., no 'g' prefix). */`
		8d0e4d	`#define PROGRAM_NAME "uniq"`
		8d0e4d
		8d0e4d	`@@ -144,6 +167,10 @@ enum`
		8d0e4d	`GROUP_OPTION = CHAR_MAX + 1`
		8d0e4d	`};`
		8d0e4d
		8d0e4d	`+/* Function pointers. */`
		8d0e4d	`+static char *`
		8d0e4d	`+(find_field) (struct linebuffer line);`
		8d0e4d	`+`
		8d0e4d	`static struct option const longopts[] =`
		8d0e4d	`{`
		8d0e4d	`{"count", no_argument, NULL, 'c'},`
		8d0e4d	`@@ -260,7 +287,7 @@ size_opt (char const opt, char const msgid)`
		8d0e4d	`return a pointer to the beginning of the line's field to be compared. */`
		8d0e4d
		8d0e4d	`static char * _GL_ATTRIBUTE_PURE`
		8d0e4d	`-find_field (struct linebuffer const *line)`
		8d0e4d	`+find_field_uni (struct linebuffer *line)`
		8d0e4d	`{`
		8d0e4d	`size_t count;`
		8d0e4d	`char const *lp = line->buffer;`
		8d0e4d	`@@ -280,6 +307,83 @@ find_field (struct linebuffer const *line)`
		8d0e4d	`return line->buffer + i;`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+`
		8d0e4d	`+# define MBCHAR_TO_WCHAR(WC, MBLENGTH, LP, POS, SIZE, STATEP, CONVFAIL) \`
		8d0e4d	`+ do \`
		8d0e4d	`+ { \`
		8d0e4d	`+ mbstate_t state_bak; \`
		8d0e4d	`+ \`
		8d0e4d	`+ CONVFAIL = 0; \`
		8d0e4d	`+ state_bak = *STATEP; \`
		8d0e4d	`+ \`
		8d0e4d	`+ MBLENGTH = mbrtowc (&WC, LP + POS, SIZE - POS, STATEP); \`
		8d0e4d	`+ \`
		8d0e4d	`+ switch (MBLENGTH) \`
		8d0e4d	`+ { \`
		8d0e4d	`+ case (size_t)-2: \`
		8d0e4d	`+ case (size_t)-1: \`
		8d0e4d	`+ *STATEP = state_bak; \`
		8d0e4d	`+ CONVFAIL++; \`
		8d0e4d	`+ /* Fall through */ \`
		8d0e4d	`+ case 0: \`
		8d0e4d	`+ MBLENGTH = 1; \`
		8d0e4d	`+ } \`
		8d0e4d	`+ } \`
		8d0e4d	`+ while (0)`
		8d0e4d	`+`
		8d0e4d	`+static char *`
		8d0e4d	`+find_field_multi (struct linebuffer *line)`
		8d0e4d	`+{`
		8d0e4d	`+ size_t count;`
		8d0e4d	`+ char *lp = line->buffer;`
		8d0e4d	`+ size_t size = line->length - 1;`
		8d0e4d	`+ size_t pos;`
		8d0e4d	`+ size_t mblength;`
		8d0e4d	`+ wchar_t wc;`
		8d0e4d	`+ mbstate_t *statep;`
		8d0e4d	`+ int convfail = 0;`
		8d0e4d	`+`
		8d0e4d	`+ pos = 0;`
		8d0e4d	`+ statep = &(line->state);`
		8d0e4d	`+`
		8d0e4d	`+ /* skip fields. */`
		8d0e4d	`+ for (count = 0; count < skip_fields && pos < size; count++)`
		8d0e4d	`+ {`
		8d0e4d	`+ while (pos < size)`
		8d0e4d	`+ {`
		8d0e4d	`+ MBCHAR_TO_WCHAR (wc, mblength, lp, pos, size, statep, convfail);`
		8d0e4d	`+`
		8d0e4d	`+ if (convfail \|\| !(iswblank (wc) \|\| wc == '\n'))`
		8d0e4d	`+ {`
		8d0e4d	`+ pos += mblength;`
		8d0e4d	`+ break;`
		8d0e4d	`+ }`
		8d0e4d	`+ pos += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ while (pos < size)`
		8d0e4d	`+ {`
		8d0e4d	`+ MBCHAR_TO_WCHAR (wc, mblength, lp, pos, size, statep, convfail);`
		8d0e4d	`+`
		8d0e4d	`+ if (!convfail && (iswblank (wc) \|\| wc == '\n'))`
		8d0e4d	`+ break;`
		8d0e4d	`+`
		8d0e4d	`+ pos += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ /* skip fields. */`
		8d0e4d	`+ for (count = 0; count < skip_chars && pos < size; count++)`
		8d0e4d	`+ {`
		8d0e4d	`+ MBCHAR_TO_WCHAR (wc, mblength, lp, pos, size, statep, convfail);`
		8d0e4d	`+ pos += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ return lp + pos;`
		8d0e4d	`+}`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`/* Return false if two strings OLD and NEW match, true if not.`
		8d0e4d	`OLD and NEW point not to the beginnings of the lines`
		8d0e4d	`but rather to the beginnings of the fields to compare.`
		8d0e4d	`@@ -288,6 +392,8 @@ find_field (struct linebuffer const *line)`
		8d0e4d	`static bool`
		8d0e4d	`different (char old, char new, size_t oldlen, size_t newlen)`
		8d0e4d	`{`
		8d0e4d	`+ char copy_old, copy_new;`
		8d0e4d	`+`
		8d0e4d	`if (check_chars < oldlen)`
		8d0e4d	`oldlen = check_chars;`
		8d0e4d	`if (check_chars < newlen)`
		8d0e4d	`@@ -295,15 +401,104 @@ different (char old, char new, size_t oldlen, size_t newlen)`
		8d0e4d
		8d0e4d	`if (ignore_case)`
		8d0e4d	`{`
		8d0e4d	`- /* FIXME: This should invoke strcoll somehow. */`
		8d0e4d	`- return oldlen != newlen \|\| memcasecmp (old, new, oldlen);`
		8d0e4d	`+ size_t i;`
		8d0e4d	`+`
		8d0e4d	`+ copy_old = xmalloc (oldlen + 1);`
		8d0e4d	`+ copy_new = xmalloc (oldlen + 1);`
		8d0e4d	`+`
		8d0e4d	`+ for (i = 0; i < oldlen; i++)`
		8d0e4d	`+ {`
		8d0e4d	`+ copy_old[i] = toupper (old[i]);`
		8d0e4d	`+ copy_new[i] = toupper (new[i]);`
		8d0e4d	`+ }`
		8d0e4d	`+ bool rc = xmemcoll (copy_old, oldlen, copy_new, newlen);`
		8d0e4d	`+ free (copy_old);`
		8d0e4d	`+ free (copy_new);`
		8d0e4d	`+ return rc;`
		8d0e4d	`}`
		8d0e4d	`- else if (hard_LC_COLLATE)`
		8d0e4d	`- return xmemcoll (old, oldlen, new, newlen) != 0;`
		8d0e4d	`else`
		8d0e4d	`- return oldlen != newlen \|\| memcmp (old, new, oldlen);`
		8d0e4d	`+ {`
		8d0e4d	`+ copy_old = (char *)old;`
		8d0e4d	`+ copy_new = (char *)new;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+ return xmemcoll (copy_old, oldlen, copy_new, newlen);`
		8d0e4d	`+`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+static int`
		8d0e4d	`+different_multi (const char old, const char new, size_t oldlen, size_t newlen, mbstate_t oldstate, mbstate_t newstate)`
		8d0e4d	`+{`
		8d0e4d	`+ size_t i, j, chars;`
		8d0e4d	`+ const char *str[2];`
		8d0e4d	`+ char *copy[2];`
		8d0e4d	`+ size_t len[2];`
		8d0e4d	`+ mbstate_t state[2];`
		8d0e4d	`+ size_t mblength;`
		8d0e4d	`+ wchar_t wc, uwc;`
		8d0e4d	`+ mbstate_t state_bak;`
		8d0e4d	`+`
		8d0e4d	`+ str[0] = old;`
		8d0e4d	`+ str[1] = new;`
		8d0e4d	`+ len[0] = oldlen;`
		8d0e4d	`+ len[1] = newlen;`
		8d0e4d	`+ state[0] = oldstate;`
		8d0e4d	`+ state[1] = newstate;`
		8d0e4d	`+`
		8d0e4d	`+ for (i = 0; i < 2; i++)`
		8d0e4d	`+ {`
		8d0e4d	`+ copy[i] = xmalloc (len[i] + 1);`
		8d0e4d	`+ memset (copy[i], '\0', len[i] + 1);`
		8d0e4d	`+`
		8d0e4d	`+ for (j = 0, chars = 0; j < len[i] && chars < check_chars; chars++)`
		8d0e4d	`+ {`
		8d0e4d	`+ state_bak = state[i];`
		8d0e4d	`+ mblength = mbrtowc (&wc, str[i] + j, len[i] - j, &(state[i]));`
		8d0e4d	`+`
		8d0e4d	`+ switch (mblength)`
		8d0e4d	`+ {`
		8d0e4d	`+ case (size_t)-1:`
		8d0e4d	`+ case (size_t)-2:`
		8d0e4d	`+ state[i] = state_bak;`
		8d0e4d	`+ /* Fall through */`
		8d0e4d	`+ case 0:`
		8d0e4d	`+ mblength = 1;`
		8d0e4d	`+ break;`
		8d0e4d	`+`
		8d0e4d	`+ default:`
		8d0e4d	`+ if (ignore_case)`
		8d0e4d	`+ {`
		8d0e4d	`+ uwc = towupper (wc);`
		8d0e4d	`+`
		8d0e4d	`+ if (uwc != wc)`
		8d0e4d	`+ {`
		8d0e4d	`+ mbstate_t state_wc;`
		8d0e4d	`+ size_t mblen;`
		8d0e4d	`+`
		8d0e4d	`+ memset (&state_wc, '\0', sizeof(mbstate_t));`
		8d0e4d	`+ mblen = wcrtomb (copy[i] + j, uwc, &state_wc);`
		8d0e4d	`+ assert (mblen != (size_t)-1);`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+ memcpy (copy[i] + j, str[i] + j, mblength);`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+ memcpy (copy[i] + j, str[i] + j, mblength);`
		8d0e4d	`+ }`
		8d0e4d	`+ j += mblength;`
		8d0e4d	`+ }`
		8d0e4d	`+ copy[i][j] = '\0';`
		8d0e4d	`+ len[i] = j;`
		8d0e4d	`+ }`
		8d0e4d	`+ int rc = xmemcoll (copy[0], len[0], copy[1], len[1]);`
		8d0e4d	`+ free (copy[0]);`
		8d0e4d	`+ free (copy[1]);`
		8d0e4d	`+ return rc;`
		8d0e4d	`+`
		8d0e4d	`+}`
		8d0e4d	`+#endif`
		8d0e4d	`+`
		8d0e4d	`/* Output the line in linebuffer LINE to standard output`
		8d0e4d	`provided that the switches say it should be output.`
		8d0e4d	`MATCH is true if the line matches the previous line.`
		8d0e4d	`@@ -367,19 +562,38 @@ check_file (const char infile, const char outfile, char delimiter)`
		8d0e4d	`char *prevfield IF_LINT ( = NULL);`
		8d0e4d	`size_t prevlen IF_LINT ( = 0);`
		8d0e4d	`bool first_group_printed = false;`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ mbstate_t prevstate;`
		8d0e4d	`+`
		8d0e4d	`+ memset (&prevstate, '\0', sizeof (mbstate_t));`
		8d0e4d	`+#endif`
		8d0e4d
		8d0e4d	`while (!feof (stdin))`
		8d0e4d	`{`
		8d0e4d	`char *thisfield;`
		8d0e4d	`size_t thislen;`
		8d0e4d	`bool new_group;`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ mbstate_t thisstate;`
		8d0e4d	`+#endif`
		8d0e4d
		8d0e4d	`if (readlinebuffer_delim (thisline, stdin, delimiter) == 0)`
		8d0e4d	`break;`
		8d0e4d
		8d0e4d	`thisfield = find_field (thisline);`
		8d0e4d	`thislen = thisline->length - 1 - (thisfield - thisline->buffer);`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ if (MB_CUR_MAX > 1)`
		8d0e4d	`+ {`
		8d0e4d	`+ thisstate = thisline->state;`
		8d0e4d
		8d0e4d	`+ new_group = (prevline->length == 0`
		8d0e4d	`+ \|\| different_multi (thisfield, prevfield,`
		8d0e4d	`+ thislen, prevlen,`
		8d0e4d	`+ thisstate, prevstate));`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+#endif`
		8d0e4d	`new_group = (prevline->length == 0`
		8d0e4d	`\|\| different (thisfield, prevfield, thislen, prevlen));`
		8d0e4d
		8d0e4d	`@@ -397,6 +611,10 @@ check_file (const char infile, const char outfile, char delimiter)`
		8d0e4d	`SWAP_LINES (prevline, thisline);`
		8d0e4d	`prevfield = thisfield;`
		8d0e4d	`prevlen = thislen;`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ if (MB_CUR_MAX > 1)`
		8d0e4d	`+ prevstate = thisstate;`
		8d0e4d	`+#endif`
		8d0e4d	`first_group_printed = true;`
		8d0e4d	`}`
		8d0e4d	`}`
		8d0e4d	`@@ -409,17 +627,26 @@ check_file (const char infile, const char outfile, char delimiter)`
		8d0e4d	`size_t prevlen;`
		8d0e4d	`uintmax_t match_count = 0;`
		8d0e4d	`bool first_delimiter = true;`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ mbstate_t prevstate;`
		8d0e4d	`+#endif`
		8d0e4d
		8d0e4d	`if (readlinebuffer_delim (prevline, stdin, delimiter) == 0)`
		8d0e4d	`goto closefiles;`
		8d0e4d	`prevfield = find_field (prevline);`
		8d0e4d	`prevlen = prevline->length - 1 - (prevfield - prevline->buffer);`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ prevstate = prevline->state;`
		8d0e4d	`+#endif`
		8d0e4d
		8d0e4d	`while (!feof (stdin))`
		8d0e4d	`{`
		8d0e4d	`bool match;`
		8d0e4d	`char *thisfield;`
		8d0e4d	`size_t thislen;`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ mbstate_t thisstate = thisline->state;`
		8d0e4d	`+#endif`
		8d0e4d	`if (readlinebuffer_delim (thisline, stdin, delimiter) == 0)`
		8d0e4d	`{`
		8d0e4d	`if (ferror (stdin))`
		8d0e4d	`@@ -428,6 +655,14 @@ check_file (const char infile, const char outfile, char delimiter)`
		8d0e4d	`}`
		8d0e4d	`thisfield = find_field (thisline);`
		8d0e4d	`thislen = thisline->length - 1 - (thisfield - thisline->buffer);`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ if (MB_CUR_MAX > 1)`
		8d0e4d	`+ {`
		8d0e4d	`+ match = !different_multi (thisfield, prevfield,`
		8d0e4d	`+ thislen, prevlen, thisstate, prevstate);`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+#endif`
		8d0e4d	`match = !different (thisfield, prevfield, thislen, prevlen);`
		8d0e4d	`match_count += match;`
		8d0e4d
		8d0e4d	`@@ -460,6 +695,9 @@ check_file (const char infile, const char outfile, char delimiter)`
		8d0e4d	`SWAP_LINES (prevline, thisline);`
		8d0e4d	`prevfield = thisfield;`
		8d0e4d	`prevlen = thislen;`
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ prevstate = thisstate;`
		8d0e4d	`+#endif`
		8d0e4d	`if (!match)`
		8d0e4d	`match_count = 0;`
		8d0e4d	`}`
		8d0e4d	`@@ -506,6 +744,19 @@ main (int argc, char **argv)`
		8d0e4d
		8d0e4d	`atexit (close_stdout);`
		8d0e4d
		8d0e4d	`+#if HAVE_MBRTOWC`
		8d0e4d	`+ if (MB_CUR_MAX > 1)`
		8d0e4d	`+ {`
		8d0e4d	`+ find_field = find_field_multi;`
		8d0e4d	`+ }`
		8d0e4d	`+ else`
		8d0e4d	`+#endif`
		8d0e4d	`+ {`
		8d0e4d	`+ find_field = find_field_uni;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+`
		8d0e4d	`+`
		8d0e4d	`skip_chars = 0;`
		8d0e4d	`skip_fields = 0;`
		8d0e4d	`check_chars = SIZE_MAX;`
		8d0e4d	`diff --git a/tests/i18n/sort.sh b/tests/i18n/sort.sh`
		8d0e4d	`new file mode 100755`
		8d0e4d	`index 0000000..26c95de`
		8d0e4d	`--- /dev/null`
		8d0e4d	`+++ b/tests/i18n/sort.sh`
		8d0e4d	`@@ -0,0 +1,29 @@`
		8d0e4d	`+#!/bin/sh`
		8d0e4d	`+# Verify sort's multi-byte support.`
		8d0e4d	`+`
		8d0e4d	`+. "${srcdir=.}/tests/init.sh"; path_prepend_ ./src`
		8d0e4d	`+print_ver_ sort`
		8d0e4d	`+`
		8d0e4d	`+export LC_ALL=en_US.UTF-8`
		8d0e4d	`+locale -k LC_CTYPE \| grep -q "charmap.*UTF-8" \`
		8d0e4d	`+ \|\| skip_ "No UTF-8 locale available"`
		8d0e4d	`+`
		8d0e4d	`+# Enable heap consistency checkng on older systems`
		8d0e4d	`+export MALLOC_CHECK_=2`
		8d0e4d	`+`
		8d0e4d	`+`
		8d0e4d	`+# check buffer overflow issue due to`
		8d0e4d	`+# expanding multi-byte representation due to case conversion`
		8d0e4d	`+# https://bugzilla.suse.com/show_bug.cgi?id=928749`
		8d0e4d	`+cat <<EOF > exp`
		8d0e4d	`+.`
		8d0e4d	`+ɑ`
		8d0e4d	`+EOF`
		8d0e4d	`+cat <<EOF \| sort -f > out \|\| fail=1`
		8d0e4d	`+.`
		8d0e4d	`+ɑ`
		8d0e4d	`+EOF`
		8d0e4d	`+compare exp out \|\| { fail=1; cat out; }`
		8d0e4d	`+`
		8d0e4d	`+`
		8d0e4d	`+Exit $fail`
		8d0e4d	`diff --git a/tests/local.mk b/tests/local.mk`
		8d0e4d	`index 568944e..192f776 100644`
		8d0e4d	`--- a/tests/local.mk`
		8d0e4d	`+++ b/tests/local.mk`
		8d0e4d	`@@ -362,6 +362,8 @@ all_tests = \`
		8d0e4d	`tests/misc/sort-discrim.sh \`
		8d0e4d	`tests/misc/sort-files0-from.pl \`
		8d0e4d	`tests/misc/sort-float.sh \`
		8d0e4d	`+ tests/misc/sort-mb-tests.sh \`
		8d0e4d	`+ tests/i18n/sort.sh \`
		8d0e4d	`tests/misc/sort-h-thousands-sep.sh \`
		8d0e4d	`tests/misc/sort-merge.pl \`
		8d0e4d	`tests/misc/sort-merge-fdlimit.sh \`
		8d0e4d	`diff --git a/tests/misc/expand.pl b/tests/misc/expand.pl`
		8d0e4d	`index 8a9cad1..9293e39 100755`
		8d0e4d	`--- a/tests/misc/expand.pl`
		8d0e4d	`+++ b/tests/misc/expand.pl`
		8d0e4d	`@@ -27,6 +27,15 @@ my $prog = 'expand';`
		8d0e4d	`# Turn off localization of executable's output.`
		8d0e4d	`@ENV{qw(LANGUAGE LANG LC_ALL)} = ('C') x 3;`
		8d0e4d
		8d0e4d	`+#comment out next line to disable multibyte tests`
		8d0e4d	`+my $mb_locale = $ENV{LOCALE_FR_UTF8};`
		8d0e4d	`+! defined $mb_locale \|\| $mb_locale eq 'none'`
		8d0e4d	`+ and $mb_locale = 'C';`
		8d0e4d	`+`
		8d0e4d	`+my $prog = 'expand';`
		8d0e4d	+my $try = "Try \`$prog --help' for more information.\n";
		8d0e4d	`+my $inval = "$prog: invalid byte, character or field list\n$try";`
		8d0e4d	`+`
		8d0e4d	`my @Tests =`
		8d0e4d	`(`
		8d0e4d	`['t1', '--tabs=3', {IN=>"a\tb"}, {OUT=>"a b"}],`
		8d0e4d	`@@ -168,6 +177,8 @@ my @Tests =`
		8d0e4d
		8d0e4d
		8d0e4d	`# Test errors`
		8d0e4d	`+ # FIXME: The following tests contain ‘quoting’ specific to LC_MESSAGES`
		8d0e4d	`+ # So we force LC_MESSAGES=C to make them pass.`
		8d0e4d	`['e1', '--tabs="a"', {IN=>''}, {OUT=>''}, {EXIT=>1},`
		8d0e4d	`{ERR => "$prog: tab size contains invalid character(s): 'a'\n"}],`
		8d0e4d	`['e2', "-t $UINTMAX_OFLOW", {IN=>''}, {OUT=>''}, {EXIT=>1},`
		8d0e4d	`@@ -184,6 +195,37 @@ my @Tests =`
		8d0e4d	`{ERR => "$prog: '/' specifier not at start of number: '/'\n"}],`
		8d0e4d	`);`
		8d0e4d
		8d0e4d	`+if ($mb_locale ne 'C')`
		8d0e4d	`+ {`
		8d0e4d	`+ # Duplicate each test vector, appending "-mb" to the test name and`
		8d0e4d	`+ # inserting {ENV => "LC_ALL=$mb_locale"} in the copy, so that we`
		8d0e4d	`+ # provide coverage for the distro-added multi-byte code paths.`
		8d0e4d	`+ my @new;`
		8d0e4d	`+ foreach my $t (@Tests)`
		8d0e4d	`+ {`
		8d0e4d	`+ my @new_t = @$t;`
		8d0e4d	`+ my $test_name = shift @new_t;`
		8d0e4d	`+`
		8d0e4d	`+ # Depending on whether expand is multi-byte-patched,`
		8d0e4d	`+ # it emits different diagnostics:`
		8d0e4d	`+ # non-MB: invalid byte or field list`
		8d0e4d	`+ # MB: invalid byte, character or field list`
		8d0e4d	`+ # Adjust the expected error output accordingly.`
		8d0e4d	`+ if (grep {ref $_ eq 'HASH' && exists $_->{ERR} && $_->{ERR} eq $inval}`
		8d0e4d	`+ (@new_t))`
		8d0e4d	`+ {`
		8d0e4d	`+ my $sub = {ERR_SUBST => 's/, character//'};`
		8d0e4d	`+ push @new_t, $sub;`
		8d0e4d	`+ push @$t, $sub;`
		8d0e4d	`+ }`
		8d0e4d	`+ push @new, ["$test_name-mb", @new_t, {ENV => "LANG=$mb_locale LC_MESSAGES=C"}];`
		8d0e4d	`+ }`
		8d0e4d	`+ push @Tests, @new;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+`
		8d0e4d	`+@Tests = triple_test \@Tests;`
		8d0e4d	`+`
		8d0e4d	`my $save_temps = $ENV{DEBUG};`
		8d0e4d	`my $verbose = $ENV{VERBOSE};`
		8d0e4d
		8d0e4d	`diff --git a/tests/misc/fold.pl b/tests/misc/fold.pl`
		8d0e4d	`index 7b192b4..76f073f 100755`
		8d0e4d	`--- a/tests/misc/fold.pl`
		8d0e4d	`+++ b/tests/misc/fold.pl`
		8d0e4d	`@@ -20,9 +20,18 @@ use strict;`
		8d0e4d
		8d0e4d	`(my $program_name = $0) =~ s\|.*/\|\|;`
		8d0e4d
		8d0e4d	`+my $prog = 'fold';`
		8d0e4d	+my $try = "Try \`$prog --help' for more information.\n";
		8d0e4d	`+my $inval = "$prog: invalid byte, character or field list\n$try";`
		8d0e4d	`+`
		8d0e4d	`# Turn off localization of executable's output.`
		8d0e4d	`@ENV{qw(LANGUAGE LANG LC_ALL)} = ('C') x 3;`
		8d0e4d
		8d0e4d	`+# uncommented to enable multibyte paths`
		8d0e4d	`+my $mb_locale = $ENV{LOCALE_FR_UTF8};`
		8d0e4d	`+! defined $mb_locale \|\| $mb_locale eq 'none'`
		8d0e4d	`+ and $mb_locale = 'C';`
		8d0e4d	`+`
		8d0e4d	`my @Tests =`
		8d0e4d	`(`
		8d0e4d	`['s1', '-w2 -s', {IN=>"a\t"}, {OUT=>"a\n\t"}],`
		8d0e4d	`@@ -31,9 +40,48 @@ my @Tests =`
		8d0e4d	`['s4', '-w4 -s', {IN=>"abc ef\n"}, {OUT=>"abc \nef\n"}],`
		8d0e4d	`);`
		8d0e4d
		8d0e4d	`+# Add _POSIX2_VERSION=199209 to the environment of each test`
		8d0e4d	`+# that uses an old-style option like +1.`
		8d0e4d	`+if ($mb_locale ne 'C')`
		8d0e4d	`+ {`
		8d0e4d	`+ # Duplicate each test vector, appending "-mb" to the test name and`
		8d0e4d	`+ # inserting {ENV => "LC_ALL=$mb_locale"} in the copy, so that we`
		8d0e4d	`+ # provide coverage for the distro-added multi-byte code paths.`
		8d0e4d	`+ my @new;`
		8d0e4d	`+ foreach my $t (@Tests)`
		8d0e4d	`+ {`
		8d0e4d	`+ my @new_t = @$t;`
		8d0e4d	`+ my $test_name = shift @new_t;`
		8d0e4d	`+`
		8d0e4d	`+ # Depending on whether fold is multi-byte-patched,`
		8d0e4d	`+ # it emits different diagnostics:`
		8d0e4d	`+ # non-MB: invalid byte or field list`
		8d0e4d	`+ # MB: invalid byte, character or field list`
		8d0e4d	`+ # Adjust the expected error output accordingly.`
		8d0e4d	`+ if (grep {ref $_ eq 'HASH' && exists $_->{ERR} && $_->{ERR} eq $inval}`
		8d0e4d	`+ (@new_t))`
		8d0e4d	`+ {`
		8d0e4d	`+ my $sub = {ERR_SUBST => 's/, character//'};`
		8d0e4d	`+ push @new_t, $sub;`
		8d0e4d	`+ push @$t, $sub;`
		8d0e4d	`+ }`
		8d0e4d	`+ push @new, ["$test_name-mb", @new_t, {ENV => "LC_ALL=$mb_locale"}];`
		8d0e4d	`+ }`
		8d0e4d	`+ push @Tests, @new;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+@Tests = triple_test \@Tests;`
		8d0e4d	`+`
		8d0e4d	`+# Remember that triple_test creates from each test with exactly one "IN"`
		8d0e4d	`+# file two more tests (.p and .r suffix on name) corresponding to reading`
		8d0e4d	`+# input from a file and from a pipe. The pipe-reading test would fail`
		8d0e4d	`+# due to a race condition about 1 in 20 times.`
		8d0e4d	`+# Remove the IN_PIPE version of the "output-is-input" test above.`
		8d0e4d	`+# The others aren't susceptible because they have three inputs each.`
		8d0e4d	`+@Tests = grep {$_->[0] ne 'output-is-input.p'} @Tests;`
		8d0e4d	`+`
		8d0e4d	`my $save_temps = $ENV{DEBUG};`
		8d0e4d	`my $verbose = $ENV{VERBOSE};`
		8d0e4d
		8d0e4d	`-my $prog = 'fold';`
		8d0e4d	`my $fail = run_tests ($program_name, $prog, \@Tests, $save_temps, $verbose);`
		8d0e4d	`exit $fail;`
		8d0e4d	`diff --git a/tests/misc/join.pl b/tests/misc/join.pl`
		8d0e4d	`index 4d399d8..07f2823 100755`
		8d0e4d	`--- a/tests/misc/join.pl`
		8d0e4d	`+++ b/tests/misc/join.pl`
		8d0e4d	`@@ -25,6 +25,15 @@ my $limits = getlimits ();`
		8d0e4d
		8d0e4d	`my $prog = 'join';`
		8d0e4d
		8d0e4d	+my $try = "Try \`$prog --help' for more information.\n";
		8d0e4d	`+my $inval = "$prog: invalid byte, character or field list\n$try";`
		8d0e4d	`+`
		8d0e4d	`+my $mb_locale;`
		8d0e4d	`+#Comment out next line to disable multibyte tests`
		8d0e4d	`+$mb_locale = $ENV{LOCALE_FR_UTF8};`
		8d0e4d	`+! defined $mb_locale \|\| $mb_locale eq 'none'`
		8d0e4d	`+ and $mb_locale = 'C';`
		8d0e4d	`+`
		8d0e4d	`my $delim = chr 0247;`
		8d0e4d	`sub t_subst ($)`
		8d0e4d	`{`
		8d0e4d	`@@ -329,8 +338,49 @@ foreach my $t (@tv)`
		8d0e4d	`push @Tests, $new_ent;`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`+# Add _POSIX2_VERSION=199209 to the environment of each test`
		8d0e4d	`+# that uses an old-style option like +1.`
		8d0e4d	`+if ($mb_locale ne 'C')`
		8d0e4d	`+ {`
		8d0e4d	`+ # Duplicate each test vector, appending "-mb" to the test name and`
		8d0e4d	`+ # inserting {ENV => "LC_ALL=$mb_locale"} in the copy, so that we`
		8d0e4d	`+ # provide coverage for the distro-added multi-byte code paths.`
		8d0e4d	`+ my @new;`
		8d0e4d	`+ foreach my $t (@Tests)`
		8d0e4d	`+ {`
		8d0e4d	`+ my @new_t = @$t;`
		8d0e4d	`+ my $test_name = shift @new_t;`
		8d0e4d	`+`
		8d0e4d	`+ # Depending on whether join is multi-byte-patched,`
		8d0e4d	`+ # it emits different diagnostics:`
		8d0e4d	`+ # non-MB: invalid byte or field list`
		8d0e4d	`+ # MB: invalid byte, character or field list`
		8d0e4d	`+ # Adjust the expected error output accordingly.`
		8d0e4d	`+ if (grep {ref $_ eq 'HASH' && exists $_->{ERR} && $_->{ERR} eq $inval}`
		8d0e4d	`+ (@new_t))`
		8d0e4d	`+ {`
		8d0e4d	`+ my $sub = {ERR_SUBST => 's/, character//'};`
		8d0e4d	`+ push @new_t, $sub;`
		8d0e4d	`+ push @$t, $sub;`
		8d0e4d	`+ }`
		8d0e4d	`+ #Adjust the output some error messages including test_name for mb`
		8d0e4d	`+ if (grep {ref $_ eq 'HASH' && exists $_->{ERR}}`
		8d0e4d	`+ (@new_t))`
		8d0e4d	`+ {`
		8d0e4d	`+ my $sub2 = {ERR_SUBST => "s/$test_name-mb/$test_name/"};`
		8d0e4d	`+ push @new_t, $sub2;`
		8d0e4d	`+ push @$t, $sub2;`
		8d0e4d	`+ }`
		8d0e4d	`+ push @new, ["$test_name-mb", @new_t, {ENV => "LC_ALL=$mb_locale"}];`
		8d0e4d	`+ }`
		8d0e4d	`+ push @Tests, @new;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`@Tests = triple_test \@Tests;`
		8d0e4d
		8d0e4d	`+#skip invalid-j-mb test, it is failing because of the format`
		8d0e4d	`+@Tests = grep {$_->[0] ne 'invalid-j-mb'} @Tests;`
		8d0e4d	`+`
		8d0e4d	`my $save_temps = $ENV{DEBUG};`
		8d0e4d	`my $verbose = $ENV{VERBOSE};`
		8d0e4d
		8d0e4d	`diff --git a/tests/misc/sort-mb-tests.sh b/tests/misc/sort-mb-tests.sh`
		8d0e4d	`new file mode 100755`
		8d0e4d	`index 0000000..11836ba`
		8d0e4d	`--- /dev/null`
		8d0e4d	`+++ b/tests/misc/sort-mb-tests.sh`
		8d0e4d	`@@ -0,0 +1,45 @@`
		8d0e4d	`+#!/bin/sh`
		8d0e4d	`+# Verify sort's multi-byte support.`
		8d0e4d	`+`
		8d0e4d	`+. "${srcdir=.}/tests/init.sh"; path_prepend_ ./src`
		8d0e4d	`+print_ver_ sort`
		8d0e4d	`+`
		8d0e4d	`+export LC_ALL=en_US.UTF-8`
		8d0e4d	`+locale -k LC_CTYPE \| grep -q "charmap.*UTF-8" \`
		8d0e4d	`+ \|\| skip_ "No UTF-8 locale available"`
		8d0e4d	`+`
		8d0e4d	`+`
		8d0e4d	`+cat <<EOF > exp`
		8d0e4d	`+Banana＠5`
		8d0e4d	`+Apple＠10`
		8d0e4d	`+Citrus＠20`
		8d0e4d	`+Cherry＠30`
		8d0e4d	`+EOF`
		8d0e4d	`+`
		8d0e4d	`+cat <<EOF \| sort -t ＠ -k2 -n > out \|\| fail=1`
		8d0e4d	`+Apple＠10`
		8d0e4d	`+Banana＠5`
		8d0e4d	`+Citrus＠20`
		8d0e4d	`+Cherry＠30`
		8d0e4d	`+EOF`
		8d0e4d	`+`
		8d0e4d	`+compare exp out \|\| { fail=1; cat out; }`
		8d0e4d	`+`
		8d0e4d	`+`
		8d0e4d	`+cat <<EOF > exp`
		8d0e4d	`+Citrus＠ＡＡ20＠＠5`
		8d0e4d	`+Cherry＠ＡＡ30＠＠10`
		8d0e4d	`+Apple＠ＡＡ10＠＠20`
		8d0e4d	`+Banana＠ＡＡ5＠＠30`
		8d0e4d	`+EOF`
		8d0e4d	`+`
		8d0e4d	`+cat <<EOF \| sort -t ＠ -k4 -n > out \|\| fail=1`
		8d0e4d	`+Apple＠ＡＡ10＠＠20`
		8d0e4d	`+Banana＠ＡＡ5＠＠30`
		8d0e4d	`+Citrus＠ＡＡ20＠＠5`
		8d0e4d	`+Cherry＠ＡＡ30＠＠10`
		8d0e4d	`+EOF`
		8d0e4d	`+`
		8d0e4d	`+compare exp out \|\| { fail=1; cat out; }`
		8d0e4d	`+`
		8d0e4d	`+Exit $fail`
		8d0e4d	`diff --git a/tests/misc/sort-merge.pl b/tests/misc/sort-merge.pl`
		8d0e4d	`index 23f6ed2..402a987 100755`
		8d0e4d	`--- a/tests/misc/sort-merge.pl`
		8d0e4d	`+++ b/tests/misc/sort-merge.pl`
		8d0e4d	`@@ -26,6 +26,15 @@ my $prog = 'sort';`
		8d0e4d	`# Turn off localization of executable's output.`
		8d0e4d	`@ENV{qw(LANGUAGE LANG LC_ALL)} = ('C') x 3;`
		8d0e4d
		8d0e4d	`+my $mb_locale;`
		8d0e4d	`+# uncommented according to upstream commit enabling multibyte paths`
		8d0e4d	`+$mb_locale = $ENV{LOCALE_FR_UTF8};`
		8d0e4d	`+! defined $mb_locale \|\| $mb_locale eq 'none'`
		8d0e4d	`+ and $mb_locale = 'C';`
		8d0e4d	`+`
		8d0e4d	+my $try = "Try \`$prog --help' for more information.\n";
		8d0e4d	`+my $inval = "$prog: invalid byte, character or field list\n$try";`
		8d0e4d	`+`
		8d0e4d	`# three empty files and one that says 'foo'`
		8d0e4d	`my @inputs = (+(map{{IN=> {"empty$_"=> ''}}}1..3), {IN=> {foo=> "foo\n"}});`
		8d0e4d
		8d0e4d	`@@ -77,6 +86,39 @@ my @Tests =`
		8d0e4d	`{OUT=>$big_input}],`
		8d0e4d	`);`
		8d0e4d
		8d0e4d	`+# Add _POSIX2_VERSION=199209 to the environment of each test`
		8d0e4d	`+# that uses an old-style option like +1.`
		8d0e4d	`+if ($mb_locale ne 'C')`
		8d0e4d	`+ {`
		8d0e4d	`+ # Duplicate each test vector, appending "-mb" to the test name and`
		8d0e4d	`+ # inserting {ENV => "LC_ALL=$mb_locale"} in the copy, so that we`
		8d0e4d	`+ # provide coverage for the distro-added multi-byte code paths.`
		8d0e4d	`+ my @new;`
		8d0e4d	`+ foreach my $t (@Tests)`
		8d0e4d	`+ {`
		8d0e4d	`+ my @new_t = @$t;`
		8d0e4d	`+ my $test_name = shift @new_t;`
		8d0e4d	`+`
		8d0e4d	`+ # Depending on whether sort is multi-byte-patched,`
		8d0e4d	`+ # it emits different diagnostics:`
		8d0e4d	`+ # non-MB: invalid byte or field list`
		8d0e4d	`+ # MB: invalid byte, character or field list`
		8d0e4d	`+ # Adjust the expected error output accordingly.`
		8d0e4d	`+ if (grep {ref $_ eq 'HASH' && exists $_->{ERR} && $_->{ERR} eq $inval}`
		8d0e4d	`+ (@new_t))`
		8d0e4d	`+ {`
		8d0e4d	`+ my $sub = {ERR_SUBST => 's/, character//'};`
		8d0e4d	`+ push @new_t, $sub;`
		8d0e4d	`+ push @$t, $sub;`
		8d0e4d	`+ }`
		8d0e4d	`+ next if ($test_name =~ "nmerge-.");`
		8d0e4d	`+ push @new, ["$test_name-mb", @new_t, {ENV => "LC_ALL=$mb_locale"}];`
		8d0e4d	`+ }`
		8d0e4d	`+ push @Tests, @new;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+@Tests = triple_test \@Tests;`
		8d0e4d	`+`
		8d0e4d	`my $save_temps = $ENV{DEBUG};`
		8d0e4d	`my $verbose = $ENV{VERBOSE};`
		8d0e4d
		8d0e4d	`diff --git a/tests/misc/sort.pl b/tests/misc/sort.pl`
		8d0e4d	`index c3e7f8e..6ecd3ff 100755`
		8d0e4d	`--- a/tests/misc/sort.pl`
		8d0e4d	`+++ b/tests/misc/sort.pl`
		8d0e4d	`@@ -24,10 +24,15 @@ my $prog = 'sort';`
		8d0e4d	`# Turn off localization of executable's output.`
		8d0e4d	`@ENV{qw(LANGUAGE LANG LC_ALL)} = ('C') x 3;`
		8d0e4d
		8d0e4d	`-my $mb_locale = $ENV{LOCALE_FR_UTF8};`
		8d0e4d	`+my $mb_locale;`
		8d0e4d	`+#Comment out next line to disable multibyte tests`
		8d0e4d	`+$mb_locale = $ENV{LOCALE_FR_UTF8};`
		8d0e4d	`! defined $mb_locale \|\| $mb_locale eq 'none'`
		8d0e4d	`and $mb_locale = 'C';`
		8d0e4d
		8d0e4d	+my $try = "Try \`$prog --help' for more information.\n";
		8d0e4d	`+my $inval = "$prog: invalid byte, character or field list\n$try";`
		8d0e4d	`+`
		8d0e4d	`# Since each test is run with a file name and with redirected stdin,`
		8d0e4d	`# the name in the diagnostic is either the file name or "-".`
		8d0e4d	`# Normalize each diagnostic to use '-'.`
		8d0e4d	`@@ -423,6 +428,38 @@ foreach my $t (@Tests)`
		8d0e4d	`}`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`+if ($mb_locale ne 'C')`
		8d0e4d	`+ {`
		8d0e4d	`+ # Duplicate each test vector, appending "-mb" to the test name and`
		8d0e4d	`+ # inserting {ENV => "LC_ALL=$mb_locale"} in the copy, so that we`
		8d0e4d	`+ # provide coverage for the distro-added multi-byte code paths.`
		8d0e4d	`+ my @new;`
		8d0e4d	`+ foreach my $t (@Tests)`
		8d0e4d	`+ {`
		8d0e4d	`+ my @new_t = @$t;`
		8d0e4d	`+ my $test_name = shift @new_t;`
		8d0e4d	`+`
		8d0e4d	`+ # Depending on whether sort is multi-byte-patched,`
		8d0e4d	`+ # it emits different diagnostics:`
		8d0e4d	`+ # non-MB: invalid byte or field list`
		8d0e4d	`+ # MB: invalid byte, character or field list`
		8d0e4d	`+ # Adjust the expected error output accordingly.`
		8d0e4d	`+ if (grep {ref $_ eq 'HASH' && exists $_->{ERR} && $_->{ERR} eq $inval}`
		8d0e4d	`+ (@new_t))`
		8d0e4d	`+ {`
		8d0e4d	`+ my $sub = {ERR_SUBST => 's/, character//'};`
		8d0e4d	`+ push @new_t, $sub;`
		8d0e4d	`+ push @$t, $sub;`
		8d0e4d	`+ }`
		8d0e4d	`+ #disable several failing tests until investigation, disable all tests with envvars set`
		8d0e4d	`+ next if (grep {ref $_ eq 'HASH' && exists $_->{ENV}} (@new_t));`
		8d0e4d	`+ 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");`
		8d0e4d	`+ next if ($test_name =~ "11[ab]"); # avoid FP: expected result differs to MB result due to collation rules.`
		8d0e4d	`+ push @new, ["$test_name-mb", @new_t, {ENV => "LC_ALL=$mb_locale"}];`
		8d0e4d	`+ }`
		8d0e4d	`+ push @Tests, @new;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`@Tests = triple_test \@Tests;`
		8d0e4d
		8d0e4d	`# Remember that triple_test creates from each test with exactly one "IN"`
		8d0e4d	`@@ -432,6 +469,7 @@ foreach my $t (@Tests)`
		8d0e4d	`# Remove the IN_PIPE version of the "output-is-input" test above.`
		8d0e4d	`# The others aren't susceptible because they have three inputs each.`
		8d0e4d	`@Tests = grep {$_->[0] ne 'output-is-input.p'} @Tests;`
		8d0e4d	`+@Tests = grep {$_->[0] ne 'output-is-input-mb.p'} @Tests;`
		8d0e4d
		8d0e4d	`my $save_temps = $ENV{DEBUG};`
		8d0e4d	`my $verbose = $ENV{VERBOSE};`
		8d0e4d	`diff --git a/tests/misc/unexpand.pl b/tests/misc/unexpand.pl`
		8d0e4d	`index 6ba6d40..de86723 100755`
		8d0e4d	`--- a/tests/misc/unexpand.pl`
		8d0e4d	`+++ b/tests/misc/unexpand.pl`
		8d0e4d	`@@ -27,6 +27,14 @@ my $limits = getlimits ();`
		8d0e4d
		8d0e4d	`my $prog = 'unexpand';`
		8d0e4d
		8d0e4d	`+# comment out next line to disable multibyte tests`
		8d0e4d	`+my $mb_locale = $ENV{LOCALE_FR_UTF8};`
		8d0e4d	`+! defined $mb_locale \|\| $mb_locale eq 'none'`
		8d0e4d	`+ and $mb_locale = 'C';`
		8d0e4d	`+`
		8d0e4d	+my $try = "Try \`$prog --help' for more information.\n";
		8d0e4d	`+my $inval = "$prog: invalid byte, character or field list\n$try";`
		8d0e4d	`+`
		8d0e4d	`my @Tests =`
		8d0e4d	`(`
		8d0e4d	`['a1', {IN=> ' 'x 1 ."y\n"}, {OUT=> ' 'x 1 ."y\n"}],`
		8d0e4d	`@@ -128,6 +136,37 @@ my @Tests =`
		8d0e4d	`['ts2', '-t5,8', {IN=>"x\t \t y\n"}, {OUT=>"x\t\t y\n"}],`
		8d0e4d	`);`
		8d0e4d
		8d0e4d	`+if ($mb_locale ne 'C')`
		8d0e4d	`+ {`
		8d0e4d	`+ # Duplicate each test vector, appending "-mb" to the test name and`
		8d0e4d	`+ # inserting {ENV => "LC_ALL=$mb_locale"} in the copy, so that we`
		8d0e4d	`+ # provide coverage for the distro-added multi-byte code paths.`
		8d0e4d	`+ my @new;`
		8d0e4d	`+ foreach my $t (@Tests)`
		8d0e4d	`+ {`
		8d0e4d	`+ my @new_t = @$t;`
		8d0e4d	`+ my $test_name = shift @new_t;`
		8d0e4d	`+`
		8d0e4d	`+ # Depending on whether unexpand is multi-byte-patched,`
		8d0e4d	`+ # it emits different diagnostics:`
		8d0e4d	`+ # non-MB: invalid byte or field list`
		8d0e4d	`+ # MB: invalid byte, character or field list`
		8d0e4d	`+ # Adjust the expected error output accordingly.`
		8d0e4d	`+ if (grep {ref $_ eq 'HASH' && exists $_->{ERR} && $_->{ERR} eq $inval}`
		8d0e4d	`+ (@new_t))`
		8d0e4d	`+ {`
		8d0e4d	`+ my $sub = {ERR_SUBST => 's/, character//'};`
		8d0e4d	`+ push @new_t, $sub;`
		8d0e4d	`+ push @$t, $sub;`
		8d0e4d	`+ }`
		8d0e4d	`+ next if ($test_name =~ 'b-1');`
		8d0e4d	`+ push @new, ["$test_name-mb", @new_t, {ENV => "LC_ALL=$mb_locale"}];`
		8d0e4d	`+ }`
		8d0e4d	`+ push @Tests, @new;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+@Tests = triple_test \@Tests;`
		8d0e4d	`+`
		8d0e4d	`my $save_temps = $ENV{DEBUG};`
		8d0e4d	`my $verbose = $ENV{VERBOSE};`
		8d0e4d
		8d0e4d	`diff --git a/tests/misc/uniq.pl b/tests/misc/uniq.pl`
		8d0e4d	`index f028036..8eaf59a 100755`
		8d0e4d	`--- a/tests/misc/uniq.pl`
		8d0e4d	`+++ b/tests/misc/uniq.pl`
		8d0e4d	`@@ -23,9 +23,17 @@ my $limits = getlimits ();`
		8d0e4d	`my $prog = 'uniq';`
		8d0e4d	`my $try = "Try '$prog --help' for more information.\n";`
		8d0e4d
		8d0e4d	`+my $inval = "$prog: invalid byte, character or field list\n$try";`
		8d0e4d	`+`
		8d0e4d	`# Turn off localization of executable's output.`
		8d0e4d	`@ENV{qw(LANGUAGE LANG LC_ALL)} = ('C') x 3;`
		8d0e4d
		8d0e4d	`+my $mb_locale;`
		8d0e4d	`+#Comment out next line to disable multibyte tests`
		8d0e4d	`+$mb_locale = $ENV{LOCALE_FR_UTF8};`
		8d0e4d	`+! defined $mb_locale \|\| $mb_locale eq 'none'`
		8d0e4d	`+ and $mb_locale = 'C';`
		8d0e4d	`+`
		8d0e4d	`# When possible, create a "-z"-testing variant of each test.`
		8d0e4d	`sub add_z_variants($)`
		8d0e4d	`{`
		8d0e4d	`@@ -262,6 +270,53 @@ foreach my $t (@Tests)`
		8d0e4d	`and push @$t, {ENV=>'_POSIX2_VERSION=199209'};`
		8d0e4d	`}`
		8d0e4d
		8d0e4d	`+if ($mb_locale ne 'C')`
		8d0e4d	`+ {`
		8d0e4d	`+ # Duplicate each test vector, appending "-mb" to the test name and`
		8d0e4d	`+ # inserting {ENV => "LC_ALL=$mb_locale"} in the copy, so that we`
		8d0e4d	`+ # provide coverage for the distro-added multi-byte code paths.`
		8d0e4d	`+ my @new;`
		8d0e4d	`+ foreach my $t (@Tests)`
		8d0e4d	`+ {`
		8d0e4d	`+ my @new_t = @$t;`
		8d0e4d	`+ my $test_name = shift @new_t;`
		8d0e4d	`+`
		8d0e4d	`+ # Depending on whether uniq is multi-byte-patched,`
		8d0e4d	`+ # it emits different diagnostics:`
		8d0e4d	`+ # non-MB: invalid byte or field list`
		8d0e4d	`+ # MB: invalid byte, character or field list`
		8d0e4d	`+ # Adjust the expected error output accordingly.`
		8d0e4d	`+ if (grep {ref $_ eq 'HASH' && exists $_->{ERR} && $_->{ERR} eq $inval}`
		8d0e4d	`+ (@new_t))`
		8d0e4d	`+ {`
		8d0e4d	`+ my $sub = {ERR_SUBST => 's/, character//'};`
		8d0e4d	`+ push @new_t, $sub;`
		8d0e4d	`+ push @$t, $sub;`
		8d0e4d	`+ }`
		8d0e4d	`+ # In test #145, replace the each ‘...’ by '...'.`
		8d0e4d	`+ if ($test_name =~ "145")`
		8d0e4d	`+ {`
		8d0e4d	`+ my $sub = { ERR_SUBST => "s/‘([^’]+)’/'\$1'/g"};`
		8d0e4d	`+ push @new_t, $sub;`
		8d0e4d	`+ push @$t, $sub;`
		8d0e4d	`+ }`
		8d0e4d	`+ next if ( $test_name =~ "schar"`
		8d0e4d	`+ or $test_name =~ "^obs-plus"`
		8d0e4d	`+ or $test_name =~ "119");`
		8d0e4d	`+ push @new, ["$test_name-mb", @new_t, {ENV => "LC_ALL=$mb_locale"}];`
		8d0e4d	`+ }`
		8d0e4d	`+ push @Tests, @new;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`+# Remember that triple_test creates from each test with exactly one "IN"`
		8d0e4d	`+# file two more tests (.p and .r suffix on name) corresponding to reading`
		8d0e4d	`+# input from a file and from a pipe. The pipe-reading test would fail`
		8d0e4d	`+# due to a race condition about 1 in 20 times.`
		8d0e4d	`+# Remove the IN_PIPE version of the "output-is-input" test above.`
		8d0e4d	`+# The others aren't susceptible because they have three inputs each.`
		8d0e4d	`+`
		8d0e4d	`+@Tests = grep {$_->[0] ne 'output-is-input.p'} @Tests;`
		8d0e4d	`+`
		8d0e4d	`@Tests = add_z_variants \@Tests;`
		8d0e4d	`@Tests = triple_test \@Tests;`
		8d0e4d
		8d0e4d	`diff --git a/tests/pr/pr-tests.pl b/tests/pr/pr-tests.pl`
		8d0e4d	`index ec3980a..136657d 100755`
		8d0e4d	`--- a/tests/pr/pr-tests.pl`
		8d0e4d	`+++ b/tests/pr/pr-tests.pl`
		8d0e4d	`@@ -24,6 +24,15 @@ use strict;`
		8d0e4d	`my $prog = 'pr';`
		8d0e4d	`my $normalize_strerror = "s/': .*/'/";`
		8d0e4d
		8d0e4d	`+my $mb_locale;`
		8d0e4d	`+#Uncomment the following line to enable multibyte tests`
		8d0e4d	`+$mb_locale = $ENV{LOCALE_FR_UTF8};`
		8d0e4d	`+! defined $mb_locale \|\| $mb_locale eq 'none'`
		8d0e4d	`+ and $mb_locale = 'C';`
		8d0e4d	`+`
		8d0e4d	+my $try = "Try \`$prog --help' for more information.\n";
		8d0e4d	`+my $inval = "$prog: invalid byte, character or field list\n$try";`
		8d0e4d	`+`
		8d0e4d	`my @tv = (`
		8d0e4d
		8d0e4d	`# -b option is no longer an official option. But it's still working to`
		8d0e4d	`@@ -474,8 +483,48 @@ push @Tests,`
		8d0e4d	`{IN=>{2=>"a\n"}},`
		8d0e4d	`{OUT=>"a\t\t\t\t \t\t\ta\n"} ];`
		8d0e4d
		8d0e4d	`+# Add _POSIX2_VERSION=199209 to the environment of each test`
		8d0e4d	`+# that uses an old-style option like +1.`
		8d0e4d	`+if ($mb_locale ne 'C')`
		8d0e4d	`+ {`
		8d0e4d	`+ # Duplicate each test vector, appending "-mb" to the test name and`
		8d0e4d	`+ # inserting {ENV => "LC_ALL=$mb_locale"} in the copy, so that we`
		8d0e4d	`+ # provide coverage for the distro-added multi-byte code paths.`
		8d0e4d	`+ my @new;`
		8d0e4d	`+ foreach my $t (@Tests)`
		8d0e4d	`+ {`
		8d0e4d	`+ my @new_t = @$t;`
		8d0e4d	`+ my $test_name = shift @new_t;`
		8d0e4d	`+`
		8d0e4d	`+ # Depending on whether pr is multi-byte-patched,`
		8d0e4d	`+ # it emits different diagnostics:`
		8d0e4d	`+ # non-MB: invalid byte or field list`
		8d0e4d	`+ # MB: invalid byte, character or field list`
		8d0e4d	`+ # Adjust the expected error output accordingly.`
		8d0e4d	`+ if (grep {ref $_ eq 'HASH' && exists $_->{ERR} && $_->{ERR} eq $inval}`
		8d0e4d	`+ (@new_t))`
		8d0e4d	`+ {`
		8d0e4d	`+ my $sub = {ERR_SUBST => 's/, character//'};`
		8d0e4d	`+ push @new_t, $sub;`
		8d0e4d	`+ push @$t, $sub;`
		8d0e4d	`+ }`
		8d0e4d	`+ #temporarily skip some failing tests`
		8d0e4d	`+ next if ($test_name =~ "col-0" or $test_name =~ "col-inval" or $test_name =~ "asan1");`
		8d0e4d	`+ push @new, ["$test_name-mb", @new_t, {ENV => "LC_ALL=$mb_locale"}];`
		8d0e4d	`+ }`
		8d0e4d	`+ push @Tests, @new;`
		8d0e4d	`+ }`
		8d0e4d	`+`
		8d0e4d	`@Tests = triple_test \@Tests;`
		8d0e4d
		8d0e4d	`+# Remember that triple_test creates from each test with exactly one "IN"`
		8d0e4d	`+# file two more tests (.p and .r suffix on name) corresponding to reading`
		8d0e4d	`+# input from a file and from a pipe. The pipe-reading test would fail`
		8d0e4d	`+# due to a race condition about 1 in 20 times.`
		8d0e4d	`+# Remove the IN_PIPE version of the "output-is-input" test above.`
		8d0e4d	`+# The others aren't susceptible because they have three inputs each.`
		8d0e4d	`+@Tests = grep {$_->[0] ne 'output-is-input.p'} @Tests;`
		8d0e4d	`+`
		8d0e4d	`my $save_temps = $ENV{DEBUG};`
		8d0e4d	`my $verbose = $ENV{VERBOSE};`
		8d0e4d
		8d0e4d	`--`
		8d0e4d	`2.7.4`
		8d0e4d

rpms / coreutils

Source Code

Blame SOURCES/coreutils-i18n.patch