commit bash-20150123 snapshot

lib/readline/bind.c

@@ -542,7 +542,7 @@ rl_translate_keyseq (seq, array, len)
 	    case '0': case '1': case '2': case '3':
 	    case '4': case '5': case '6': case '7':
 	      i++;
-	      for (temp = 2, c -= '0'; ISOCTAL (seq[i]) && temp--; i++)
+	      for (temp = 2, c -= '0'; ISOCTAL ((unsigned char)seq[i]) && temp--; i++)
 	        c = (c * 8) + OCTVALUE (seq[i]);
 	      i--;	/* auto-increment in for loop */
 	      array[l++] = c & largest_char;

lib/readline/chardefs.h

@@ -73,7 +73,7 @@
 #endif
 
 #if !defined (isxdigit) && !defined (HAVE_ISXDIGIT) && !defined (__cplusplus)
-#  define isxdigit(c)   (isdigit((c)) || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F'))
+#  define isxdigit(c)   (isdigit((unsigned char)(c)) || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F'))
 #endif
 
 #if defined (CTYPE_NON_ASCII)
@@ -87,13 +87,13 @@
 
 /* Beware:  these only work with single-byte ASCII characters. */
 
-#define ISALNUM(c)	(IN_CTYPE_DOMAIN (c) && isalnum (c))
-#define ISALPHA(c)	(IN_CTYPE_DOMAIN (c) && isalpha (c))
-#define ISDIGIT(c)	(IN_CTYPE_DOMAIN (c) && isdigit (c))
-#define ISLOWER(c)	(IN_CTYPE_DOMAIN (c) && islower (c))
-#define ISPRINT(c)	(IN_CTYPE_DOMAIN (c) && isprint (c))
-#define ISUPPER(c)	(IN_CTYPE_DOMAIN (c) && isupper (c))
-#define ISXDIGIT(c)	(IN_CTYPE_DOMAIN (c) && isxdigit (c))
+#define ISALNUM(c)	(IN_CTYPE_DOMAIN (c) && isalnum ((unsigned char)c))
+#define ISALPHA(c)	(IN_CTYPE_DOMAIN (c) && isalpha ((unsigned char)c))
+#define ISDIGIT(c)	(IN_CTYPE_DOMAIN (c) && isdigit ((unsigned char)c))
+#define ISLOWER(c)	(IN_CTYPE_DOMAIN (c) && islower ((unsigned char)c))
+#define ISPRINT(c)	(IN_CTYPE_DOMAIN (c) && isprint ((unsigned char)c))
+#define ISUPPER(c)	(IN_CTYPE_DOMAIN (c) && isupper ((unsigned char)c))
+#define ISXDIGIT(c)	(IN_CTYPE_DOMAIN (c) && isxdigit ((unsigned char)c))
 
 #define _rl_lowercase_p(c)	(NON_NEGATIVE(c) && ISLOWER(c))
 #define _rl_uppercase_p(c)	(NON_NEGATIVE(c) && ISUPPER(c))

lib/readline/chardefs.h~

@@ -0,0 +1,164 @@
+/* chardefs.h -- Character definitions for readline. */
+
+/* Copyright (C) 1994-2009 Free Software Foundation, Inc.
+
+   This file is part of the GNU Readline Library (Readline), a library
+   for reading lines of text with interactive input and history editing.
+
+   Readline is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   Readline is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with Readline.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef _CHARDEFS_H_
+#define _CHARDEFS_H_
+
+#include <ctype.h>
+
+#if defined (HAVE_CONFIG_H)
+#  if defined (HAVE_STRING_H)
+#    if ! defined (STDC_HEADERS) && defined (HAVE_MEMORY_H)
+#      include <memory.h>
+#    endif
+#    include <string.h>
+#  endif /* HAVE_STRING_H */
+#  if defined (HAVE_STRINGS_H)
+#    include <strings.h>
+#  endif /* HAVE_STRINGS_H */
+#else
+#  include <string.h>
+#endif /* !HAVE_CONFIG_H */
+
+#ifndef whitespace
+#define whitespace(c) (((c) == ' ') || ((c) == '\t'))
+#endif
+
+#ifdef CTRL
+#  undef CTRL
+#endif
+#ifdef UNCTRL
+#  undef UNCTRL
+#endif
+
+/* Some character stuff. */
+#define control_character_threshold 0x020   /* Smaller than this is control. */
+#define control_character_mask 0x1f	    /* 0x20 - 1 */
+#define meta_character_threshold 0x07f	    /* Larger than this is Meta. */
+#define control_character_bit 0x40	    /* 0x000000, must be off. */
+#define meta_character_bit 0x080	    /* x0000000, must be on. */
+#define largest_char 255		    /* Largest character value. */
+
+#define CTRL_CHAR(c) ((c) < control_character_threshold && (((c) & 0x80) == 0))
+#define META_CHAR(c) ((c) > meta_character_threshold && (c) <= largest_char)
+
+#define CTRL(c) ((c) & control_character_mask)
+#define META(c) ((c) | meta_character_bit)
+
+#define UNMETA(c) ((c) & (~meta_character_bit))
+#define UNCTRL(c) _rl_to_upper(((c)|control_character_bit))
+
+#if defined STDC_HEADERS || (!defined (isascii) && !defined (HAVE_ISASCII))
+#  define IN_CTYPE_DOMAIN(c) 1
+#else
+#  define IN_CTYPE_DOMAIN(c) isascii(c)
+#endif
+
+#if !defined (isxdigit) && !defined (HAVE_ISXDIGIT) && !defined (__cplusplus)
+#  define isxdigit(c)   (isdigit((c)) || ((c) >= 'a' && (c) <= 'f') || ((c) >= 'A' && (c) <= 'F'))
+#endif
+
+#if defined (CTYPE_NON_ASCII)
+#  define NON_NEGATIVE(c) 1
+#else
+#  define NON_NEGATIVE(c) ((unsigned char)(c) == (c))
+#endif
+
+/* Some systems define these; we want our definitions. */
+#undef ISPRINT
+
+/* Beware:  these only work with single-byte ASCII characters. */
+
+#define ISALNUM(c)	(IN_CTYPE_DOMAIN (c) && isalnum (c))
+#define ISALPHA(c)	(IN_CTYPE_DOMAIN (c) && isalpha (c))
+#define ISDIGIT(c)	(IN_CTYPE_DOMAIN (c) && isdigit (c))
+#define ISLOWER(c)	(IN_CTYPE_DOMAIN (c) && islower (c))
+#define ISPRINT(c)	(IN_CTYPE_DOMAIN (c) && isprint (c))
+#define ISUPPER(c)	(IN_CTYPE_DOMAIN (c) && isupper (c))
+#define ISXDIGIT(c)	(IN_CTYPE_DOMAIN (c) && isxdigit (c))
+
+#define _rl_lowercase_p(c)	(NON_NEGATIVE(c) && ISLOWER(c))
+#define _rl_uppercase_p(c)	(NON_NEGATIVE(c) && ISUPPER(c))
+#define _rl_digit_p(c)		((c) >= '0' && (c) <= '9')
+
+#define _rl_pure_alphabetic(c)	(NON_NEGATIVE(c) && ISALPHA(c))
+#define ALPHABETIC(c)		(NON_NEGATIVE(c) && ISALNUM(c))
+
+#ifndef _rl_to_upper
+#  define _rl_to_upper(c) (_rl_lowercase_p(c) ? toupper((unsigned char)c) : (c))
+#  define _rl_to_lower(c) (_rl_uppercase_p(c) ? tolower((unsigned char)c) : (c))
+#endif
+
+#ifndef _rl_digit_value
+#  define _rl_digit_value(x) ((x) - '0')
+#endif
+
+#ifndef _rl_isident
+#  define _rl_isident(c) (ISALNUM(c) || (c) == '_')
+#endif
+
+#ifndef ISOCTAL
+#  define ISOCTAL(c)	((c) >= '0' && (c) <= '7')
+#endif
+#define OCTVALUE(c)	((c) - '0')
+
+#define HEXVALUE(c) \
+  (((c) >= 'a' && (c) <= 'f') \
+  	? (c)-'a'+10 \
+  	: (c) >= 'A' && (c) <= 'F' ? (c)-'A'+10 : (c)-'0')
+
+#ifndef NEWLINE
+#define NEWLINE '\n'
+#endif
+
+#ifndef RETURN
+#define RETURN CTRL('M')
+#endif
+
+#ifndef RUBOUT
+#define RUBOUT 0x7f
+#endif
+
+#ifndef TAB
+#define TAB '\t'
+#endif
+
+#ifdef ABORT_CHAR
+#undef ABORT_CHAR
+#endif
+#define ABORT_CHAR CTRL('G')
+
+#ifdef PAGE
+#undef PAGE
+#endif
+#define PAGE CTRL('L')
+
+#ifdef SPACE
+#undef SPACE
+#endif
+#define SPACE ' '	/* XXX - was 0x20 */
+
+#ifdef ESC
+#undef ESC
+#endif
+#define ESC CTRL('[')
+
+#endif  /* _CHARDEFS_H_ */

lib/readline/histfile.c

@@ -114,7 +114,7 @@ int history_lines_written_to_file = 0;
 
 /* Does S look like the beginning of a history timestamp entry?  Placeholder
    for more extensive tests. */
-#define HIST_TIMESTAMP_START(s)		(*(s) == history_comment_char && isdigit ((s)[1]) )
+#define HIST_TIMESTAMP_START(s)		(*(s) == history_comment_char && isdigit ((unsigned char)(s)[1]) )
 
 /* Return the string that should be used in the place of this
    filename.  This only matters when you don't specify the

lib/readline/histfile.c~

@@ -0,0 +1,650 @@
+/* histfile.c - functions to manipulate the history file. */
+
+/* Copyright (C) 1989-2010 Free Software Foundation, Inc.
+
+   This file contains the GNU History Library (History), a set of
+   routines for managing the text of previously typed lines.
+
+   History is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   History is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with History.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/* The goal is to make the implementation transparent, so that you
+   don't have to know what data types are used, just what functions
+   you can call.  I think I have done that. */
+
+#define READLINE_LIBRARY
+
+#if defined (__TANDEM)
+#  include <floss.h>
+#endif
+
+#if defined (HAVE_CONFIG_H)
+#  include <config.h>
+#endif
+
+#include <stdio.h>
+
+#include <sys/types.h>
+#if ! defined (_MINIX) && defined (HAVE_SYS_FILE_H)
+#  include <sys/file.h>
+#endif
+#include "posixstat.h"
+#include <fcntl.h>
+
+#if defined (HAVE_STDLIB_H)
+#  include <stdlib.h>
+#else
+#  include "ansi_stdlib.h"
+#endif /* HAVE_STDLIB_H */
+
+#if defined (HAVE_UNISTD_H)
+#  include <unistd.h>
+#endif
+
+#include <ctype.h>
+
+#if defined (__EMX__)
+#  undef HAVE_MMAP
+#endif
+
+#ifdef HISTORY_USE_MMAP
+#  include <sys/mman.h>
+
+#  ifdef MAP_FILE
+#    define MAP_RFLAGS	(MAP_FILE|MAP_PRIVATE)
+#    define MAP_WFLAGS	(MAP_FILE|MAP_SHARED)
+#  else
+#    define MAP_RFLAGS	MAP_PRIVATE
+#    define MAP_WFLAGS	MAP_SHARED
+#  endif
+
+#  ifndef MAP_FAILED
+#    define MAP_FAILED	((void *)-1)
+#  endif
+
+#endif /* HISTORY_USE_MMAP */
+
+/* If we're compiling for __EMX__ (OS/2) or __CYGWIN__ (cygwin32 environment
+   on win 95/98/nt), we want to open files with O_BINARY mode so that there
+   is no \n -> \r\n conversion performed.  On other systems, we don't want to
+   mess around with O_BINARY at all, so we ensure that it's defined to 0. */
+#if defined (__EMX__) || defined (__CYGWIN__)
+#  ifndef O_BINARY
+#    define O_BINARY 0
+#  endif
+#else /* !__EMX__ && !__CYGWIN__ */
+#  undef O_BINARY
+#  define O_BINARY 0
+#endif /* !__EMX__ && !__CYGWIN__ */
+
+#include <errno.h>
+#if !defined (errno)
+extern int errno;
+#endif /* !errno */
+
+#include "history.h"
+#include "histlib.h"
+
+#include "rlshell.h"
+#include "xmalloc.h"
+
+/* If non-zero, we write timestamps to the history file in history_do_write() */
+int history_write_timestamps = 0;
+
+/* Immediately after a call to read_history() or read_history_range(), this
+   will return the number of lines just read from the history file in that
+   call. */
+int history_lines_read_from_file = 0;
+
+/* Immediately after a call to write_history() or history_do_write(), this
+   will return the number of lines just written to the history file in that
+   call.  This also works with history_truncate_file. */
+int history_lines_written_to_file = 0;
+
+/* Does S look like the beginning of a history timestamp entry?  Placeholder
+   for more extensive tests. */
+#define HIST_TIMESTAMP_START(s)		(*(s) == history_comment_char && isdigit ((s)[1]) )
+
+/* Return the string that should be used in the place of this
+   filename.  This only matters when you don't specify the
+   filename to read_history (), or write_history (). */
+static char *
+history_filename (filename)
+     const char *filename;
+{
+  char *return_val;
+  const char *home;
+  int home_len;
+
+  return_val = filename ? savestring (filename) : (char *)NULL;
+
+  if (return_val)
+    return (return_val);
+  
+  home = sh_get_env_value ("HOME");
+#if defined (_WIN32)
+  if (home == 0)
+    home = sh_get_env_value ("APPDATA");
+#endif
+
+  if (home == 0)
+    return (NULL);
+  else
+    home_len = strlen (home);
+
+  return_val = (char *)xmalloc (2 + home_len + 8); /* strlen(".history") == 8 */
+  strcpy (return_val, home);
+  return_val[home_len] = '/';
+#if defined (__MSDOS__)
+  strcpy (return_val + home_len + 1, "_history");
+#else
+  strcpy (return_val + home_len + 1, ".history");
+#endif
+
+  return (return_val);
+}
+
+static char *
+history_backupfile (filename)
+     const char *filename;
+{
+  char *ret;
+  size_t len;
+
+  len = strlen (filename);
+  ret = xmalloc (len + 2);
+  strcpy (ret, filename);
+  ret[len] = '-';
+  ret[len+1] = '\0';
+  return ret;
+}
+  
+/* Add the contents of FILENAME to the history list, a line at a time.
+   If FILENAME is NULL, then read from ~/.history.  Returns 0 if
+   successful, or errno if not. */
+int
+read_history (filename)
+     const char *filename;
+{
+  return (read_history_range (filename, 0, -1));
+}
+
+/* Read a range of lines from FILENAME, adding them to the history list.
+   Start reading at the FROM'th line and end at the TO'th.  If FROM
+   is zero, start at the beginning.  If TO is less than FROM, read
+   until the end of the file.  If FILENAME is NULL, then read from
+   ~/.history.  Returns 0 if successful, or errno if not. */
+int
+read_history_range (filename, from, to)
+     const char *filename;
+     int from, to;
+{
+  register char *line_start, *line_end, *p;
+  char *input, *buffer, *bufend, *last_ts;
+  int file, current_line, chars_read;
+  struct stat finfo;
+  size_t file_size;
+#if defined (EFBIG)
+  int overflow_errno = EFBIG;
+#elif defined (EOVERFLOW)
+  int overflow_errno = EOVERFLOW;
+#else
+  int overflow_errno = EIO;
+#endif
+
+  history_lines_read_from_file = 0;
+
+  buffer = last_ts = (char *)NULL;
+  input = history_filename (filename);
+  file = input ? open (input, O_RDONLY|O_BINARY, 0666) : -1;
+
+  if ((file < 0) || (fstat (file, &finfo) == -1))
+    goto error_and_exit;
+
+  file_size = (size_t)finfo.st_size;
+
+  /* check for overflow on very large files */
+  if (file_size != finfo.st_size || file_size + 1 < file_size)
+    {
+      errno = overflow_errno;
+      goto error_and_exit;
+    }
+
+#ifdef HISTORY_USE_MMAP
+  /* We map read/write and private so we can change newlines to NULs without
+     affecting the underlying object. */
+  buffer = (char *)mmap (0, file_size, PROT_READ|PROT_WRITE, MAP_RFLAGS, file, 0);
+  if ((void *)buffer == MAP_FAILED)
+    {
+      errno = overflow_errno;
+      goto error_and_exit;
+    }
+  chars_read = file_size;
+#else
+  buffer = (char *)malloc (file_size + 1);
+  if (buffer == 0)
+    {
+      errno = overflow_errno;
+      goto error_and_exit;
+    }
+
+  chars_read = read (file, buffer, file_size);
+#endif
+  if (chars_read < 0)
+    {
+  error_and_exit:
+      if (errno != 0)
+	chars_read = errno;
+      else
+	chars_read = EIO;
+      if (file >= 0)
+	close (file);
+
+      FREE (input);
+#ifndef HISTORY_USE_MMAP
+      FREE (buffer);
+#endif
+
+      return (chars_read);
+    }
+
+  close (file);
+
+  /* Set TO to larger than end of file if negative. */
+  if (to < 0)
+    to = chars_read;
+
+  /* Start at beginning of file, work to end. */
+  bufend = buffer + chars_read;
+  current_line = 0;
+
+  /* Skip lines until we are at FROM. */
+  for (line_start = line_end = buffer; line_end < bufend && current_line < from; line_end++)
+    if (*line_end == '\n')
+      {
+      	p = line_end + 1;
+      	/* If we see something we think is a timestamp, continue with this
+	   line.  We should check more extensively here... */
+	if (HIST_TIMESTAMP_START(p) == 0)
+	  current_line++;
+	line_start = p;
+      }
+
+  /* If there are lines left to gobble, then gobble them now. */
+  for (line_end = line_start; line_end < bufend; line_end++)
+    if (*line_end == '\n')
+      {
+	/* Change to allow Windows-like \r\n end of line delimiter. */
+	if (line_end > line_start && line_end[-1] == '\r')
+	  line_end[-1] = '\0';
+	else
+	  *line_end = '\0';
+
+	if (*line_start)
+	  {
+	    if (HIST_TIMESTAMP_START(line_start) == 0)
+	      {
+		add_history (line_start);
+		if (last_ts)
+		  {
+		    add_history_time (last_ts);
+		    last_ts = NULL;
+		  }
+	      }
+	    else
+	      {
+		last_ts = line_start;
+		current_line--;
+	      }
+	  }
+
+	current_line++;
+
+	if (current_line >= to)
+	  break;
+
+	line_start = line_end + 1;
+      }
+
+  history_lines_read_from_file = current_line;
+
+  FREE (input);
+#ifndef HISTORY_USE_MMAP
+  FREE (buffer);
+#else
+  munmap (buffer, file_size);
+#endif
+
+  return (0);
+}
+
+/* Truncate the history file FNAME, leaving only LINES trailing lines.
+   If FNAME is NULL, then use ~/.history.  Returns 0 on success, errno
+   on failure. */
+int
+history_truncate_file (fname, lines)
+     const char *fname;
+     int lines;
+{
+  char *buffer, *filename, *bakname, *bp, *bp1;		/* bp1 == bp+1 */
+  int file, chars_read, rv, orig_lines, exists;
+  struct stat finfo;
+  size_t file_size;
+
+  history_lines_written_to_file = 0;
+
+  buffer = (char *)NULL;
+  filename = history_filename (fname);
+  bakname = 0;
+  file = filename ? open (filename, O_RDONLY|O_BINARY, 0666) : -1;
+  rv = exists = 0;
+
+  /* Don't try to truncate non-regular files. */
+  if (file == -1 || fstat (file, &finfo) == -1)
+    {
+      rv = errno;
+      if (file != -1)
+	close (file);
+      goto truncate_exit;
+    }
+  exists = 1;
+
+  if (S_ISREG (finfo.st_mode) == 0)
+    {
+      close (file);
+#ifdef EFTYPE
+      rv = EFTYPE;
+#else
+      rv = EINVAL;
+#endif
+      goto truncate_exit;
+    }
+
+  file_size = (size_t)finfo.st_size;
+
+  /* check for overflow on very large files */
+  if (file_size != finfo.st_size || file_size + 1 < file_size)
+    {
+      close (file);
+#if defined (EFBIG)
+      rv = errno = EFBIG;
+#elif defined (EOVERFLOW)
+      rv = errno = EOVERFLOW;
+#else
+      rv = errno = EINVAL;
+#endif
+      goto truncate_exit;
+    }
+
+  buffer = (char *)malloc (file_size + 1);
+  if (buffer == 0)
+    {
+      rv = errno;
+      close (file);
+      goto truncate_exit;
+    }
+
+  chars_read = read (file, buffer, file_size);
+  close (file);
+
+  if (chars_read <= 0)
+    {
+      rv = (chars_read < 0) ? errno : 0;
+      goto truncate_exit;
+    }
+
+  orig_lines = lines;
+  /* Count backwards from the end of buffer until we have passed
+     LINES lines.  bp1 is set funny initially.  But since bp[1] can't
+     be a comment character (since it's off the end) and *bp can't be
+     both a newline and the history comment character, it should be OK. */
+  for (bp1 = bp = buffer + chars_read - 1; lines && bp > buffer; bp--)
+    {
+      if (*bp == '\n' && HIST_TIMESTAMP_START(bp1) == 0)
+	lines--;
+      bp1 = bp;
+    }
+
+  /* If this is the first line, then the file contains exactly the
+     number of lines we want to truncate to, so we don't need to do
+     anything.  It's the first line if we don't find a newline between
+     the current value of i and 0.  Otherwise, write from the start of
+     this line until the end of the buffer. */
+  for ( ; bp > buffer; bp--)
+    {
+      if (*bp == '\n' && HIST_TIMESTAMP_START(bp1) == 0)
+        {
+	  bp++;
+	  break;
+        }
+      bp1 = bp;
+    }
+
+  /* Write only if there are more lines in the file than we want to
+     truncate to. */
+  if (bp <= buffer)
+    {
+      rv = 0;
+      /* No-op if LINES == 0 at this point */
+      history_lines_written_to_file = orig_lines - lines;
+      goto truncate_exit;
+    }
+
+  bakname = history_backupfile (filename);
+  if (filename && bakname)
+    rename (filename, bakname);
+
+  if ((file = open (filename, O_WRONLY|O_CREAT|O_TRUNC|O_BINARY, 0600)) != -1)
+    {
+      if (write (file, bp, chars_read - (bp - buffer)) < 0)
+	rv = errno;
+
+#if defined (__BEOS__)
+      /* BeOS ignores O_TRUNC. */
+      ftruncate (file, chars_read - (bp - buffer));
+#endif
+
+      if (close (file) < 0 && rv == 0)
+	rv = errno;
+    }
+  else
+    rv = errno;
+
+ truncate_exit:
+  FREE (buffer);
+
+  history_lines_written_to_file = orig_lines - lines;
+
+  if (rv != 0 && filename && bakname)
+    rename (bakname, filename);
+  else if (rv == 0 && bakname)
+    unlink (bakname);
+
+  /* Make sure the new filename is owned by the same user as the old.  If one
+     user is running this, it's a no-op.  If the shell is running after sudo
+     with a shared history file, we don't want to leave the history file
+     owned by root. */
+  if (rv == 0 && exists)
+    chown (filename, finfo.st_uid, finfo.st_gid);
+
+  xfree (filename);
+  FREE (bakname);
+
+  return rv;
+}
+
+/* Workhorse function for writing history.  Writes the last NELEMENT entries
+   from the history list to FILENAME.  OVERWRITE is non-zero if you
+   wish to replace FILENAME with the entries. */
+static int
+history_do_write (filename, nelements, overwrite)
+     const char *filename;
+     int nelements, overwrite;
+{
+  register int i;
+  char *output, *bakname;
+  int file, mode, rv, exists;
+  struct stat finfo;
+#ifdef HISTORY_USE_MMAP
+  size_t cursize;
+
+  history_lines_written_to_file = 0;
+
+  mode = overwrite ? O_RDWR|O_CREAT|O_TRUNC|O_BINARY : O_RDWR|O_APPEND|O_BINARY;
+#else
+  mode = overwrite ? O_WRONLY|O_CREAT|O_TRUNC|O_BINARY : O_WRONLY|O_APPEND|O_BINARY;
+#endif
+  output = history_filename (filename);
+  bakname = (overwrite && output) ? history_backupfile (output) : 0;
+  exists = output ? (stat (output, &finfo) == 0) : 0;
+
+  if (output && bakname)
+    rename (output, bakname);
+
+  file = output ? open (output, mode, 0600) : -1;
+  rv = 0;
+
+  if (file == -1)
+    {
+      rv = errno;
+      if (output && bakname)
+        rename (bakname, output);
+      FREE (output);
+      FREE (bakname);
+      return (rv);
+    }
+
+#ifdef HISTORY_USE_MMAP
+  cursize = overwrite ? 0 : lseek (file, 0, SEEK_END);
+#endif
+
+  if (nelements > history_length)
+    nelements = history_length;
+
+  /* Build a buffer of all the lines to write, and write them in one syscall.
+     Suggested by Peter Ho (peter@robosts.oxford.ac.uk). */
+  {
+    HIST_ENTRY **the_history;	/* local */
+    register int j;
+    int buffer_size;
+    char *buffer;
+
+    the_history = history_list ();
+    /* Calculate the total number of bytes to write. */
+    for (buffer_size = 0, i = history_length - nelements; i < history_length; i++)
+#if 0
+      buffer_size += 2 + HISTENT_BYTES (the_history[i]);
+#else
+      {
+	if (history_write_timestamps && the_history[i]->timestamp && the_history[i]->timestamp[0])
+	  buffer_size += strlen (the_history[i]->timestamp) + 1;
+	buffer_size += strlen (the_history[i]->line) + 1;
+      }
+#endif
+
+    /* Allocate the buffer, and fill it. */
+#ifdef HISTORY_USE_MMAP
+    if (ftruncate (file, buffer_size+cursize) == -1)
+      goto mmap_error;
+    buffer = (char *)mmap (0, buffer_size, PROT_READ|PROT_WRITE, MAP_WFLAGS, file, cursize);
+    if ((void *)buffer == MAP_FAILED)
+      {
+mmap_error:
+	rv = errno;
+	close (file);
+	if (output && bakname)
+	  rename (bakname, output);
+	FREE (output);
+	FREE (bakname);
+	return rv;
+      }
+#else    
+    buffer = (char *)malloc (buffer_size);
+    if (buffer == 0)
+      {
+      	rv = errno;
+	close (file);
+	if (output && bakname)
+	  rename (bakname, output);
+	FREE (output);
+	FREE (bakname);
+	return rv;
+      }
+#endif
+
+    for (j = 0, i = history_length - nelements; i < history_length; i++)
+      {
+	if (history_write_timestamps && the_history[i]->timestamp && the_history[i]->timestamp[0])
+	  {
+	    strcpy (buffer + j, the_history[i]->timestamp);
+	    j += strlen (the_history[i]->timestamp);
+	    buffer[j++] = '\n';
+	  }
+	strcpy (buffer + j, the_history[i]->line);
+	j += strlen (the_history[i]->line);
+	buffer[j++] = '\n';
+      }
+
+#ifdef HISTORY_USE_MMAP
+    if (msync (buffer, buffer_size, MS_ASYNC) != 0 || munmap (buffer, buffer_size) != 0)
+      rv = errno;
+#else
+    if (write (file, buffer, buffer_size) < 0)
+      rv = errno;
+    xfree (buffer);
+#endif
+  }
+
+  history_lines_written_to_file = nelements;
+
+  if (close (file) < 0 && rv == 0)
+    rv = errno;
+
+  if (rv != 0 && output && bakname)
+    rename (bakname, output);
+  else if (rv == 0 && bakname)
+    unlink (bakname);
+
+  /* Make sure the new filename is owned by the same user as the old.  If one
+     user is running this, it's a no-op.  If the shell is running after sudo
+     with a shared history file, we don't want to leave the history file
+     owned by root. */
+  if (rv == 0 && exists)
+    chown (output, finfo.st_uid, finfo.st_gid);
+
+  FREE (output);
+  FREE (bakname);
+
+  return (rv);
+}
+
+/* Append NELEMENT entries to FILENAME.  The entries appended are from
+   the end of the list minus NELEMENTs up to the end of the list. */
+int
+append_history (nelements, filename)
+     int nelements;
+     const char *filename;
+{
+  return (history_do_write (filename, nelements, HISTORY_APPEND));
+}
+
+/* Overwrite FILENAME with the current history.  If FILENAME is NULL,
+   then write the history list to ~/.history.  Values returned
+   are as in read_history ().*/
+int
+write_history (filename)
+     const char *filename;
+{
+  return (history_do_write (filename, history_length, HISTORY_OVERWRITE));
+}

lib/readline/readline.c

@@ -533,9 +533,9 @@ readline_internal_charloop ()
   int c, code, lk;
 
   lastc = EOF;
-  eof_found = 0;
 
 #if !defined (READLINE_CALLBACKS)
+  eof_found = 0;
   while (rl_done == 0)
     {
 #endif

lib/readline/rlmbutil.h

@@ -132,6 +132,12 @@ extern int _rl_walphabetic PARAMS((wchar_t));
 #  define WCWIDTH(wc)	wcwidth(wc)
 #endif
 
+#if defined (WCWIDTH_BROKEN)
+#  define IS_COMBINING_CHAR(x)	(WCWIDTH(x) == 0 && iswcntrl(x) == 0)
+#else
+#  define IS_COMBINING_CHAR(x)	(WCWIDTH(x) == 0)
+#endif
+
 #else /* !HANDLE_MULTIBYTE */
 
 #undef MB_LEN_MAX

lib/readline/rlmbutil.h~

@@ -0,0 +1,163 @@
+/* rlmbutil.h -- utility functions for multibyte characters. */
+
+/* Copyright (C) 2001-2009 Free Software Foundation, Inc.
+
+   This file is part of the GNU Readline Library (Readline), a library
+   for reading lines of text with interactive input and history editing.      
+
+   Readline is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   Readline is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with Readline.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#if !defined (_RL_MBUTIL_H_)
+#define _RL_MBUTIL_H_
+
+#include "rlstdc.h"
+
+/************************************************/
+/* check multibyte capability for I18N code     */
+/************************************************/
+
+/* For platforms which support the ISO C amendement 1 functionality we
+   support user defined character classes.  */
+   /* Solaris 2.5 has a bug: <wchar.h> must be included before <wctype.h>.  */
+#if defined (HAVE_WCTYPE_H) && defined (HAVE_WCHAR_H) && defined (HAVE_LOCALE_H)
+#  include <wchar.h>
+#  include <wctype.h>
+#  if defined (HAVE_ISWCTYPE) && \
+      defined (HAVE_ISWLOWER) && \
+      defined (HAVE_ISWUPPER) && \
+      defined (HAVE_MBSRTOWCS) && \
+      defined (HAVE_MBRTOWC) && \
+      defined (HAVE_MBRLEN) && \
+      defined (HAVE_TOWLOWER) && \
+      defined (HAVE_TOWUPPER) && \
+      defined (HAVE_WCHAR_T) && \
+      defined (HAVE_WCWIDTH)
+     /* system is supposed to support XPG5 */
+#    define HANDLE_MULTIBYTE      1
+#  endif
+#endif
+
+/* If we don't want multibyte chars even on a system that supports them, let
+   the configuring user turn multibyte support off. */
+#if defined (NO_MULTIBYTE_SUPPORT)
+#  undef HANDLE_MULTIBYTE
+#endif
+
+/* Some systems, like BeOS, have multibyte encodings but lack mbstate_t.  */
+#if HANDLE_MULTIBYTE && !defined (HAVE_MBSTATE_T)
+#  define wcsrtombs(dest, src, len, ps) (wcsrtombs) (dest, src, len, 0)
+#  define mbsrtowcs(dest, src, len, ps) (mbsrtowcs) (dest, src, len, 0)
+#  define wcrtomb(s, wc, ps) (wcrtomb) (s, wc, 0)
+#  define mbrtowc(pwc, s, n, ps) (mbrtowc) (pwc, s, n, 0)
+#  define mbrlen(s, n, ps) (mbrlen) (s, n, 0)
+#  define mbstate_t int
+#endif
+
+/* Make sure MB_LEN_MAX is at least 16 on systems that claim to be able to
+   handle multibyte chars (some systems define MB_LEN_MAX as 1) */
+#ifdef HANDLE_MULTIBYTE
+#  include <limits.h>
+#  if defined(MB_LEN_MAX) && (MB_LEN_MAX < 16)
+#    undef MB_LEN_MAX
+#  endif
+#  if !defined (MB_LEN_MAX)
+#    define MB_LEN_MAX 16
+#  endif
+#endif
+
+/************************************************/
+/* end of multibyte capability checks for I18N  */
+/************************************************/
+
+/*
+ * Flags for _rl_find_prev_mbchar and _rl_find_next_mbchar:
+ *
+ * MB_FIND_ANY		find any multibyte character
+ * MB_FIND_NONZERO	find a non-zero-width multibyte character
+ */
+
+#define MB_FIND_ANY	0x00
+#define MB_FIND_NONZERO	0x01
+
+extern int _rl_find_prev_mbchar PARAMS((char *, int, int));
+extern int _rl_find_next_mbchar PARAMS((char *, int, int, int));
+
+#ifdef HANDLE_MULTIBYTE
+
+extern int _rl_compare_chars PARAMS((char *, int, mbstate_t *, char *, int, mbstate_t *));
+extern int _rl_get_char_len PARAMS((char *, mbstate_t *));
+extern int _rl_adjust_point PARAMS((char *, int, mbstate_t *));
+
+extern int _rl_read_mbchar PARAMS((char *, int));
+extern int _rl_read_mbstring PARAMS((int, char *, int));
+
+extern int _rl_is_mbchar_matched PARAMS((char *, int, int, char *, int));
+
+extern wchar_t _rl_char_value PARAMS((char *, int));
+extern int _rl_walphabetic PARAMS((wchar_t));
+
+#define _rl_to_wupper(wc)	(iswlower (wc) ? towupper (wc) : (wc))
+#define _rl_to_wlower(wc)	(iswupper (wc) ? towlower (wc) : (wc))
+
+#define MB_NEXTCHAR(b,s,c,f) \
+	((MB_CUR_MAX > 1 && rl_byte_oriented == 0) \
+		? _rl_find_next_mbchar ((b), (s), (c), (f)) \
+		: ((s) + (c)))
+#define MB_PREVCHAR(b,s,f) \
+	((MB_CUR_MAX > 1 && rl_byte_oriented == 0) \
+		? _rl_find_prev_mbchar ((b), (s), (f)) \
+		: ((s) - 1))
+
+#define MB_INVALIDCH(x)		((x) == (size_t)-1 || (x) == (size_t)-2)
+#define MB_NULLWCH(x)		((x) == 0)
+
+/* Unicode combining characters range from U+0300 to U+036F */
+#define UNICODE_COMBINING_CHAR(x) ((x) >= 768 && (x) <= 879)
+
+#if defined (WCWIDTH_BROKEN)
+#  define WCWIDTH(wc)	((_rl_utf8locale && UNICODE_COMBINING_CHAR(wc)) ? 0 : wcwidth(wc))
+#else
+#  define WCWIDTH(wc)	wcwidth(wc)
+#endif
+
+#else /* !HANDLE_MULTIBYTE */
+
+#undef MB_LEN_MAX
+#undef MB_CUR_MAX
+
+#define MB_LEN_MAX	1
+#define MB_CUR_MAX	1
+
+#define _rl_find_prev_mbchar(b, i, f)		(((i) == 0) ? (i) : ((i) - 1))
+#define _rl_find_next_mbchar(b, i1, i2, f)	((i1) + (i2))
+
+#define _rl_char_value(buf,ind)	((buf)[(ind)])
+
+#define _rl_walphabetic(c)	(rl_alphabetic (c))
+
+#define _rl_to_wupper(c)	(_rl_to_upper (c))
+#define _rl_to_wlower(c)	(_rl_to_lower (c))
+
+#define MB_NEXTCHAR(b,s,c,f)	((s) + (c))
+#define MB_PREVCHAR(b,s,f)	((s) - 1)
+
+#define MB_INVALIDCH(x)		(0)
+#define MB_NULLWCH(x)		(0)
+
+#endif /* !HANDLE_MULTIBYTE */
+
+extern int rl_byte_oriented;
+
+#endif /* _RL_MBUTIL_H_ */

lib/readline/text.c

@@ -1103,7 +1103,7 @@ _rl_rubout_char (count, key)
       c = rl_line_buffer[--rl_point];
       rl_delete_text (rl_point, orig_point);
       /* The erase-at-end-of-line hack is of questionable merit now. */
-      if (rl_point == rl_end && ISPRINT (c) && _rl_last_c_pos)
+      if (rl_point == rl_end && ISPRINT ((unsigned char)c) && _rl_last_c_pos)
 	{
 	  int l;
 	  l = rl_character_len (c, rl_point);
@@ -1337,7 +1337,7 @@ rl_change_case (count, op)
 	}
       else
 	nop = op;
-      if (MB_CUR_MAX == 1 || rl_byte_oriented || isascii (c))
+      if (MB_CUR_MAX == 1 || rl_byte_oriented || isascii ((unsigned char)c))
 	{
 	  nc = (nop == UpCase) ? _rl_to_upper (c) : _rl_to_lower (c);
 	  rl_line_buffer[start] = nc;

lib/sh/casemod.c

@@ -1,6 +1,6 @@
 /* casemod.c -- functions to change case of strings */
 
-/* Copyright (C) 2008,2009 Free Software Foundation, Inc.
+/* Copyright (C) 2008,2009,2015 Free Software Foundation, Inc.
 
    This file is part of GNU Bash, the Bourne Again SHell.
 
@@ -49,7 +49,7 @@
 #if !defined (HANDLE_MULTIBYTE)
 #  define cval(s, i)	((s)[(i)])
 #  define iswalnum(c)	(isalnum(c))
-#  define TOGGLE(x)	(ISUPPER (x) ? tolower (x) : (TOUPPER (x)))
+#  define TOGGLE(x)	(ISUPPER (x) ? tolower ((unsigned char)x) : (TOUPPER (x)))
 #else
 #  define TOGGLE(x)	(iswupper (x) ? towlower (x) : (_to_wupper(x)))
 #endif
@@ -105,7 +105,7 @@ sh_modcase (string, pat, flags)
      char *pat;
      int flags;
 {
-  int start, next, end;
+  int start, next, end, retind;
   int inword, c, nc, nop, match, usewords;
   char *ret, *s;
   wchar_t wc;
@@ -131,8 +131,8 @@ sh_modcase (string, pat, flags)
   start = 0;
   end = strlen (string);
 
-  ret = (char *)xmalloc (end + 1);
-  strcpy (ret, string);
+  ret = (char *)xmalloc (2*end + 1);
+  retind = 0;
 
   /* See if we are supposed to split on alphanumerics and operate on each word */
   usewords = (flags & CASE_USEWORDS);
@@ -141,26 +141,23 @@ sh_modcase (string, pat, flags)
   inword = 0;
   while (start < end)
     {
-      wc = cval (ret, start);
+      wc = cval (string, start);
 
       if (iswalnum (wc) == 0)
-	{
-	  inword = 0;
-#if 0
-	  ADVANCE_CHAR (ret, end, start);
-	  continue;
-#endif
-	}
+	inword = 0;
 
       if (pat)
 	{
 	  next = start;
-	  ADVANCE_CHAR (ret, end, next);
-	  s = substring (ret, start, next);
+	  ADVANCE_CHAR (string, end, next);
+	  s = substring (string, start, next);
 	  match = strmatch (pat, s, FNM_EXTMATCH) != FNM_NOMATCH;
 	  free (s);
 	  if (match == 0)
             {
+              /* copy unmatched portion */
+              memcpy (ret + retind, string + start, next - start);
+              retind += next - start;
               start = next;
               inword = 1;
               continue;
@@ -210,27 +207,27 @@ sh_modcase (string, pat, flags)
       else
 	nop = flags;
 
-      /* Need to check UCHAR_MAX since wc may have already been converted to a
-	 wide character by cval() */
-      if (MB_CUR_MAX == 1 || (wc <= UCHAR_MAX && is_basic ((int)wc)))
+      /* Can't short-circuit, some locales have multibyte upper and lower
+	 case equivalents of single-byte ascii characters (e.g., Turkish) */
+      if (MB_CUR_MAX == 1)
 	{
 singlebyte:
 	  switch (nop)
-	  {
-	  default:
-	  case CASE_NOOP:  nc = wc; break;
-	  case CASE_UPPER:  nc = TOUPPER (wc); break;
-	  case CASE_LOWER:  nc = TOLOWER (wc); break;
-	  case CASE_TOGGLEALL:
-	  case CASE_TOGGLE: nc = TOGGLE (wc); break;
-	  }
-	  ret[start] = nc;
+	    {
+	    default:
+	    case CASE_NOOP:  nc = wc; break;
+	    case CASE_UPPER:  nc = TOUPPER (wc); break;
+	    case CASE_LOWER:  nc = TOLOWER (wc); break;
+	    case CASE_TOGGLEALL:
+	    case CASE_TOGGLE: nc = TOGGLE (wc); break;
+	    }
+	  ret[retind++] = nc;
 	}
 #if defined (HANDLE_MULTIBYTE)
       else
 	{
 	  m = mbrtowc (&wc, string + start, end - start, &state);
-	  if (MB_INVALIDCH (m))
+	  if (MB_INVALIDCH (m) || m == 1)
 	    {
 	      wc = (unsigned char)string[start];
 	      goto singlebyte;
@@ -238,28 +235,34 @@ singlebyte:
 	  else if (MB_NULLWCH (m))
 	    wc = L'\0';
 	  switch (nop)
-	  {
-	  default:
-	  case CASE_NOOP:  nwc = wc; break;
-	  case CASE_UPPER:  nwc = _to_wupper (wc); break;
-	  case CASE_LOWER:  nwc = _to_wlower (wc); break;
-	  case CASE_TOGGLEALL:
-	  case CASE_TOGGLE: nwc = TOGGLE (wc); break;
-	  }
-	  if  (nwc != wc)	/*  just skip unchanged characters */
+	    {
+	    default:
+	    case CASE_NOOP:  nwc = wc; break;
+	    case CASE_UPPER:  nwc = _to_wupper (wc); break;
+	    case CASE_LOWER:  nwc = _to_wlower (wc); break;
+	    case CASE_TOGGLEALL:
+	    case CASE_TOGGLE: nwc = TOGGLE (wc); break;
+	    }
+
+	  /* We don't have to convert `wide' characters that are in the
+	     unsigned char range back to single-byte `multibyte' characters. */
+	  if ((int)nwc <= UCHAR_MAX && is_basic ((int)nwc))
+	    ret[retind++] = nwc;
+	  else
 	    {
 	      mlen = wcrtomb (mb, nwc, &state);
 	      if (mlen > 0)
 		mb[mlen] = '\0';
-	      /* Assume the same width */
-	      strncpy (ret + start, mb, mlen);
+	      /* Don't assume the same width */
+	      strncpy (ret + retind, mb, mlen);
+	      retind += mlen;
 	    }
 	}
 #endif
 
-      /*  This assumes that the upper and lower case versions are the same width. */
-      ADVANCE_CHAR (ret, end, start);
+      ADVANCE_CHAR (string, end, start);
     }
 
+  ret[retind] = '\0';
   return ret;
 }

lib/sh/casemod.c~

@@ -0,0 +1,270 @@
+/* casemod.c -- functions to change case of strings */
+
+/* Copyright (C) 2008,2009,2015 Free Software Foundation, Inc.
+
+   This file is part of GNU Bash, the Bourne Again SHell.
+
+   Bash is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   Bash is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with Bash.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#if defined (HAVE_CONFIG_H)
+#  include <config.h>
+#endif
+
+#if defined (HAVE_UNISTD_H)
+#  include <unistd.h>
+#endif /* HAVE_UNISTD_H */
+
+#include <stdc.h>
+
+#include <bashansi.h>
+#include <bashintl.h>
+#include <bashtypes.h>
+
+#include <stdio.h>
+#include <ctype.h>
+#include <xmalloc.h>
+
+#include <shmbchar.h>
+#include <shmbutil.h>
+#include <chartypes.h>
+#include <typemax.h>
+
+#include <glob/strmatch.h>
+
+#define _to_wupper(wc)	(iswlower (wc) ? towupper (wc) : (wc))
+#define _to_wlower(wc)	(iswupper (wc) ? towlower (wc) : (wc))
+
+#if !defined (HANDLE_MULTIBYTE)
+#  define cval(s, i)	((s)[(i)])
+#  define iswalnum(c)	(isalnum(c))
+#  define TOGGLE(x)	(ISUPPER (x) ? tolower ((unsigned char)x) : (TOUPPER (x)))
+#else
+#  define TOGGLE(x)	(iswupper (x) ? towlower (x) : (_to_wupper(x)))
+#endif
+
+/* These must agree with the defines in externs.h */
+#define CASE_NOOP	0x0000
+#define CASE_LOWER	0x0001
+#define CASE_UPPER	0x0002
+#define CASE_CAPITALIZE	0x0004
+#define CASE_UNCAP	0x0008
+#define CASE_TOGGLE	0x0010
+#define CASE_TOGGLEALL	0x0020
+#define CASE_UPFIRST	0x0040
+#define CASE_LOWFIRST	0x0080
+
+#define CASE_USEWORDS	0x1000		/* modify behavior to act on words in passed string */
+
+extern char *substring __P((char *, int, int));
+
+#ifndef UCHAR_MAX
+#  define UCHAR_MAX	TYPE_MAXIMUM(unsigned char)
+#endif
+
+#if defined (HANDLE_MULTIBYTE)
+static wchar_t
+cval (s, i)
+     char *s;
+     int i;
+{
+  size_t tmp;
+  wchar_t wc;
+  int l;
+  mbstate_t mps;  
+
+  if (MB_CUR_MAX == 1 || is_basic (s[i]))
+    return ((wchar_t)s[i]);
+  l = strlen (s);
+  if (i >= (l - 1))
+    return ((wchar_t)s[i]);
+  memset (&mps, 0, sizeof (mbstate_t));
+  tmp = mbrtowc (&wc, s + i, l - i, &mps);
+  if (MB_INVALIDCH (tmp) || MB_NULLWCH (tmp))
+    return ((wchar_t)s[i]);
+  return wc;  
+}
+#endif
+
+/* Modify the case of characters in STRING matching PAT based on the value of
+   FLAGS.  If PAT is null, modify the case of each character */
+char *
+sh_modcase (string, pat, flags)
+     const char *string;
+     char *pat;
+     int flags;
+{
+  int start, next, end, retind;
+  int inword, c, nc, nop, match, usewords;
+  char *ret, *s;
+  wchar_t wc;
+#if defined (HANDLE_MULTIBYTE)
+  wchar_t nwc;
+  char mb[MB_LEN_MAX+1];
+  int mlen;
+  size_t m;
+  mbstate_t state;
+#endif
+
+  if (string == 0 || *string == 0)
+    {
+      ret = (char *)xmalloc (1);
+      ret[0] = '\0';
+      return ret;
+    }
+
+#if defined (HANDLE_MULTIBYTE)
+  memset (&state, 0, sizeof (mbstate_t));
+#endif
+
+  start = 0;
+  end = strlen (string);
+
+  ret = (char *)xmalloc (2*end + 1);
+  retind = 0;
+
+  /* See if we are supposed to split on alphanumerics and operate on each word */
+  usewords = (flags & CASE_USEWORDS);
+  flags &= ~CASE_USEWORDS;
+
+  inword = 0;
+  while (start < end)
+    {
+      wc = cval (string, start);
+
+      if (iswalnum (wc) == 0)
+	inword = 0;
+
+      if (pat)
+	{
+	  next = start;
+	  ADVANCE_CHAR (string, end, next);
+	  s = substring (string, start, next);
+	  match = strmatch (pat, s, FNM_EXTMATCH) != FNM_NOMATCH;
+	  free (s);
+	  if (match == 0)
+            {
+              /* copy unmatched portion */
+              memcpy (ret + retind, string + start, next - start);
+              retind += next - start;
+              start = next;
+              inword = 1;
+              continue;
+            }
+	}
+
+      /* XXX - for now, the toggling operators work on the individual
+	 words in the string, breaking on alphanumerics.  Should I
+	 leave the capitalization operators to do that also? */
+      if (flags == CASE_CAPITALIZE)
+	{
+	  if (usewords)
+	    nop = inword ? CASE_LOWER : CASE_UPPER;
+	  else
+	    nop = (start > 0) ? CASE_LOWER : CASE_UPPER;
+	  inword = 1;
+	}
+      else if (flags == CASE_UNCAP)
+	{
+	  if (usewords)
+	    nop = inword ? CASE_UPPER : CASE_LOWER;
+	  else
+	    nop = (start > 0) ? CASE_UPPER : CASE_LOWER;
+	  inword = 1;
+	}
+      else if (flags == CASE_UPFIRST)
+ 	{
+ 	  if (usewords)
+	    nop = inword ? CASE_NOOP : CASE_UPPER;
+	  else
+	    nop = (start > 0) ? CASE_NOOP : CASE_UPPER;
+ 	  inword = 1;
+ 	}
+      else if (flags == CASE_LOWFIRST)
+ 	{
+ 	  if (usewords)
+	    nop = inword ? CASE_NOOP : CASE_LOWER;
+	  else
+	    nop = (start > 0) ? CASE_NOOP : CASE_LOWER;
+ 	  inword = 1;
+ 	}
+      else if (flags == CASE_TOGGLE)
+	{
+	  nop = inword ? CASE_NOOP : CASE_TOGGLE;
+	  inword = 1;
+	}
+      else
+	nop = flags;
+
+      /* Can't short-circuit, some locales have multibyte upper and lower
+	 case equivalents of single-byte ascii characters (e.g., Turkish) */
+      if (MB_CUR_MAX == 1)
+	{
+singlebyte:
+	  switch (nop)
+	    {
+	    default:
+	    case CASE_NOOP:  nc = wc; break;
+	    case CASE_UPPER:  nc = TOUPPER (wc); break;
+	    case CASE_LOWER:  nc = TOLOWER (wc); break;
+	    case CASE_TOGGLEALL:
+	    case CASE_TOGGLE: nc = TOGGLE (wc); break;
+	    }
+	  ret[retind++] = nc;
+	}
+#if defined (HANDLE_MULTIBYTE)
+      else
+	{
+	  m = mbrtowc (&wc, string + start, end - start, &state);
+if (m == 1)
+  itrace("sh_modcase: mbrtowc returns 1 for single byte char");
+	  if (MB_INVALIDCH (m) || m == 1)
+	    {
+	      wc = (unsigned char)string[start];
+	      goto singlebyte;
+	    }
+	  else if (MB_NULLWCH (m))
+	    wc = L'\0';
+	  switch (nop)
+	    {
+	    default:
+	    case CASE_NOOP:  nwc = wc; break;
+	    case CASE_UPPER:  nwc = _to_wupper (wc); break;
+	    case CASE_LOWER:  nwc = _to_wlower (wc); break;
+	    case CASE_TOGGLEALL:
+	    case CASE_TOGGLE: nwc = TOGGLE (wc); break;
+	    }
+
+	  /* We don't have to convert `wide' characters that are in the
+	     unsigned char range back to single-byte `multibyte' characters. */
+	  if ((int)nwc <= UCHAR_MAX && is_basic ((int)nwc))
+	    ret[retind++] = nwc;
+	  else
+	    {
+	      mlen = wcrtomb (mb, nwc, &state);
+	      if (mlen > 0)
+		mb[mlen] = '\0';
+	      /* Don't assume the same width */
+	      strncpy (ret + retind, mb, mlen);
+	      retind += mlen;
+	    }
+	}
+#endif
+
+      ADVANCE_CHAR (string, end, start);
+    }
+
+  ret[retind] = '\0';
+  return ret;
+}

lib/sh/shquote.c

@@ -33,6 +33,9 @@
 #include "syntax.h"
 #include <xmalloc.h>
 
+#include "shmbchar.h"
+#include "shmbutil.h"
+
 extern char *ansic_quote __P((char *, int, int *));
 extern int ansic_shouldquote __P((const char *));
 
@@ -231,13 +234,25 @@ sh_backslash_quote (string, table, flags)
      int flags;
 {
   int c;
-  char *result, *r, *s, *backslash_table;
+  size_t slen;
+  char *result, *r, *s, *backslash_table, *send;
+  DECLARE_MBSTATE;
 
-  result = (char *)xmalloc (2 * strlen (string) + 1);
+  slen = strlen (string);
+  send = string + slen;
+  result = (char *)xmalloc (2 * slen + 1);
 
   backslash_table = table ? table : (char *)bstab;
   for (r = result, s = string; s && (c = *s); s++)
     {
+#if defined (HANDLE_MULTIBYTE)
+      if (MB_CUR_MAX > 1 && is_basic (c) == 0)
+	{
+	  COPY_CHAR_P (r, s, send);
+	  s--;		/* compensate for auto-increment in loop above */
+	  continue;
+	}
+#endif
       if (backslash_table[c] == 1)
 	*r++ = '\\';
       else if (c == '#' && s == string)			/* comment char */