commit readline-20170531 snapshot

47 files changed, 1283 insertions, 1608 deletions

diff --git a/._complete.c b/._complete.c
deleted file mode 100644
index f2127f5..0000000
--- a/._complete.c
+++ /dev/null
diff --git a/NEWS b/NEWS
index cf7107e..4ff0330 100644
--- a/NEWS
+++ b/NEWS
@@ -46,6 +46,34 @@ k.  If readline reads a history file that begins with `#' (or the value of
 l.  Readline now throws an error if it parses a key binding without a terminating
     `:' or whitespace.
 
+m.  The default binding for ^W in vi mode now uses word boundaries specified
+    by Posix (vi-unix-word-rubout is bindable command name).
+
+n.  rl_clear_visible_line: new application-callable function; clears all
+    screen lines occupied by the current visible readline line.
+
+o.  rl_tty_set_echoing: application-callable function that controls whether
+    or not readline thinks it is echoing terminal output.
+
+p.  Handle >| and strings of digits preceding and following redirection
+    specifications as single tokens when tokenizing the line for history
+    expansion.
+
+q.  Fixed a bug with displaying completions when the prefix display length
+    is greater than the length of the completions to be displayed.
+
+r.  The :p history modifier now applies to the entire line, so any expansion
+    specifying :p causes the line to be printed instead of expanded.
+
+s.  New application-callable function: rl_pending_signal(): returns the signal
+    number of any signal readline has caught but not yet handled.
+    
+t.  New application-settable variable: rl_persistent_signal_handlers: if set
+    to a non-zero value, readline will enable the readline-6.2 signal handler
+    behavior in callback mode: handlers are installed when
+    rl_callback_handler_install is called and removed removed when a complete
+    line has been read.
+
 -------------------------------------------------------------------------------
 This is a terse description of the new features added to readline-6.3 since
 the release of readline-6.2.
diff --git a/bind.c b/bind.c
index f1098c4..fef538b 100644
--- a/bind.c
+++ b/bind.c
@@ -1,6 +1,6 @@
 /* bind.c -- key binding and startup file support for the readline library. */
 
-/* Copyright (C) 1987-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 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.
@@ -105,10 +105,7 @@ static int _rl_prefer_visible_bell = 1;
    Add NAME to the list of named functions.  Make FUNCTION be the function
    that gets called.  If KEY is not -1, then bind it. */
 int
-rl_add_defun (name, function, key)
-     const char *name;
-     rl_command_func_t *function;
-     int key;
+rl_add_defun (const char *name, rl_command_func_t *function, int key)
 {
   if (key != -1)
     rl_bind_key (key, function);
@@ -118,9 +115,7 @@ rl_add_defun (name, function, key)
 
 /* Bind KEY to FUNCTION.  Returns non-zero if KEY is out of range. */
 int
-rl_bind_key (key, function)
-     int key;
-     rl_command_func_t *function;
+rl_bind_key (int key, rl_command_func_t *function)
 {
   char keyseq[3];
   int l;
@@ -168,10 +163,7 @@ rl_bind_key (key, function)
 /* Bind KEY to FUNCTION in MAP.  Returns non-zero in case of invalid
    KEY. */
 int
-rl_bind_key_in_map (key, function, map)
-     int key;
-     rl_command_func_t *function;
-     Keymap map;
+rl_bind_key_in_map (int key, rl_command_func_t *function, Keymap map)
 {
   int result;
   Keymap oldmap;
@@ -184,13 +176,9 @@ rl_bind_key_in_map (key, function, map)
 }
 
 /* Bind key sequence KEYSEQ to DEFAULT_FUNC if KEYSEQ is unbound.  Right
-   now, this is always used to attempt to bind the arrow keys, hence the
-   check for rl_vi_movement_mode. */
+   now, this is always used to attempt to bind the arrow keys. */
 int
-rl_bind_key_if_unbound_in_map (key, default_func, kmap)
-     int key;
-     rl_command_func_t *default_func;
-     Keymap kmap;
+rl_bind_key_if_unbound_in_map (int key, rl_command_func_t *default_func, Keymap kmap)
 {
   char keyseq[2];
 
@@ -200,9 +188,7 @@ rl_bind_key_if_unbound_in_map (key, default_func, kmap)
 }
 
 int
-rl_bind_key_if_unbound (key, default_func)
-     int key;
-     rl_command_func_t *default_func;
+rl_bind_key_if_unbound (int key, rl_command_func_t *default_func)
 {
   char keyseq[2];
 
@@ -212,29 +198,24 @@ rl_bind_key_if_unbound (key, default_func)
 }
 
 /* Make KEY do nothing in the currently selected keymap.
-   Returns non-zero in case of error. */
+   Returns non-zero in case of error.  This is not the same as self-insert;
+   this makes it a dead key. */
 int
-rl_unbind_key (key)
-     int key;
+rl_unbind_key (int key)
 {
   return (rl_bind_key (key, (rl_command_func_t *)NULL));
 }
 
-/* Make KEY do nothing in MAP.
-   Returns non-zero in case of error. */
+/* Make KEY do nothing in MAP. Returns non-zero in case of error. */
 int
-rl_unbind_key_in_map (key, map)
-     int key;
-     Keymap map;
+rl_unbind_key_in_map (int key, Keymap map)
 {
   return (rl_bind_key_in_map (key, (rl_command_func_t *)NULL, map));
 }
 
 /* Unbind all keys bound to FUNCTION in MAP. */
 int
-rl_unbind_function_in_map (func, map)
-     rl_command_func_t *func;
-     Keymap map;
+rl_unbind_function_in_map (rl_command_func_t *func, Keymap map)
 {
   register int i, rval;
 
@@ -249,10 +230,9 @@ rl_unbind_function_in_map (func, map)
   return rval;
 }
 
+/* Unbind all keys bound to COMMAND, which is a bindable command name, in MAP */
 int
-rl_unbind_command_in_map (command, map)
-     const char *command;
-     Keymap map;
+rl_unbind_command_in_map (const char *command, Keymap map)
 {
   rl_command_func_t *func;
 
@@ -266,9 +246,7 @@ rl_unbind_command_in_map (command, map)
    FUNCTION, starting in the current keymap.  This makes new
    keymaps as necessary. */
 int
-rl_bind_keyseq (keyseq, function)
-     const char *keyseq;
-     rl_command_func_t *function;
+rl_bind_keyseq (const char *keyseq, rl_command_func_t *function)
 {
   return (rl_generic_bind (ISFUNC, keyseq, (char *)function, _rl_keymap));
 }
@@ -277,20 +255,14 @@ rl_bind_keyseq (keyseq, function)
    FUNCTION.  This makes new keymaps as necessary.  The initial
    place to do bindings is in MAP. */
 int
-rl_bind_keyseq_in_map (keyseq, function, map)
-     const char *keyseq;
-     rl_command_func_t *function;
-     Keymap map;
+rl_bind_keyseq_in_map (const char *keyseq, rl_command_func_t *function, Keymap map)
 {
   return (rl_generic_bind (ISFUNC, keyseq, (char *)function, map));
 }
 
 /* Backwards compatibility; equivalent to rl_bind_keyseq_in_map() */
 int
-rl_set_key (keyseq, function, map)
-     const char *keyseq;
-     rl_command_func_t *function;
-     Keymap map;
+rl_set_key (const char *keyseq, rl_command_func_t *function, Keymap map)
 {
   return (rl_generic_bind (ISFUNC, keyseq, (char *)function, map));
 }
@@ -299,10 +271,7 @@ rl_set_key (keyseq, function, map)
    now, this is always used to attempt to bind the arrow keys, hence the
    check for rl_vi_movement_mode. */
 int
-rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, kmap)
-     const char *keyseq;
-     rl_command_func_t *default_func;
-     Keymap kmap;
+rl_bind_keyseq_if_unbound_in_map (const char *keyseq, rl_command_func_t *default_func, Keymap kmap)
 {
   rl_command_func_t *func;
 
@@ -322,9 +291,7 @@ rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, kmap)
 }
 
 int
-rl_bind_keyseq_if_unbound (keyseq, default_func)
-     const char *keyseq;
-     rl_command_func_t *default_func;
+rl_bind_keyseq_if_unbound (const char *keyseq, rl_command_func_t *default_func)
 {
   return (rl_bind_keyseq_if_unbound_in_map (keyseq, default_func, _rl_keymap));
 }
@@ -333,9 +300,7 @@ rl_bind_keyseq_if_unbound (keyseq, default_func)
    the string of characters MACRO.  This makes new keymaps as
    necessary.  The initial place to do bindings is in MAP. */
 int
-rl_macro_bind (keyseq, macro, map)
-     const char *keyseq, *macro;
-     Keymap map;
+rl_macro_bind (const char *keyseq, const char *macro, Keymap map)
 {
   char *macro_keys;
   int macro_keys_len;
@@ -357,11 +322,7 @@ rl_macro_bind (keyseq, macro, map)
    a macro (ISMACR), or a keymap (ISKMAP).  This makes new keymaps
    as necessary.  The initial place to do bindings is in MAP. */
 int
-rl_generic_bind (type, keyseq, data, map)
-     int type;
-     const char *keyseq;
-     char *data;
-     Keymap map;
+rl_generic_bind (int type, const char *keyseq, char *data, Keymap map)
 {
   char *keys;
   int keys_len;
@@ -469,10 +430,7 @@ rl_generic_bind (type, keyseq, data, map)
    an array of characters.  LEN gets the final length of ARRAY.  Return
    non-zero if there was an error parsing SEQ. */
 int
-rl_translate_keyseq (seq, array, len)
-     const char *seq;
-     char *array;
-     int *len;
+rl_translate_keyseq (const char *seq, char *array, int *len)
 {
   register int i, c, l, temp;
 
@@ -483,7 +441,10 @@ rl_translate_keyseq (seq, array, len)
 	  c = seq[++i];
 
 	  if (c == 0)
-	    break;
+	    {
+	      array[l++] = '\\';	/* preserve trailing backslash */
+	      break;
+	    }
 
 	  /* Handle \C- and \M- prefixes. */
 	  if ((c == 'C' || c == 'M') && seq[i + 1] == '-')
@@ -494,8 +455,6 @@ rl_translate_keyseq (seq, array, len)
 		  array[l++] = ESC;	/* ESC is meta-prefix */
 		  i += 5;
 		  array[l++] = CTRL (_rl_to_upper (seq[i]));
-		  if (seq[i] == '\0')
-		    i--;
 		}
 	      else if (c == 'M')
 		{
@@ -524,6 +483,8 @@ rl_translate_keyseq (seq, array, len)
 		  /* Special hack for C-?... */
 		  array[l++] = (seq[i] == '?') ? RUBOUT : CTRL (_rl_to_upper (seq[i]));
 		}
+	      if (seq[i] == '\0')
+		break;
 	      continue;
 	    }	      
 
@@ -596,8 +557,7 @@ rl_translate_keyseq (seq, array, len)
 }
 
 static int
-_rl_isescape (c)
-     int c;
+_rl_isescape (int c)
 {
   switch (c)
     {
@@ -613,8 +573,7 @@ _rl_isescape (c)
 }
 
 static int
-_rl_escchar (c)
-     int c;
+_rl_escchar (int c)
 {
   switch (c)
     {
@@ -630,8 +589,7 @@ _rl_escchar (c)
 }
 
 char *
-rl_untranslate_keyseq (seq)
-     int seq;
+rl_untranslate_keyseq (int seq)
 {
   static char kseq[16];
   int i, c;
@@ -681,9 +639,7 @@ rl_untranslate_keyseq (seq)
 }
 
 char *
-_rl_untranslate_macro_value (seq, use_escapes)
-     char *seq;
-     int use_escapes;
+_rl_untranslate_macro_value (char *seq, int use_escapes)
 {
   char *ret, *r, *s;
   int c;
@@ -742,8 +698,7 @@ _rl_untranslate_macro_value (seq, use_escapes)
    If STRING doesn't have a matching function, then a NULL pointer
    is returned. */
 rl_command_func_t *
-rl_named_function (string)
-     const char *string;
+rl_named_function (const char *string)
 {
   register int i;
 
@@ -761,10 +716,7 @@ rl_named_function (string)
    type of the object pointed to.  One of ISFUNC (function), ISKMAP (keymap),
    or ISMACR (macro). */
 rl_command_func_t *
-rl_function_of_keyseq (keyseq, map, type)
-     const char *keyseq;
-     Keymap map;
-     int *type;
+rl_function_of_keyseq (const char *keyseq, Keymap map, int *type)
 {
   register int i;
 
@@ -835,9 +787,7 @@ static int current_readline_init_lineno;
    The size of the buffer is returned in *SIZEP.  Returns NULL if any
    errors were encountered. */
 static char *
-_rl_read_file (filename, sizep)
-     char *filename;
-     size_t *sizep;
+_rl_read_file (char *filename, size_t *sizep)
 {
   struct stat finfo;
   size_t file_size;
@@ -882,8 +832,7 @@ _rl_read_file (filename, sizep)
 
 /* Re-read the current keybindings file. */
 int
-rl_re_read_init_file (count, ignore)
-     int count, ignore;
+rl_re_read_init_file (int count, int ignore)
 {
   int r;
   r = rl_read_init_file ((const char *)NULL);
@@ -900,8 +849,7 @@ rl_re_read_init_file (count, ignore)
    If the file existed and could be opened and read, 0 is returned,
    otherwise errno is returned. */
 int
-rl_read_init_file (filename)
-     const char *filename;
+rl_read_init_file (const char *filename)
 {
   /* Default the filename. */
   if (filename == 0)
@@ -926,9 +874,7 @@ rl_read_init_file (filename)
 }
 
 static int
-_rl_read_init_file (filename, include_level)
-     const char *filename;
-     int include_level;
+_rl_read_init_file (const char *filename, int include_level)
 {
   register int i;
   char *buffer, *openname, *line, *end;
@@ -1055,8 +1001,7 @@ static int if_stack_size;
 /* Push _rl_parsing_conditionalized_out, and set parser state based
    on ARGS. */
 static int
-parser_if (args)
-     char *args;
+parser_if (char *args)
 {
   register int i;
 
@@ -1128,8 +1073,7 @@ parser_if (args)
 
 /* Invert the current parser state if there is anything on the stack. */
 static int
-parser_else (args)
-     char *args;
+parser_else (char *args)
 {
   register int i;
 
@@ -1159,8 +1103,7 @@ parser_else (args)
 /* Terminate a conditional, popping the value of
    _rl_parsing_conditionalized_out from the stack. */
 static int
-parser_endif (args)
-     char *args;
+parser_endif (char *args)
 {
   if (if_stack_depth)
     _rl_parsing_conditionalized_out = if_stack[--if_stack_depth];
@@ -1170,8 +1113,7 @@ parser_endif (args)
 }
 
 static int
-parser_include (args)
-     char *args;
+parser_include (char *args)
 {
   const char *old_init_file;
   char *e;
@@ -1211,8 +1153,7 @@ static const struct {
 /* Handle a parser directive.  STATEMENT is the line of the directive
    without any leading `$'. */
 static int
-handle_parser_directive (statement)
-     char *statement;
+handle_parser_directive (char *statement)
 {
   register int i;
   char *directive, *args;
@@ -1249,9 +1190,7 @@ handle_parser_directive (statement)
 /* Start at STRING[START] and look for DELIM.  Return I where STRING[I] ==
    DELIM or STRING[I] == 0.  DELIM is usually a double quote. */
 static int
-_rl_skip_to_delim (string, start, delim)
-     char *string;
-     int start, delim;
+_rl_skip_to_delim (char *string, int start, int delim)
 {
   int i, c, passc;
 
@@ -1283,8 +1222,7 @@ _rl_skip_to_delim (string, start, delim)
    a variable binding command looks like: set variable value.
    A new-style keybinding looks like "\C-x\C-x": exchange-point-and-mark. */
 int
-rl_parse_and_bind (string)
-     char *string;
+rl_parse_and_bind (char *string)
 {
   char *funname, *kname;
   register int c, i;
@@ -1328,6 +1266,12 @@ rl_parse_and_bind (string)
   /* Advance to the colon (:) or whitespace which separates the two objects. */
   for (; (c = string[i]) && c != ':' && c != ' ' && c != '\t'; i++ );
 
+  if (i == 0)
+    {
+      _rl_init_file_error ("`%s': invalid key binding: missing key sequence", string);
+      return 1;
+    }
+
   equivalency = (c == ':' && string[i + 1] == '=');
 
   foundsep = c != 0;
@@ -1406,6 +1350,11 @@ remove_trailing:
       i = _rl_skip_to_delim (string, i+1, *funname);
       if (string[i])
 	i++;
+      else
+	{
+	  _rl_init_file_error ("`%s': missing closing quote for macro", funname);
+	  return 1;
+	}
     }
 
   /* Advance to the end of the string.  */
@@ -1583,8 +1532,7 @@ static const struct {
 };
 
 static int
-find_boolean_var (name)
-     const char *name;
+find_boolean_var (const char *name)
 {
   register int i;
 
@@ -1598,8 +1546,7 @@ find_boolean_var (name)
    function needs to be called or another variable needs
    to be changed when they're changed. */
 static void
-hack_special_boolean_var (i)
-     int i;
+hack_special_boolean_var (int i)
 {
   const char *name;
 
@@ -1668,8 +1615,7 @@ static const struct {
 };
 
 static int
-find_string_var (name)
-     const char *name;
+find_string_var (const char *name)
 {
   register int i;
 
@@ -1683,8 +1629,7 @@ find_string_var (name)
    the value is null or empty, `on' (case-insensitive), or "1".  Any other
    values result in 0 (false). */
 static int
-bool_to_int (value)
-     const char *value;
+bool_to_int (const char *value)
 {
   return (value == 0 || *value == '\0' ||
 		(_rl_stricmp (value, "on") == 0) ||
@@ -1692,8 +1637,7 @@ bool_to_int (value)
 }
 
 char *
-rl_variable_value (name)
-     const char *name;
+rl_variable_value (const char *name)
 {
   register int i;
 
@@ -1711,8 +1655,7 @@ rl_variable_value (name)
 }
 
 int
-rl_variable_bind (name, value)
-     const char *name, *value;
+rl_variable_bind (const char *name, const char *value)
 {
   register int i;
   int	v;
@@ -1743,8 +1686,7 @@ rl_variable_bind (name, value)
 }
 
 static int
-sv_editmode (value)
-     const char *value;
+sv_editmode (const char *value)
 {
   if (_rl_strnicmp (value, "vi", 2) == 0)
     {
@@ -1764,8 +1706,7 @@ sv_editmode (value)
 }
 
 static int
-sv_combegin (value)
-     const char *value;
+sv_combegin (const char *value)
 {
   if (value && *value)
     {
@@ -1777,8 +1718,7 @@ sv_combegin (value)
 }
 
 static int
-sv_dispprefix (value)
-     const char *value;
+sv_dispprefix (const char *value)
 {
   int nval = 0;
 
@@ -1793,8 +1733,7 @@ sv_dispprefix (value)
 }
 
 static int
-sv_compquery (value)
-     const char *value;
+sv_compquery (const char *value)
 {
   int nval = 100;
 
@@ -1809,8 +1748,7 @@ sv_compquery (value)
 }
 
 static int
-sv_compwidth (value)
-     const char *value;
+sv_compwidth (const char *value)
 {
   int nval = -1;
 
@@ -1822,8 +1760,7 @@ sv_compwidth (value)
 }
 
 static int
-sv_histsize (value)
-     const char *value;
+sv_histsize (const char *value)
 {
   int nval;
 
@@ -1842,8 +1779,7 @@ sv_histsize (value)
 }
 
 static int
-sv_keymap (value)
-     const char *value;
+sv_keymap (const char *value)
 {
   Keymap kmap;
 
@@ -1857,8 +1793,7 @@ sv_keymap (value)
 }
 
 static int
-sv_seqtimeout (value)
-     const char *value;
+sv_seqtimeout (const char *value)
 {
   int nval;
 
@@ -1874,8 +1809,7 @@ sv_seqtimeout (value)
 }
 
 static int
-sv_bell_style (value)
-     const char *value;
+sv_bell_style (const char *value)
 {
   if (value == 0 || *value == '\0')
     _rl_bell_preference = AUDIBLE_BELL;
@@ -1891,8 +1825,7 @@ sv_bell_style (value)
 }
 
 static int
-sv_isrchterm (value)
-     const char *value;
+sv_isrchterm (const char *value)
 {
   int beg, end, delim;
   char *v;
@@ -1929,8 +1862,7 @@ sv_isrchterm (value)
 extern char *_rl_emacs_mode_str;
 
 static int
-sv_emacs_modestr (value)
-     const char *value;
+sv_emacs_modestr (const char *value)
 {
   if (value && *value)
     {
@@ -1958,8 +1890,7 @@ sv_emacs_modestr (value)
 }
 
 static int
-sv_viins_modestr (value)
-     const char *value;
+sv_viins_modestr (const char *value)
 {
   if (value && *value)
     {
@@ -1987,8 +1918,7 @@ sv_viins_modestr (value)
 }
 
 static int
-sv_vicmd_modestr (value)
-     const char *value;
+sv_vicmd_modestr (const char *value)
 {
   if (value && *value)
     {
@@ -2039,8 +1969,7 @@ static const assoc_list name_key_alist[] = {
 };
 
 static int
-glean_key_from_name (name)
-     char *name;
+glean_key_from_name (char *name)
 {
   register int i;
 
@@ -2070,8 +1999,7 @@ static const struct {
 };
 
 Keymap
-rl_get_keymap_by_name (name)
-     const char *name;
+rl_get_keymap_by_name (const char *name)
 {
   register int i;
 
@@ -2082,8 +2010,7 @@ rl_get_keymap_by_name (name)
 }
 
 char *
-rl_get_keymap_name (map)
-     Keymap map;
+rl_get_keymap_name (Keymap map)
 {
   register int i;
   for (i = 0; keymap_names[i].name; i++)
@@ -2093,21 +2020,20 @@ rl_get_keymap_name (map)
 }
   
 void
-rl_set_keymap (map)
-     Keymap map;
+rl_set_keymap (Keymap map)
 {
   if (map)
     _rl_keymap = map;
 }
 
 Keymap
-rl_get_keymap ()
+rl_get_keymap (void)
 {
   return (_rl_keymap);
 }
 
 void
-rl_set_keymap_from_edit_mode ()
+rl_set_keymap_from_edit_mode (void)
 {
   if (rl_editing_mode == emacs_mode)
     _rl_keymap = emacs_standard_keymap;
@@ -2118,7 +2044,7 @@ rl_set_keymap_from_edit_mode ()
 }
 
 char *
-rl_get_keymap_name_from_edit_mode ()
+rl_get_keymap_name_from_edit_mode (void)
 {
   if (rl_editing_mode == emacs_mode)
     return "emacs";
@@ -2143,7 +2069,7 @@ rl_get_keymap_name_from_edit_mode ()
 
 /* Print the names of functions known to Readline. */
 void
-rl_list_funmap_names ()
+rl_list_funmap_names (void)
 {
   register int i;
   const char **funmap_names;
@@ -2160,8 +2086,7 @@ rl_list_funmap_names ()
 }
 
 static char *
-_rl_get_keyname (key)
-     int key;
+_rl_get_keyname (int key)
 {
   char *keyname;
   int i, c;
@@ -2236,9 +2161,7 @@ _rl_get_keyname (key)
 /* Return a NULL terminated array of strings which represent the key
    sequences that are used to invoke FUNCTION in MAP. */
 char **
-rl_invoking_keyseqs_in_map (function, map)
-     rl_command_func_t *function;
-     Keymap map;
+rl_invoking_keyseqs_in_map (rl_command_func_t *function, Keymap map)
 {
   register int key;
   char **result;
@@ -2345,8 +2268,7 @@ rl_invoking_keyseqs_in_map (function, map)
 /* Return a NULL terminated array of strings which represent the key
    sequences that can be used to invoke FUNCTION using the current keymap. */
 char **
-rl_invoking_keyseqs (function)
-     rl_command_func_t *function;
+rl_invoking_keyseqs (rl_command_func_t *function)
 {
   return (rl_invoking_keyseqs_in_map (function, _rl_keymap));
 }
@@ -2355,8 +2277,7 @@ rl_invoking_keyseqs (function)
    PRINT_READABLY is non-zero, then print the output in such a way
    that it can be read back in. */
 void
-rl_function_dumper (print_readably)
-     int print_readably;
+rl_function_dumper (int print_readably)
 {
   register int i;
   const char **names;
@@ -2427,8 +2348,7 @@ rl_function_dumper (print_readably)
    rl_outstream.  If an explicit argument is given, then print
    the output in such a way that it can be read back in. */
 int
-rl_dump_functions (count, key)
-     int count, key;
+rl_dump_functions (int count, int key)
 {
   if (rl_dispatching)
     fprintf (rl_outstream, "\r\n");
@@ -2438,10 +2358,7 @@ rl_dump_functions (count, key)
 }
 
 static void
-_rl_macro_dumper_internal (print_readably, map, prefix)
-     int print_readably;
-     Keymap map;
-     char *prefix;
+_rl_macro_dumper_internal (int print_readably, Keymap map, char *prefix)
 {
   register int key;
   char *keyname, *out;
@@ -2500,15 +2417,13 @@ _rl_macro_dumper_internal (print_readably, map, prefix)
 }
 
 void
-rl_macro_dumper (print_readably)
-     int print_readably;
+rl_macro_dumper (int print_readably)
 {
   _rl_macro_dumper_internal (print_readably, _rl_keymap, (char *)NULL);
 }
 
 int
-rl_dump_macros (count, key)
-     int count, key;
+rl_dump_macros (int count, int key)
 {
   if (rl_dispatching)
     fprintf (rl_outstream, "\r\n");
@@ -2518,8 +2433,7 @@ rl_dump_macros (count, key)
 }
 
 static char *
-_rl_get_string_variable_value (name)
-     const char *name;
+_rl_get_string_variable_value (const char *name)
 {
   static char numbuf[32];
   char *ret;
@@ -2599,8 +2513,7 @@ _rl_get_string_variable_value (name)
 }
 
 void
-rl_variable_dumper (print_readably)
-     int print_readably;
+rl_variable_dumper (int print_readably)
 {
   int i;
   char *v;
@@ -2631,8 +2544,7 @@ rl_variable_dumper (print_readably)
    rl_outstream.  If an explicit argument is given, then print
    the output in such a way that it can be read back in. */
 int
-rl_dump_variables (count, key)
-     int count, key;
+rl_dump_variables (int count, int key)
 {
   if (rl_dispatching)
     fprintf (rl_outstream, "\r\n");
@@ -2643,9 +2555,7 @@ rl_dump_variables (count, key)
 
 /* Return non-zero if any members of ARRAY are a substring in STRING. */
 static int
-substring_member_of_array (string, array)
-     const char *string;
-     const char * const *array;
+substring_member_of_array (const char *string, const char * const *array)
 {
   while (*array)
     {
diff --git a/callback.c b/callback.c
index cc3ce11..a466cf9 100644
--- a/callback.c
+++ b/callback.c
@@ -1,6 +1,6 @@
 /* callback.c -- functions to use readline as an X `callback' mechanism. */
 
-/* Copyright (C) 1987-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 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.
@@ -60,7 +60,7 @@ int rl_persistent_signal_handlers = 0;
 
 /* **************************************************************** */
 /*								    */
-/*			Callback Readline Functions		 */
+/*			Callback Readline Functions		    */
 /*								    */
 /* **************************************************************** */
 
@@ -80,7 +80,7 @@ static int in_handler;		/* terminal_prepped and signals set? */
 
 /* Make sure the terminal is set up, initialize readline, and prompt. */
 static void
-_rl_callback_newline ()
+_rl_callback_newline (void)
 {
   rl_initialize ();
 
@@ -103,9 +103,7 @@ _rl_callback_newline ()
 
 /* Install a readline handler, set up the terminal, and issue the prompt. */
 void
-rl_callback_handler_install (prompt, linefunc)
-     const char *prompt;
-     rl_vcpfunc_t *linefunc;
+rl_callback_handler_install (const char *prompt, rl_vcpfunc_t *linefunc)
 {
   rl_set_prompt (prompt);
   RL_SETSTATE (RL_STATE_CALLBACK);
@@ -126,7 +124,7 @@ rl_callback_handler_install (prompt, linefunc)
 
 /* Read one character, and dispatch to the handler if it ends the line. */
 void
-rl_callback_read_char ()
+rl_callback_read_char (void)
 {
   char *line;
   int eof, jcode;
@@ -299,7 +297,7 @@ rl_callback_read_char ()
 
 /* Remove the handler, and make sure the terminal is in its normal state. */
 void
-rl_callback_handler_remove ()
+rl_callback_handler_remove (void)
 {
   rl_linefunc = NULL;
   RL_UNSETSTATE (RL_STATE_CALLBACK);
@@ -316,8 +314,7 @@ rl_callback_handler_remove ()
 }
 
 _rl_callback_generic_arg *
-_rl_callback_data_alloc (count)
-     int count;
+_rl_callback_data_alloc (int count)
 {
   _rl_callback_generic_arg *arg;
 
@@ -330,15 +327,14 @@ _rl_callback_data_alloc (count)
 }
 
 void
-_rl_callback_data_dispose (arg)
-     _rl_callback_generic_arg *arg;
+_rl_callback_data_dispose (_rl_callback_generic_arg *arg)
 {
   xfree (arg);
 }
 
 /* Make sure that this agrees with cases in rl_callback_read_char */
 void
-rl_callback_sigcleanup ()
+rl_callback_sigcleanup (void)
 {
   if (RL_ISSTATE (RL_STATE_CALLBACK) == 0)
     return;
diff --git a/colors.c b/colors.c
index 5d450ee..53758e0 100644
--- a/colors.c
+++ b/colors.c
@@ -2,7 +2,7 @@
 
    Modified by Chet Ramey for Readline.
 
-   Copyright (C) 1985, 1988, 1990-1991, 1995-2010, 2012, 2015
+   Copyright (C) 1985, 1988, 1990-1991, 1995-2010, 2012, 2015, 2017
    Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
@@ -70,7 +70,8 @@ COLOR_EXT_TYPE *_rl_color_ext_list = 0;
 
 /* Output a color indicator (which may contain nulls).  */
 void
-_rl_put_indicator (const struct bin_str *ind) {
+_rl_put_indicator (const struct bin_str *ind)
+{
   fwrite (ind->string, ind->len, 1, rl_outstream);
 }
 
diff --git a/compat.c b/compat.c
index 2af5120..3ade362 100644
--- a/compat.c
+++ b/compat.c
@@ -1,6 +1,6 @@
 /* compat.c -- backwards compatibility functions. */
 
-/* Copyright (C) 2000-2009 Free Software Foundation, Inc.
+/* Copyright (C) 2000-2017 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.
@@ -46,68 +46,61 @@ extern char *rl_filename_completion_function PARAMS((const char *, int));
 /* Provide backwards-compatible entry points for old function names. */
 
 void
-free_undo_list ()
+free_undo_list (void)
 {
   rl_free_undo_list ();
 }
 
 int
-maybe_replace_line ()
+maybe_replace_line (void)
 {
   return rl_maybe_replace_line ();
 }
 
 int
-maybe_save_line ()
+maybe_save_line (void)
 {
   return rl_maybe_save_line ();
 }
 
 int
-maybe_unsave_line ()
+maybe_unsave_line (void)
 {
   return rl_maybe_unsave_line ();
 }
 
 int
-ding ()
+ding (void)
 {
   return rl_ding ();
 }
 
 int
-crlf ()
+crlf (void)
 {
   return rl_crlf ();
 }
 
 int
-alphabetic (c)
-     int c;
+alphabetic (int c)
 {
   return rl_alphabetic (c);
 }
 
 char **
-completion_matches (s, f)
-     const char *s;
-     rl_compentry_func_t *f;
+completion_matches (const char *s, rl_compentry_func_t *f)
 {
   return rl_completion_matches (s, f);
 }
 
 char *
-username_completion_function (s, i)
-     const char *s;
-     int i;
+username_completion_function (const char *s, int i)
 {
   return rl_username_completion_function (s, i);
 }
 
 char *
-filename_completion_function (s, i)
-     const char *s;
-     int i;
+filename_completion_function (const char *s, int i)
 {
   return rl_filename_completion_function (s, i);
 }
diff --git a/complete.c b/complete.c
index 1d79dcb..662a19d 100644
--- a/complete.c
+++ b/complete.c
@@ -1,6 +1,6 @@
 /* complete.c -- filename completion for readline. */
 
-/* Copyright (C) 1987-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 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.
@@ -198,15 +198,6 @@ int _rl_completion_prefix_display_length = 0;
    matches.  If < 0 or > _rl_screenwidth, it is ignored. */
 int _rl_completion_columns = -1;
 
-/* Global variables available to applications using readline. */
-
-#if defined (VISIBLE_STATS)
-/* Non-zero means add an additional character to each filename displayed
-   during listing completion iff rl_filename_completion_desired which helps
-   to indicate the type of file being listed. */
-int rl_visible_stats = 0;
-#endif /* VISIBLE_STATS */
-
 #if defined (COLOR_SUPPORT)
 /* Non-zero means to use colors to indicate file type when listing possible
    completions.  The colors used are taken from $LS_COLORS, if set. */
@@ -227,6 +218,15 @@ int _rl_skip_completed_text = 0;
    cycle of possible completions instead of the last. */
 int _rl_menu_complete_prefix_first = 0;
 
+/* Global variables available to applications using readline. */
+
+#if defined (VISIBLE_STATS)
+/* Non-zero means add an additional character to each filename displayed
+   during listing completion iff rl_filename_completion_desired which helps
+   to indicate the type of file being listed. */
+int rl_visible_stats = 0;
+#endif /* VISIBLE_STATS */
+
 /* If non-zero, then this is the address of a function to call when
    completing on a directory name.  The function is called with
    the address of a string (the current directory name) as an arg. */
@@ -422,8 +422,7 @@ static int _rl_complete_display_matches_interrupt = 0;
    that does the initial simple matching selection algorithm (see
    rl_completion_matches ()).  The default is to do filename completion. */
 int
-rl_complete (ignore, invoking_key)
-     int ignore, invoking_key;
+rl_complete (int ignore, int invoking_key)
 {
   rl_completion_invoking_key = invoking_key;
 
@@ -441,16 +440,14 @@ rl_complete (ignore, invoking_key)
 
 /* List the possible completions.  See description of rl_complete (). */
 int
-rl_possible_completions (ignore, invoking_key)
-     int ignore, invoking_key;
+rl_possible_completions (int ignore, int invoking_key)
 {
   rl_completion_invoking_key = invoking_key;
   return (rl_complete_internal ('?'));
 }
 
 int
-rl_insert_completions (ignore, invoking_key)
-     int ignore, invoking_key;
+rl_insert_completions (int ignore, int invoking_key)
 {
   rl_completion_invoking_key = invoking_key;
   return (rl_complete_internal ('*'));
@@ -462,8 +459,7 @@ rl_insert_completions (ignore, invoking_key)
    an application-specific completion function to honor the
    show-all-if-ambiguous readline variable. */
 int
-rl_completion_mode (cfunc)
-     rl_command_func_t *cfunc;
+rl_completion_mode (rl_command_func_t *cfunc)
 {
   if (rl_last_func == cfunc && !completion_changed_buffer)
     return '?';
@@ -483,16 +479,14 @@ rl_completion_mode (cfunc)
 
 /* Reset readline state on a signal or other event. */
 void
-_rl_reset_completion_state ()
+_rl_reset_completion_state (void)
 {
   rl_completion_found_quote = 0;
   rl_completion_quote_character = 0;
 }
 
 static void
-_rl_complete_sigcleanup (sig, ptr)
-     int sig;
-     void *ptr;
+_rl_complete_sigcleanup (int sig, void *ptr)
 {
   if (sig == SIGINT)	/* XXX - for now */
     {
@@ -504,8 +498,7 @@ _rl_complete_sigcleanup (sig, ptr)
 /* Set default values for readline word completion.  These are the variables
    that application completion functions can change or inspect. */
 static void
-set_completion_defaults (what_to_do)
-     int what_to_do;
+set_completion_defaults (int what_to_do)
 {
   /* Only the completion entry function can change these. */
   rl_filename_completion_desired = 0;
@@ -523,8 +516,7 @@ set_completion_defaults (what_to_do)
 
 /* The user must press "y" or "n". Non-zero return means "y" pressed. */
 static int
-get_y_or_n (for_pager)
-     int for_pager;
+get_y_or_n (int for_pager)
 {
   int c;
 
@@ -557,8 +549,7 @@ get_y_or_n (for_pager)
 }
 
 static int
-_rl_internal_pager (lines)
-     int lines;
+_rl_internal_pager (int lines)
 {
   int i;
 
@@ -575,8 +566,7 @@ _rl_internal_pager (lines)
 }
 
 static int
-path_isdir (filename)
-     const char *filename;
+path_isdir (const char *filename)
 {
   struct stat finfo;
 
@@ -593,8 +583,7 @@ path_isdir (filename)
      `%' for character special devices
      `#' for block special devices */
 static int
-stat_char (filename)
-     char *filename;
+stat_char (char *filename)
 {
   struct stat finfo;
   int character, r;
@@ -678,29 +667,28 @@ stat_char (filename)
 
 #if defined (COLOR_SUPPORT)
 static int
-colored_stat_start (filename)
-     const char *filename;
+colored_stat_start (const char *filename)
 {
   _rl_set_normal_color ();
   return (_rl_print_color_indicator (filename));
 }
 
 static void
-colored_stat_end ()
+colored_stat_end (void)
 {
   _rl_prep_non_filename_text ();
   _rl_put_indicator (&_rl_color_indicator[C_CLR_TO_EOL]);
 }
 
 static int
-colored_prefix_start ()
+colored_prefix_start (void)
 {
   _rl_set_normal_color ();
   return (_rl_print_prefix_color ());
 }
 
 static void
-colored_prefix_end ()
+colored_prefix_end (void)
 {
   colored_stat_end ();		/* for now */
 }
@@ -715,8 +703,7 @@ colored_prefix_end ()
    for the previous slash and return the portion following that.  If
    there's no previous slash, we just return what we were passed. */
 static char *
-printable_part (pathname)
-      char *pathname;
+printable_part (char *pathname)
 {
   char *temp, *x;
 
@@ -750,8 +737,7 @@ printable_part (pathname)
 
 /* Compute width of STRING when displayed on screen by print_filename */
 static int
-fnwidth (string)
-     const char *string;
+fnwidth (const char *string)
 {
   int width, pos;
 #if defined (HANDLE_MULTIBYTE)
@@ -803,10 +789,7 @@ fnwidth (string)
 #define ELLIPSIS_LEN	3
 
 static int
-fnprint (to_print, prefix_bytes, real_pathname)
-     const char *to_print;
-     int prefix_bytes;
-     const char *real_pathname;
+fnprint (const char *to_print, int prefix_bytes, const char *real_pathname)
 {
   int printed_len, w;
   const char *s;
@@ -932,9 +915,7 @@ fnprint (to_print, prefix_bytes, real_pathname)
    filenames.  Return the number of characters we output. */
 
 static int
-print_filename (to_print, full_pathname, prefix_bytes)
-     char *to_print, *full_pathname;
-     int prefix_bytes;
+print_filename (char *to_print, char *full_pathname, int prefix_bytes)
 {
   int printed_len, extension_char, slen, tlen;
   char *s, c, *new_full_pathname, *dn;
@@ -991,7 +972,6 @@ print_filename (to_print, full_pathname, prefix_bytes)
 	    slen--;
 	  else
 	    new_full_pathname[slen] = '/';
-	  new_full_pathname[slen] = '/';
 	  strcpy (new_full_pathname + slen + 1, to_print);
 
 #if defined (VISIBLE_STATS)
@@ -1052,10 +1032,7 @@ print_filename (to_print, full_pathname, prefix_bytes)
 }
 
 static char *
-rl_quote_filename (s, rtype, qcp)
-     char *s;
-     int rtype;
-     char *qcp;
+rl_quote_filename (char *s, int rtype, char *qcp)
 {
   char *r;
 
@@ -1083,8 +1060,7 @@ rl_quote_filename (s, rtype, qcp)
    the value of the delimiter character that caused a word break. */
 
 char
-_rl_find_completion_word (fp, dp)
-     int *fp, *dp;
+_rl_find_completion_word (int *fp, int *dp)
 {
   int scan, end, found_quote, delimiter, pass_next, isbrk;
   char quote_char, *brkchars;
@@ -1216,11 +1192,7 @@ _rl_find_completion_word (fp, dp)
 }
 
 static char **
-gen_completion_matches (text, start, end, our_func, found_quote, quote_char)
-     char *text;
-     int start, end;
-     rl_compentry_func_t *our_func;
-     int found_quote, quote_char;
+gen_completion_matches (char *text, int start, int end, rl_compentry_func_t *our_func, int found_quote, int quote_char)
 {
   char **matches;
 
@@ -1264,8 +1236,7 @@ gen_completion_matches (text, start, end, our_func, found_quote, quote_char)
 /* Filter out duplicates in MATCHES.  This frees up the strings in
    MATCHES. */
 static char **
-remove_duplicate_matches (matches)
-     char **matches;
+remove_duplicate_matches (char **matches)
 {
   char *lowest_common;
   int i, j, newlen;
@@ -1325,10 +1296,7 @@ remove_duplicate_matches (matches)
 /* Find the common prefix of the list of matches, and put it into
    matches[0]. */
 static int
-compute_lcd_of_matches (match_list, matches, text)
-     char **match_list;
-     int matches;
-     const char *text;
+compute_lcd_of_matches (char **match_list, int matches, const char *text)
 {
   register int i, c1, c2, si;
   int low;		/* Count of max-matched characters. */
@@ -1454,7 +1422,8 @@ compute_lcd_of_matches (match_list, matches, text)
 	    }
 
 	  /* sort the list to get consistent answers. */
-	  qsort (match_list+1, matches, sizeof(char *), (QSFUNC *)_rl_qsort_string_compare);
+	  if (rl_sort_completion_matches)
+	    qsort (match_list+1, matches, sizeof(char *), (QSFUNC *)_rl_qsort_string_compare);
 
 	  si = strlen (text);
 	  lx = (si <= low) ? si : low;	/* check shorter of text and matches */
@@ -1484,9 +1453,7 @@ compute_lcd_of_matches (match_list, matches, text)
 }
 
 static int
-postprocess_matches (matchesp, matching_filenames)
-     char ***matchesp;
-     int matching_filenames;
+postprocess_matches (char ***matchesp, int matching_filenames)
 {
   char *t, **matches, **temp_matches;
   int nmatch, i;
@@ -1540,7 +1507,7 @@ postprocess_matches (matchesp, matching_filenames)
 }
 
 static int
-complete_get_screenwidth ()
+complete_get_screenwidth (void)
 {
   int cols;
   char *envcols;
@@ -1561,9 +1528,7 @@ complete_get_screenwidth ()
    of strings, in argv format, LEN is the number of strings in MATCHES,
    and MAX is the length of the longest string in MATCHES. */
 void
-rl_display_match_list (matches, len, max)
-     char **matches;
-     int len, max;
+rl_display_match_list (char **matches, int len, int max)
 {
   int count, limit, printed_len, lines, cols;
   int i, j, k, l, common_length, sind;
@@ -1720,8 +1685,7 @@ rl_display_match_list (matches, len, max)
    and ask the user if he wants to see the list if there are more matches
    than RL_COMPLETION_QUERY_ITEMS. */
 static void
-display_matches (matches)
-     char **matches;
+display_matches (char **matches)
 {
   int len, max, i;
   char *temp;
@@ -1787,11 +1751,9 @@ display_matches (matches)
   rl_display_fixed = 1;
 }
 
+/* qc == pointer to quoting character, if any */
 static char *
-make_quoted_replacement (match, mtype, qc)
-     char *match;
-     int mtype;
-     char *qc;	/* Pointer to quoting character, if any */
+make_quoted_replacement (char *match, int mtype, char *qc)
 {
   int should_quote, do_replace;
   char *replacement;
@@ -1833,10 +1795,7 @@ make_quoted_replacement (match, mtype, qc)
 }
 
 static void
-insert_match (match, start, mtype, qc)
-     char *match;
-     int start, mtype;
-     char *qc;
+insert_match (char *match, int start, int mtype, char *qc)
 {
   char *replacement, *r;
   char oqc;
@@ -1893,9 +1852,7 @@ insert_match (match, start, mtype, qc)
    value of _rl_complete_mark_symlink_dirs, but may be modified by an
    application's completion function). */
 static int
-append_to_match (text, delimiter, quote_char, nontrivial_match)
-     char *text;
-     int delimiter, quote_char, nontrivial_match;
+append_to_match (char *text, int delimiter, int quote_char, int nontrivial_match)
 {
   char temp_string[4], *filename, *fn;
   int temp_string_index, s;
@@ -1962,10 +1919,7 @@ append_to_match (text, delimiter, quote_char, nontrivial_match)
 }
 
 static void
-insert_all_matches (matches, point, qc)
-     char **matches;
-     int point;
-     char *qc;
+insert_all_matches (char **matches, int point, char *qc)
 {
   int i;
   char *rp;
@@ -2001,8 +1955,7 @@ insert_all_matches (matches, point, qc)
 }
 
 void
-_rl_free_match_list (matches)
-     char **matches;
+_rl_free_match_list (char **matches)
 {
   register int i;
 
@@ -2024,17 +1977,14 @@ _rl_free_match_list (matches)
    `@' means to do standard completion, and list all possible completions if
    there is more than one and partial completion is not possible. */
 int
-rl_complete_internal (what_to_do)
-     int what_to_do;
+rl_complete_internal (int what_to_do)
 {
   char **matches;
   rl_compentry_func_t *our_func;
   int start, end, delimiter, found_quote, i, nontrivial_lcd;
   char *text, *saved_line_buffer;
   char quote_char;
-#if 1
   int tlen, mlen;
-#endif
 
   RL_SETSTATE(RL_STATE_COMPLETING);
 
@@ -2209,9 +2159,7 @@ rl_complete_internal (what_to_do)
      when there are no more matches.
  */
 char **
-rl_completion_matches (text, entry_function)
-     const char *text;
-     rl_compentry_func_t *entry_function;
+rl_completion_matches (const char *text, rl_compentry_func_t *entry_function)
 {
   register int i;
 
@@ -2279,9 +2227,7 @@ rl_completion_matches (text, entry_function)
    TEXT contains a partial username preceded by a random
    character (usually `~').  */
 char *
-rl_username_completion_function (text, state)
-     const char *text;
-     int state;
+rl_username_completion_function (const char *text, int state)
 {
 #if defined (__WIN32__) || defined (__OPENNT)
   return (char *)NULL;
@@ -2343,11 +2289,7 @@ rl_username_completion_function (text, state)
    _rl_completion_case_map is set, make `-' and `_' equivalent.  CONVFN is
    the possibly-converted directory entry; FILENAME is what the user typed. */
 static int
-complete_fncmp (convfn, convlen, filename, filename_len)
-     const char *convfn;
-     int convlen;
-     const char *filename;
-     int filename_len;
+complete_fncmp (const char *convfn, int convlen, const char *filename, int filename_len)
 {
   register char *s1, *s2;
   int d, len;
@@ -2475,9 +2417,7 @@ complete_fncmp (convfn, convlen, filename, filename_len)
    because of all the pathnames that must be followed when looking up the
    completion for a command. */
 char *
-rl_filename_completion_function (text, state)
-     const char *text;
-     int state;
+rl_filename_completion_function (const char *text, int state)
 {
   static DIR *directory = (DIR *)NULL;
   static char *filename = (char *)NULL;
@@ -2705,8 +2645,7 @@ rl_filename_completion_function (text, state)
    hit the end of the match list, we restore the original unmatched text,
    ring the bell, and reset the counter to zero. */
 int
-rl_old_menu_complete (count, invoking_key)
-     int count, invoking_key;
+rl_old_menu_complete (int count, int invoking_key)
 {
   rl_compentry_func_t *our_func;
   int matching_filenames, found_quote;
@@ -2827,9 +2766,17 @@ rl_old_menu_complete (count, invoking_key)
   return (0);
 }
 
+/* The current version of menu completion.
+   The differences between this function and the original are:
+
+1. It honors the maximum number of completions variable (completion-query-items)
+2. It appends to the word as usual if there is only one match
+3. It displays the common prefix if there is one, and makes it the first menu
+   choice if the menu-complete-display-prefix option is enabled
+*/
+ 
 int
-rl_menu_complete (count, ignore)
-     int count, ignore;
+rl_menu_complete (int count, int ignore)
 {
   rl_compentry_func_t *our_func;
   int matching_filenames, found_quote;
@@ -3001,8 +2948,7 @@ rl_menu_complete (count, ignore)
 }
 
 int
-rl_backward_menu_complete (count, key)
-     int count, key;
+rl_backward_menu_complete (int count, int key)
 {
   /* Positive arguments to backward-menu-complete translate into negative
      arguments for menu-complete, and vice versa. */
diff --git a/display.c b/display.c
index 0e0d44c..35c0949 100644
--- a/display.c
+++ b/display.c
@@ -1,6 +1,6 @@
 /* display.c -- readline redisplay facility. */
 
-/* Copyright (C) 1987-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 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.
@@ -158,9 +158,6 @@ rl_voidfunc_t *rl_redisplay_function = rl_redisplay;
 /* What YOU turn on when you have handled all redisplay yourself. */
 int rl_display_fixed = 0;
 
-int _rl_suppress_redisplay = 0;
-int _rl_want_redisplay = 0;
-
 /* The stuff that gets printed out before the actual text of the line.
    This is usually pointing to rl_prompt. */
 char *rl_display_prompt = (char *)NULL;
@@ -177,6 +174,10 @@ int _rl_vi_cmd_modestr_len;
 
 /* Pseudo-global variables declared here. */
 
+/* Hints for other parts of readline to give to the display engine. */
+int _rl_suppress_redisplay = 0;
+int _rl_want_redisplay = 0;
+
 /* The visible cursor position.  If you print some text, adjust this. */
 /* NOTE: _rl_last_c_pos is used as a buffer index when not in a locale
    supporting multibyte characters, and an absolute cursor position when
@@ -185,14 +186,24 @@ int _rl_vi_cmd_modestr_len;
 int _rl_last_c_pos = 0;
 int _rl_last_v_pos = 0;
 
+/* Number of physical lines consumed by the current line buffer currently
+  on screen minus 1. */
+int _rl_vis_botlin = 0;
+
+/* This is a hint update_line gives to rl_redisplay that it has adjusted the
+   value of _rl_last_c_pos *and* taken the presence of any invisible chars in
+   the prompt into account.  rl_redisplay notes this and does not do the
+   adjustment itself. */
 static int cpos_adjusted;
+
+/* The index into the line buffer corresponding to the cursor position */
 static int cpos_buffer_position;
+
+/* A flag to note when we're displaying the first line of the prompt */
 static int displaying_prompt_first_line;
+/* The number of multibyte characters in the prompt, if any */
 static int prompt_multibyte_chars;
 
-/* Number of lines currently on screen minus 1. */
-int _rl_vis_botlin = 0;
-
 static int _rl_inv_botlin = 0;
 
 /* Variables used only in this file. */
@@ -215,7 +226,11 @@ static int line_size = 1024;
 
 static char *local_prompt, *local_prompt_prefix;
 static int local_prompt_len;
-static int prompt_visible_length, prompt_prefix_length;
+static int prompt_prefix_length;
+/* Number of chars in the buffer that contribute to visible chars on the screen.
+   This might be different from the number of physical chars in the presence
+   of multibyte characters */
+static int prompt_visible_length;
 
 /* The number of invisible characters in the line currently being
    displayed on the screen. */
@@ -241,6 +256,12 @@ static int prompt_last_screen_line;
 
 static int prompt_physical_chars;
 
+/* An array of indexes into the prompt string where we will break physical
+   screen lines.  It's easier to compute in expand_prompt and use later in
+   rl_redisplay instead of having rl_redisplay try to guess about invisible
+   characters in the prompt or use heuristics about where they are. */
+static int *local_prompt_newlines;
+
 /* set to a non-zero value by rl_redisplay if we are marking modified history
    lines and the current line is so marked. */
 static int modmark;
@@ -251,6 +272,8 @@ static int modmark;
 
 static char *saved_local_prompt;
 static char *saved_local_prefix;
+static int *saved_local_prompt_newlines;
+
 static int saved_last_invisible;
 static int saved_visible_length;
 static int saved_prefix_length;
@@ -261,8 +284,7 @@ static int saved_physical_chars;
 /* Return a string indicating the editing mode, for use in the prompt. */
 
 static char *
-prompt_modestr (lenp)
-     int *lenp;
+prompt_modestr (int *lenp)
 {
   if (rl_editing_mode == emacs_mode)
     {
@@ -290,7 +312,8 @@ prompt_modestr (lenp)
    index of the last invisible character in the returned string. NIFLP,
    if non-zero, is a place to store the number of invisible characters in
    the first prompt line.  The previous are used as byte counts -- indexes
-   into a character buffer. */
+   into a character buffer.  *VLP gets the number of physical characters in
+   the expanded prompt (visible length) */
 
 /* Current implementation:
 	\001 (^A) start non-visible characters
@@ -303,15 +326,16 @@ prompt_modestr (lenp)
 	PMT_MULTILINE	caller indicates that this is part of a multiline prompt
 */
 
+/* This approximates the number of lines the prompt will take when displayed */
+#define APPROX_DIV(n, d)	(((n) < (d)) ? 1 : ((n) / (d)) + 1)
+
 static char *
-expand_prompt (pmt, flags, lp, lip, niflp, vlp)
-     char *pmt;
-     int flags;
-     int *lp, *lip, *niflp, *vlp;
+expand_prompt (char *pmt, int flags, int *lp, int *lip, int *niflp, int *vlp)
 {
   char *r, *ret, *p, *igstart, *nprompt, *ms;
   int l, rl, last, ignoring, ninvis, invfl, invflset, ind, pind, physchars;
-  int mlen;
+  int mlen, newlines, newlines_guess, bound;
+  int mb_cur_max;
 
   /* We only expand the mode string for the last line of a multiline prompt
      (a prompt with embedded newlines). */
@@ -326,29 +350,54 @@ expand_prompt (pmt, flags, lp, lip, niflp, vlp)
   else
     nprompt = pmt;
 
-  /* Short-circuit if we can. */
-  if ((MB_CUR_MAX <= 1 || rl_byte_oriented) && strchr (nprompt, RL_PROMPT_START_IGNORE) == 0)
+  mb_cur_max = MB_CUR_MAX;
+
+  if (_rl_screenwidth == 0)
+    _rl_get_screen_size (0, 0);	/* avoid division by zero */
+
+  /* Short-circuit if we can.  We can do this if we are treating the prompt as
+     a sequence of bytes and there are no invisible characters in the prompt
+     to deal with. Since we populate local_prompt_newlines, we have to run
+     through the rest of the function if this prompt looks like it's going to
+     be longer than one screen line. */
+  if ((mb_cur_max <= 1 || rl_byte_oriented) && strchr (nprompt, RL_PROMPT_START_IGNORE) == 0)
     {
-      r = (nprompt == pmt) ? savestring (pmt) : nprompt;
+      l = strlen (nprompt);
+      if (l < (_rl_screenwidth > 0 ? _rl_screenwidth : 80))
+        {
+	  r = (nprompt == pmt) ? savestring (pmt) : nprompt;
+	  if (lp)
+	    *lp = l;
+	  if (lip)
+	    *lip = 0;
+	  if (niflp)
+	    *niflp = 0;
+	  if (vlp)
+	    *vlp = l;
 
-      if (lp)
-	*lp = strlen (r);
-      if (lip)
-	*lip = 0;
-      if (niflp)
-	*niflp = 0;
-      if (vlp)
-	*vlp = lp ? *lp : strlen (r);
-      return r;
+	  local_prompt_newlines = (int *) xrealloc (local_prompt_newlines, sizeof (int) * 2);
+	  local_prompt_newlines[0] = 0;
+	  local_prompt_newlines[1] = -1;
+
+	  return r;
+        }
     }
 
   l = strlen (nprompt);			/* XXX */
   r = ret = (char *)xmalloc (l + 1);
 
+  /* Guess at how many screen lines the prompt will take to size the array that
+     keeps track of where the line wraps happen */
+  newlines_guess = (_rl_screenwidth > 0) ? APPROX_DIV(l,  _rl_screenwidth) : APPROX_DIV(l, 80);
+  local_prompt_newlines = (int *) xrealloc (local_prompt_newlines, sizeof (int) * (newlines_guess + 1));
+  local_prompt_newlines[newlines = 0] = 0;
+  for (rl = 1; rl <= newlines_guess; rl++)
+    local_prompt_newlines[rl] = -1;
+
   rl = physchars = 0;	/* mode string now part of nprompt */
-  invfl = 0;	/* invisible chars in first line of prompt */
-  invflset = 0;	/* we only want to set invfl once */
-  igstart = 0;
+  invfl = 0;		/* invisible chars in first line of prompt */
+  invflset = 0;		/* we only want to set invfl once */
+  igstart = 0;		/* we're not ignoring any characters yet */
 
   for (ignoring = last = ninvis = 0, p = nprompt; p && *p; p++)
     {
@@ -370,7 +419,7 @@ expand_prompt (pmt, flags, lp, lip, niflp, vlp)
       else
 	{
 #if defined (HANDLE_MULTIBYTE)
-	  if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
+	  if (mb_cur_max > 1 && rl_byte_oriented == 0)
 	    {
 	      pind = p - nprompt;
 	      ind = _rl_find_next_mbchar (nprompt, pind, 1, MB_FIND_NONZERO);
@@ -404,11 +453,28 @@ expand_prompt (pmt, flags, lp, lip, niflp, vlp)
 		ninvis++;		/* invisible chars byte counter */
 	    }
 
-	  if (invflset == 0 && rl >= _rl_screenwidth)
+	  if (invflset == 0 && physchars >= _rl_screenwidth)
 	    {
 	      invfl = ninvis;
 	      invflset = 1;
 	    }
+
+	  if (physchars >= (bound = (newlines + 1) * _rl_screenwidth) && local_prompt_newlines[newlines+1] == -1)
+	    {
+	      int new;
+	      if (physchars > bound)		/* should rarely happen */
+		{
+#if defined (HANDLE_MULTIBYTE)
+		  if (mb_cur_max > 1 && rl_byte_oriented == 0)
+		    new = _rl_find_prev_mbchar (ret, r - ret, MB_FIND_ANY);
+		  else
+#endif
+		    new = r - ret - (physchars - bound);	/* XXX */
+		}
+	      else
+	        new = r - ret;
+	      local_prompt_newlines[++newlines] = new;
+	    }
 	}
     }
 
@@ -434,8 +500,7 @@ expand_prompt (pmt, flags, lp, lip, niflp, vlp)
 /* Just strip out RL_PROMPT_START_IGNORE and RL_PROMPT_END_IGNORE from
    PMT and return the rest of PMT. */
 char *
-_rl_strip_prompt (pmt)
-     char *pmt;
+_rl_strip_prompt (char *pmt)
 {
   char *ret;
 
@@ -444,7 +509,7 @@ _rl_strip_prompt (pmt)
 }
 
 void
-_rl_reset_prompt ()
+_rl_reset_prompt (void)
 {
   rl_visible_prompt_length = rl_expand_prompt (rl_prompt);
 }
@@ -460,15 +525,20 @@ _rl_reset_prompt ()
  * prompt_visible_length = number of visible characters in local_prompt
  * prompt_prefix_length = number of visible characters in local_prompt_prefix
  *
+ * It also tries to keep track of the number of invisible characters in the
+ * prompt string, and where they are.
+ *
  * This function is called once per call to readline().  It may also be
  * called arbitrarily to expand the primary prompt.
  *
  * The return value is the number of visible characters on the last line
- * of the (possibly multi-line) prompt.
+ * of the (possibly multi-line) prompt.  In this case, multi-line means
+ * there are embedded newlines in the prompt string itself, not that the
+ * number of physical characters exceeds the screen width and the prompt
+ * wraps.
  */
 int
-rl_expand_prompt (prompt)
-     char *prompt;
+rl_expand_prompt (char *prompt)
 {
   char *p, *t;
   int c;
@@ -526,8 +596,7 @@ rl_expand_prompt (prompt)
    increased.  If the lines have already been allocated, this ensures that
    they can hold at least MINSIZE characters. */
 static void
-init_line_structures (minsize)
-      int minsize;
+init_line_structures (int minsize)
 {
   register int n;
 
@@ -574,9 +643,9 @@ init_line_structures (minsize)
   line_structures_initialized = 1;
 }
   
-/* Basic redisplay algorithm. */
+/* Basic redisplay algorithm.  See comments inline. */
 void
-rl_redisplay ()
+rl_redisplay (void)
 {
   register int in, out, c, linenum, cursor_linenum;
   register char *line;
@@ -637,6 +706,10 @@ rl_redisplay ()
      one passed to readline()), use the values we have already expanded.
      If not, use what's already in rl_display_prompt.  WRAP_OFFSET is the
      number of non-visible characters in the prompt string. */
+  /* This is where we output the characters in the prompt before the last
+     newline, if any.  If there aren't any embedded newlines, we don't
+     write anything. Copy the last line of the prompt string into the line in
+     any case */
   if (rl_display_prompt == rl_prompt || local_prompt)
     {
       if (local_prompt_prefix && forced_display)
@@ -691,6 +764,7 @@ rl_redisplay ()
       wrap_offset = prompt_invis_chars_first_line = 0;
     }
 
+#if defined (HANDLE_MULTIBYTE)
 #define CHECK_INV_LBREAKS() \
       do { \
 	if (newlines >= (inv_lbsize - 2)) \
@@ -698,7 +772,22 @@ rl_redisplay ()
 	    inv_lbsize *= 2; \
 	    inv_lbreaks = (int *)xrealloc (inv_lbreaks, inv_lbsize * sizeof (int)); \
 	  } \
+	if (newlines >= (line_state_invisible->wbsize - 2)) \
+	  { \
+	    line_state_invisible->wbsize *= 2; \
+	    line_state_invisible->wrapped_line = (int *)xrealloc (line_state_invisible->wrapped_line, line_state_invisible->wbsize * sizeof(int)); \
+	  } \
       } while (0)
+#else
+#define CHECK_INV_LBREAKS() \
+      do { \
+	if (newlines >= (inv_lbsize - 2)) \
+	  { \
+	    inv_lbsize *= 2; \
+	    inv_lbreaks = (int *)xrealloc (inv_lbreaks, inv_lbsize * sizeof (int)); \
+	  } \
+      } while (0)
+#endif /* !HANDLE_MULTIBYTE */
 
 #if defined (HANDLE_MULTIBYTE)	  
 #define CHECK_LPOS() \
@@ -712,7 +801,7 @@ rl_redisplay ()
 		inv_lbreaks = (int *)xrealloc (inv_lbreaks, inv_lbsize * sizeof (int)); \
 	      } \
 	    inv_lbreaks[++newlines] = out; \
-	    if (newlines >= (line_state_invisible->wbsize - 1)) \
+	    if (newlines >= (line_state_invisible->wbsize - 2)) \
 	      { \
 		line_state_invisible->wbsize *= 2; \
 		line_state_invisible->wrapped_line = (int *)xrealloc (line_state_invisible->wrapped_line, line_state_invisible->wbsize * sizeof(int)); \
@@ -741,7 +830,10 @@ rl_redisplay ()
   /* inv_lbreaks[i] is where line i starts in the buffer. */
   inv_lbreaks[newlines = 0] = 0;
   /* lpos is a physical cursor position, so it needs to be adjusted by the
-     number of invisible characters in the prompt, per line */
+     number of invisible characters in the prompt, per line.  We compute
+     the line breaks in the prompt string in expand_prompt, taking invisible
+     characters into account, and if lpos exceeds the screen width, we copy
+     the data in the loop below. */
   lpos = prompt_physical_chars + modmark;
 
 #if defined (HANDLE_MULTIBYTE)
@@ -751,90 +843,38 @@ rl_redisplay ()
 
   /* prompt_invis_chars_first_line is the number of invisible characters in
      the first physical line of the prompt.
-     wrap_offset - prompt_invis_chars_first_line is the number of invis
-     chars on the second (or, more generally, last) line. */
+     wrap_offset - prompt_invis_chars_first_line is usually the number of
+     invis chars on the second (or, more generally, last) line. */
 
   /* This is zero-based, used to set the newlines */
   prompt_lines_estimate = lpos / _rl_screenwidth;
 
   /* what if lpos is already >= _rl_screenwidth before we start drawing the
      contents of the command line? */
-  while (lpos >= _rl_screenwidth)
-    {
-      int z, p;
-      int nocorrect, wadjust;
-
-      nocorrect = 0;
-      /* Adjust depending on the invisible characters in the line.  We use a
-	 heuristic based on experience: invisible characters nearly always
-	 appear in the first and last lines of the prompt */
-      wadjust = (newlines == 0)
-		  ? prompt_invis_chars_first_line
-		  : ((newlines == prompt_lines_estimate) ? wrap_offset : prompt_invis_chars_first_line);
-
-      /* fix from Darin Johnson <darin@acuson.com> for prompt string with
-         invisible characters that is longer than the screen width.  The
-         prompt_invis_chars_first_line variable could be made into an array
-         saying how many invisible characters there are per line, but that's
-         probably too much work for the benefit gained.  How many people have
-         prompts that exceed two physical lines?
-         Additional logic fix from Edward Catmur <ed@catmur.co.uk> */
-#if defined (HANDLE_MULTIBYTE)
-      if (mb_cur_max > 1 && rl_byte_oriented == 0 && prompt_multibyte_chars > 0)
-	{
-	  nocorrect = 1;
-	  n0 = num;
-          temp = local_prompt_len;
-          while (num < temp)
-	    {
-	      /* This has to take invisible characters in the prompt into
-		 account. */
-	      z = _rl_col_width  (local_prompt, n0, num, 1) - wadjust;
-	      if (z > _rl_screenwidth)
-		{
-	          num = _rl_find_prev_mbchar (local_prompt, num, MB_FIND_ANY);
-	          break;
-		}
-	      else if (z == _rl_screenwidth)
-		{
-		  /* If we are in the middle or at the end of a multibyte
-		     character, we want to move to the start, then find out
-		     where it ends so we know where to insert the newline.
-		     If this isn't a multibyte character, its the same as num++ */
-		  p = _rl_find_prev_mbchar (local_prompt, num, MB_FIND_ANY);
-		  num = _rl_find_next_mbchar (local_prompt, p, 1, MB_FIND_ANY);
-		  break;
-		}
-	      num++;
-	    }
-          temp = num;
-	}
-      else
-#endif /* !HANDLE_MULTIBYTE */
-	temp = ((newlines + 1) * _rl_screenwidth);
+  if (lpos >= _rl_screenwidth)
+    {
+      temp = 0;
 
-      /* Now account for invisible characters in the current line. */
-      /* XXX - this assumes that the invisible characters may be split, but only
-	 between the first and the last lines. */
-      if (nocorrect == 0)
-	temp += wadjust;
+      /* first copy the linebreaks array we computed in expand_prompt */
+      while (local_prompt_newlines[newlines+1] != -1)
+	{
+	  temp = local_prompt_newlines[newlines+1];
+	  inv_lbreaks[++newlines] = temp;
+	}  
 
-      inv_lbreaks[++newlines] = temp;
-#if defined (HANDLE_MULTIBYTE)
-      /* lpos is a physical cursor position, so it needs to take the invisible
-	 characters into account. */
+      /* Now set lpos from the last newline */
       if (mb_cur_max > 1 && rl_byte_oriented == 0 && prompt_multibyte_chars > 0)
-	lpos -= _rl_col_width (local_prompt, n0, num, 1) - wadjust;
+        lpos = _rl_col_width (local_prompt, temp, local_prompt_len, 1) - (wrap_offset - prompt_invis_chars_first_line);
       else
-#endif
-	lpos -= _rl_screenwidth;	/* all physical cursor positions */
+        lpos -= (_rl_screenwidth * newlines);
     }
 
   prompt_last_screen_line = newlines;
 
   /* Draw the rest of the line (after the prompt) into invisible_line, keeping
-     track of where the cursor is (cpos_buffer_position), the number of the line containing
-     the cursor (lb_linenum), the last line number (lb_botlin and inv_botlin).
+     track of where the cursor is (cpos_buffer_position), the number of the
+     line containing the cursor (lb_linenum), the last line number (lb_botlin
+     and inv_botlin).
      It maintains an array of line breaks for display (inv_lbreaks).
      This handles expanding tabs for display and displaying meta characters. */
   lb_linenum = 0;
@@ -911,6 +951,9 @@ rl_redisplay ()
 		  temp = _rl_screenwidth - lpos;
 		  CHECK_INV_LBREAKS ();
 		  inv_lbreaks[++newlines] = out + temp;
+#if defined (HANDLE_MULTIBYTE)
+		  line_state_invisible->wrapped_line[newlines] = _rl_wrapped_multicolumn;
+#endif
 		  lpos = 4 - temp;
 		}
 	      else
@@ -941,6 +984,9 @@ rl_redisplay ()
 	      temp2 = _rl_screenwidth - lpos;
 	      CHECK_INV_LBREAKS ();
 	      inv_lbreaks[++newlines] = out + temp2;
+#if defined (HANDLE_MULTIBYTE)
+	      line_state_invisible->wrapped_line[newlines] = _rl_wrapped_multicolumn;
+#endif
 	      lpos = temp - temp2;
 	      while (out < newout)
 		line[out++] = ' ';
@@ -958,6 +1004,9 @@ rl_redisplay ()
 	  line[out++] = '\0';	/* XXX - sentinel */
 	  CHECK_INV_LBREAKS ();
 	  inv_lbreaks[++newlines] = out;
+#if defined (HANDLE_MULTIBYTE)
+	  line_state_invisible->wrapped_line[newlines] = _rl_wrapped_multicolumn;
+#endif
 	  lpos = 0;
 	}
       else if (CTRL_CHAR (c) || c == RUBOUT)
@@ -1032,6 +1081,10 @@ rl_redisplay ()
   inv_botlin = lb_botlin = _rl_inv_botlin = newlines;
   CHECK_INV_LBREAKS ();
   inv_lbreaks[newlines+1] = out;
+#if defined (HANDLE_MULTIBYTE)
+  /* This should be 0 anyway */
+  line_state_invisible->wrapped_line[newlines+1] = _rl_wrapped_multicolumn;
+#endif
   cursor_linenum = lb_linenum;
 
   /* CPOS_BUFFER_POSITION == position in buffer where cursor should be placed.
@@ -1099,8 +1152,8 @@ rl_redisplay ()
 
 	      /* update_line potentially changes _rl_last_c_pos, but doesn't
 		 take invisible characters into account, since _rl_last_c_pos
-		 is an absolute cursor position in a multibyte locale.  See
-		 if compensating here is the right thing, or if we have to
+		 is an absolute cursor position in a multibyte locale.  We
+		 choose to (mostly) compensate for that here, rather than
 		 change update_line itself.  There are several cases in which
 		 update_line adjusts _rl_last_c_pos itself (so it can pass
 		 _rl_move_cursor_relative accurate values); it communicates
@@ -1116,6 +1169,9 @@ rl_redisplay ()
 			cpos_adjusted == 0 &&
 			_rl_last_c_pos != o_cpos &&
 			_rl_last_c_pos > (prompt_last_invisible - _rl_screenwidth - prompt_invis_chars_first_line))
+		/* This assumes that all the invisible characters are split
+		   between the first and last lines of the prompt, if the 
+		   prompt consumes more than two lines. It's usually right */
 		_rl_last_c_pos -= (wrap_offset-prompt_invis_chars_first_line);
 
 	      /* If this is the line with the prompt, we might need to
@@ -1185,6 +1241,9 @@ rl_redisplay ()
 		_rl_last_c_pos += wrap_offset;
 	    }
 
+	  /* Now we move the cursor to where it needs to be.  First, make
+	     sure we are on the correct line (cursor_linenum). */
+
 	  /* We have to reprint the prompt if it contains invisible
 	     characters, since it's not generally OK to just reprint
 	     the characters from the current cursor position.  But we
@@ -1226,9 +1285,10 @@ rl_redisplay ()
 	     position that doesn't take invisible characters in the prompt
 	     into account.  We use a fudge factor to compensate. */
 
-	  /* Since _rl_backspace() doesn't know about invisible characters in the
-	     prompt, and there's no good way to tell it, we compensate for
-	     those characters here and call _rl_backspace() directly. */
+	  /* Since _rl_backspace() doesn't know about invisible characters in
+	     the prompt, and there's no good way to tell it, we compensate for
+	     those characters here and call _rl_backspace() directly if
+	     necessary */
 	  if (wrap_offset && cursor_linenum == 0 && nleft < _rl_last_c_pos)
 	    {
 	      /* TX == new physical cursor position in multibyte locale. */
@@ -1253,7 +1313,7 @@ rl_redisplay ()
 	    _rl_move_cursor_relative (nleft, &invisible_line[pos]);
 	}
     }
-  else				/* Do horizontal scrolling. */
+  else				/* Do horizontal scrolling. Much simpler */
     {
 #define M_OFFSET(margin, offset) ((margin) == 0 ? offset : 0)
       int lmargin, ndisp, nleft, phys_c_pos, t;
@@ -1391,9 +1451,7 @@ new:	eddie> Oh, my little buggy says to me, as lurgid as
 
    Could be made even smarter, but this works well enough */
 static void
-update_line (old, new, current_line, omax, nmax, inv_botlin)
-     register char *old, *new;
-     int current_line, omax, nmax, inv_botlin;
+update_line (char *old, char *new, int current_line, int omax, int nmax, int inv_botlin)
 {
   register char *ofd, *ols, *oe, *nfd, *nls, *ne;
   int temp, lendiff, wsatend, od, nd, twidth, o_cpos;
@@ -1418,52 +1476,132 @@ update_line (old, new, current_line, omax, nmax, inv_botlin)
   if (temp == _rl_screenwidth && _rl_term_autowrap && !_rl_horizontal_scroll_mode
 	&& _rl_last_v_pos == current_line - 1)
     {
+      /* We're going to wrap around by writing the first character of NEW to
+	 the screen and dealing with changes to what's visible by modifying
+	 OLD to match it.  Complicated by the presence of multi-width
+	 characters at the end of the line or beginning of the new one. */
 #if defined (HANDLE_MULTIBYTE)
       if (mb_cur_max > 1 && rl_byte_oriented == 0)
 	{
 	  wchar_t wc;
 	  mbstate_t ps;
-	  int tempwidth, bytes;
+	  int oldwidth, newwidth;
+	  int oldbytes, newbytes;
 	  size_t ret;
 
 	  /* This fixes only double-column characters, but if the wrapped
 	     character consumes more than three columns, spaces will be
 	     inserted in the string buffer. */
-	  if (current_line < line_state_visible->wbsize && line_state_visible->wrapped_line[current_line] > 0)
-	    _rl_clear_to_eol (line_state_visible->wrapped_line[current_line]);
+	  /* XXX remember that we are working on the invisible line right now;
+	     we don't swap visible and invisible until just before rl_redisplay
+	     returns */
+	  /* This will remove the extra placeholder space we added with
+	     _rl_wrapped_multicolumn */
+	  if (current_line < line_state_invisible->wbsize && line_state_invisible->wrapped_line[current_line] > 0)
+	    _rl_clear_to_eol (line_state_invisible->wrapped_line[current_line]);
+
+	  /* 1. how many screen positions does first char in old consume? */
+	  memset (&ps, 0, sizeof (mbstate_t));
+	  ret = mbrtowc (&wc, old, mb_cur_max, &ps);
+	  oldbytes = ret;
+	  if (MB_INVALIDCH (ret))
+	    {
+	      oldwidth = 1;
+	      oldbytes = 1;
+	    }
+	  else if (MB_NULLWCH (ret))
+	    oldwidth = 0;
+	  else
+	    oldwidth = WCWIDTH (wc);
 
+	  /* 2. how many screen positions does the first char in new consume? */
 	  memset (&ps, 0, sizeof (mbstate_t));
 	  ret = mbrtowc (&wc, new, mb_cur_max, &ps);
+	  newbytes = ret;
 	  if (MB_INVALIDCH (ret))
 	    {
-	      tempwidth = 1;
-	      ret = 1;
+	      newwidth = 1;
+	      newbytes = 1;
 	    }
 	  else if (MB_NULLWCH (ret))
-	    tempwidth = 0;
+	    newwidth = 0;
 	  else
-	    tempwidth = WCWIDTH (wc);
+	    newwidth = WCWIDTH (wc);
 
-	  if (tempwidth > 0)
+	  /* 3. if the new width is less than the old width, we need to keep
+	     going in new until we have consumed at least that many screen
+	     positions, and figure out how many bytes that will take */
+	  while (newbytes < nmax && newwidth < oldwidth)
 	    {
-	      int count, i;
-	      bytes = ret;
-	      for (count = 0; count < bytes; count++)
-		putc (new[count], rl_outstream);
-	      _rl_last_c_pos = tempwidth;
+	      ret = mbrtowc (&wc, new+newbytes, mb_cur_max, &ps);
+	      if (MB_INVALIDCH (ret))
+		{
+		  newwidth += 1;
+		  newbytes += 1;
+		}
+	      else if (MB_NULLWCH (ret))
+	        break;
+	      else
+		{
+		  newwidth += WCWIDTH (wc);
+		  newbytes += ret;
+		}
+	    }
+	  /* 4. If the new width is more than the old width, keep going in old
+	     until we have consumed exactly that many screen positions, and
+	     figure out how many bytes that will take.  This is an optimization */
+	  while (oldbytes < omax && oldwidth < newwidth)
+	    {
+	      ret = mbrtowc (&wc, old+oldbytes, mb_cur_max, &ps);
+	      if (MB_INVALIDCH (ret))
+		{
+		  oldwidth += 1;
+		  oldbytes += 1;
+		}
+	      else if (MB_NULLWCH (ret))
+	        break;
+	      else
+		{
+		  oldwidth += WCWIDTH (wc);
+		  oldbytes += ret;
+		}
+	    }
+	  /* 5. write the first newbytes of new, which takes newwidth.  This is
+	     where the screen wrapping takes place, and we are now writing
+	     characters onto the new line. We need to fix up old so it
+	     accurately reflects what is on the screen after the
+	     _rl_output_some_chars below. */
+	  if (newwidth > 0)
+	    {
+	      int count, i, j;
+	      char *optr;
+
+	      _rl_output_some_chars (new, newbytes);
+	      _rl_last_c_pos = newwidth;
 	      _rl_last_v_pos++;
-	      memset (&ps, 0, sizeof (mbstate_t));
-	      ret = mbrtowc (&wc, old, mb_cur_max, &ps);
-	      if (ret != 0 && bytes != 0)
+
+	      /* 5a. If the number of screen positions doesn't match, punt
+		 and do a dumb update. */
+	      if (newwidth != oldwidth)
+		{
+		  ne = new + nmax;
+		  nd = newbytes;
+		  nfd = new + nd;
+		  goto dumb_update;
+		}
+	      if (oldbytes != 0 && newbytes != 0)
 		{
-		  if (MB_INVALIDCH (ret))
-		    ret = 1;
-		  memmove (old+bytes, old+ret, strlen (old+ret));
-		  memcpy (old, new, bytes);
+		  /* We have written as many bytes from new as we need to
+		     consume the first character of old. Fix up `old' so it
+		     reflects the new screen contents */
+		  memmove (old+newbytes, old+oldbytes, strlen (old+oldbytes));
+		  memcpy (old, new, newbytes);
+		  j = newbytes - oldbytes;
+		      
+		  omax += j;
 		  /* Fix up indices if we copy data from one line to another */
-		  omax += bytes - ret;
 		  for (i = current_line+1; i <= inv_botlin+1; i++)
-		    vis_lbreaks[i] += bytes - ret;
+		    vis_lbreaks[i] += j;
 		}
 	    }
 	  else
@@ -1508,6 +1646,7 @@ update_line (old, new, current_line, omax, nmax, inv_botlin)
 	  memset (&ps_new, 0, sizeof(mbstate_t));
 	  memset (&ps_old, 0, sizeof(mbstate_t));
 
+	  /* Are the old and new lines the same? */
 	  if (omax == nmax && STREQN (new, old, omax))
 	    {
 	      old_offset = omax;
@@ -1517,6 +1656,8 @@ update_line (old, new, current_line, omax, nmax, inv_botlin)
 	    }
 	  else
 	    {
+	      /* Go through the line from the beginning and find the first
+		 difference. */
 	      new_offset = old_offset = 0;
 	      for (ofd = old, nfd = new;
 		    (ofd - old < omax) && *ofd &&
@@ -1572,6 +1713,8 @@ update_line (old, new, current_line, omax, nmax, inv_botlin)
   wsatend = 1;			/* flag for trailing whitespace */
 
 #if defined (HANDLE_MULTIBYTE)
+  /* Find the last character that is the same between the two lines.  This
+     bounds the region that needs to change. */
   if (mb_cur_max > 1 && rl_byte_oriented == 0)
     {
       ols = old + _rl_find_prev_mbchar (old, oe - old, MB_FIND_ANY);
@@ -1731,6 +1874,7 @@ update_line (old, new, current_line, omax, nmax, inv_botlin)
 	  nd = lendiff;
 
 	  /* Do a dumb update and return */
+dumb_update:
 	  temp = ne - nfd;
 	  if (temp > 0)
 	    {
@@ -1811,6 +1955,7 @@ update_line (old, new, current_line, omax, nmax, inv_botlin)
     {
       /* Non-zero if we're increasing the number of lines. */
       int gl = current_line >= _rl_vis_botlin && inv_botlin > _rl_vis_botlin;
+
       /* If col_lendiff is > 0, implying that the new string takes up more
 	 screen real estate than the old, but lendiff is < 0, meaning that it
 	 takes fewer bytes, we need to just output the characters starting
@@ -1959,12 +2104,24 @@ update_line (old, new, current_line, omax, nmax, inv_botlin)
 		  _rl_last_c_pos += _rl_col_width (nfd, 0, bytes_to_insert, 1);
 		  if (current_line == 0 && wrap_offset &&
 			displaying_prompt_first_line &&
-			_rl_last_c_pos > wrap_offset &&
+			_rl_last_c_pos >= wrap_offset &&	/* XXX was > */
 			((nfd - new) <= prompt_last_invisible))
 		    {
 		      _rl_last_c_pos -= wrap_offset;
 		      cpos_adjusted = 1;
 		    }
+
+#if 1
+		  /* If we write a non-space into the last screen column,
+		     remove the note that we added a space to compensate for
+		     a multibyte double-width character that didn't fit, since
+		     it's only valid for what was previously there. */
+		  /* XXX - watch this */
+		  if (_rl_last_c_pos == _rl_screenwidth &&
+			line_state_invisible->wrapped_line[current_line+1] &&
+			nfd[bytes_to_insert-1] != ' ')
+		    line_state_invisible->wrapped_line[current_line+1] = 0;
+#endif
 		}
 	      else
 		_rl_last_c_pos += bytes_to_insert;
@@ -2026,7 +2183,7 @@ clear_rest_of_line:
 
 /* Tell the update routines that we have moved onto a new (empty) line. */
 int
-rl_on_new_line ()
+rl_on_new_line (void)
 {
   if (visible_line)
     visible_line[0] = '\0';
@@ -2042,7 +2199,7 @@ rl_on_new_line ()
 /* Clear all screen lines occupied by the current readline line buffer
    (visible line) */
 int
-rl_clear_visible_line ()
+rl_clear_visible_line (void)
 {
   int curr_line;
 
@@ -2070,9 +2227,10 @@ rl_clear_visible_line ()
 /* Tell the update routines that we have moved onto a new line with the
    prompt already displayed.  Code originally from the version of readline
    distributed with CLISP.  rl_expand_prompt must have already been called
-   (explicitly or implicitly).  This still doesn't work exactly right. */
+   (explicitly or implicitly).  This still doesn't work exactly right; it
+   should use expand_prompt() */
 int
-rl_on_new_line_with_prompt ()
+rl_on_new_line_with_prompt (void)
 {
   int prompt_size, i, l, real_screenwidth, newlines;
   char *prompt_last_line, *lprompt;
@@ -2128,7 +2286,7 @@ rl_on_new_line_with_prompt ()
 
 /* Actually update the display, period. */
 int
-rl_forced_update_display ()
+rl_forced_update_display (void)
 {
   register char *temp;
 
@@ -2146,7 +2304,7 @@ rl_forced_update_display ()
 
 /* Redraw only the last line of a multi-line prompt. */
 void
-rl_redraw_prompt_last_line ()
+rl_redraw_prompt_last_line (void)
 {
   char *t;
 
@@ -2164,9 +2322,7 @@ rl_redraw_prompt_last_line ()
    the movement is being done.
    DATA is always the visible line or the invisible line */
 void
-_rl_move_cursor_relative (new, data)
-     int new;
-     const char *data;
+_rl_move_cursor_relative (int new, const char *data)
 {
   register int i;
   int woff;			/* number of invisible chars on current line */
@@ -2323,8 +2479,7 @@ _rl_move_cursor_relative (new, data)
 
 /* PWP: move the cursor up or down. */
 void
-_rl_move_vert (to)
-     int to;
+_rl_move_vert (int to)
 {
   register int delta, i;
 
@@ -2364,8 +2519,7 @@ _rl_move_vert (to)
 /* Physically print C on rl_outstream.  This is for functions which know
    how to optimize the display.  Return the number of characters output. */
 int
-rl_show_char (c)
-     int c;
+rl_show_char (int c)
 {
   int n = 1;
   if (META_CHAR (c) && (_rl_output_meta_chars == 0))
@@ -2392,8 +2546,7 @@ rl_show_char (c)
 }
 
 int
-rl_character_len (c, pos)
-     register int c, pos;
+rl_character_len (int c, int pos)
 {
   unsigned char uc;
 
@@ -2528,7 +2681,7 @@ rl_message (format, arg1, arg2)
 
 /* How to clear things from the "echo-area". */
 int
-rl_clear_message ()
+rl_clear_message (void)
 {
   rl_display_prompt = rl_prompt;
   if (msg_saved_prompt)
@@ -2541,7 +2694,7 @@ rl_clear_message ()
 }
 
 int
-rl_reset_line_state ()
+rl_reset_line_state (void)
 {
   rl_on_new_line ();
 
@@ -2550,8 +2703,12 @@ rl_reset_line_state ()
   return 0;
 }
 
+/* Save all of the variables associated with the prompt and its display. Most
+   of the complexity is dealing with the invisible characters in the prompt
+   string and where they are. There are enough of these that I should consider
+   a struct. */
 void
-rl_save_prompt ()
+rl_save_prompt (void)
 {
   saved_local_prompt = local_prompt;
   saved_local_prefix = local_prompt_prefix;
@@ -2561,22 +2718,28 @@ rl_save_prompt ()
   saved_visible_length = prompt_visible_length;
   saved_invis_chars_first_line = prompt_invis_chars_first_line;
   saved_physical_chars = prompt_physical_chars;
+  saved_local_prompt_newlines = local_prompt_newlines;
 
   local_prompt = local_prompt_prefix = (char *)0;
   local_prompt_len = 0;
+  local_prompt_newlines = (int *)0;
+
   prompt_last_invisible = prompt_visible_length = prompt_prefix_length = 0;
   prompt_invis_chars_first_line = prompt_physical_chars = 0;
 }
 
 void
-rl_restore_prompt ()
+rl_restore_prompt (void)
 {
   FREE (local_prompt);
   FREE (local_prompt_prefix);
+  FREE (local_prompt_newlines);
 
   local_prompt = saved_local_prompt;
   local_prompt_prefix = saved_local_prefix;
   local_prompt_len = saved_local_length;
+  local_prompt_newlines = saved_local_prompt_newlines;
+
   prompt_prefix_length = saved_prefix_length;
   prompt_last_invisible = saved_last_invisible;
   prompt_visible_length = saved_visible_length;
@@ -2588,11 +2751,11 @@ rl_restore_prompt ()
   saved_local_length = 0;
   saved_last_invisible = saved_visible_length = saved_prefix_length = 0;
   saved_invis_chars_first_line = saved_physical_chars = 0;
+  saved_local_prompt_newlines = 0;
 }
 
 char *
-_rl_make_prompt_for_search (pchar)
-     int pchar;
+_rl_make_prompt_for_search (int pchar)
 {
   int len;
   char *pmt, *p;
@@ -2630,8 +2793,7 @@ _rl_make_prompt_for_search (pchar)
 
 /* Quick redisplay hack when erasing characters at the end of the line. */
 void
-_rl_erase_at_end_of_line (l)
-     int l;
+_rl_erase_at_end_of_line (int l)
 {
   register int i;
 
@@ -2645,10 +2807,10 @@ _rl_erase_at_end_of_line (l)
 }
 
 /* Clear to the end of the line.  COUNT is the minimum
-   number of character spaces to clear, */
+   number of character spaces to clear, but we use a terminal escape
+   sequence if available. */
 void
-_rl_clear_to_eol (count)
-     int count;
+_rl_clear_to_eol (int count)
 {
 #ifndef __MSDOS__
   if (_rl_term_clreol)
@@ -2662,19 +2824,18 @@ _rl_clear_to_eol (count)
 /* Clear to the end of the line using spaces.  COUNT is the minimum
    number of character spaces to clear, */
 static void
-space_to_eol (count)
-     int count;
+space_to_eol (int count)
 {
   register int i;
 
   for (i = 0; i < count; i++)
-   putc (' ', rl_outstream);
+    putc (' ', rl_outstream);
 
   _rl_last_c_pos += count;
 }
 
 void
-_rl_clear_screen ()
+_rl_clear_screen (void)
 {
 #ifndef __DJGPP__
   if (_rl_term_clrpag)
@@ -2689,9 +2850,7 @@ _rl_clear_screen ()
 
 /* Insert COUNT characters from STRING to the output stream at column COL. */
 static void
-insert_some_chars (string, count, col)
-     char *string;
-     int count, col;
+insert_some_chars (char *string, int count, int col)
 {
   open_some_spaces (col);
   _rl_output_some_chars (string, count);
@@ -2701,8 +2860,7 @@ insert_some_chars (string, count, col)
    ncurses documentation and use either im/ei with explicit spaces, or IC/ic
    by itself.  We assume there will either be ei or we don't need to use it. */
 static void
-open_some_spaces (col)
-     int col;
+open_some_spaces (int col)
 {
 #if !defined (__MSDOS__) && (!defined (__MINGW32__) || defined (NCURSES_VERSION))
   char *buffer;
@@ -2738,8 +2896,7 @@ open_some_spaces (col)
 
 /* Delete COUNT characters from the display line. */
 static void
-delete_chars (count)
-     int count;
+delete_chars (int count)
 {
   if (count > _rl_screenwidth)	/* XXX */
     return;
@@ -2761,7 +2918,7 @@ delete_chars (count)
 }
 
 void
-_rl_update_final ()
+_rl_update_final (void)
 {
   int full_lines;
 
@@ -2794,7 +2951,7 @@ _rl_update_final ()
 
 /* Move to the start of the current line. */
 static void
-cr ()
+cr (void)
 {
   if (_rl_term_cr)
     {
@@ -2811,8 +2968,7 @@ cr ()
    terminal escape sequences.  Called with the cursor at column 0 of the
    line to draw the prompt on. */
 static void
-redraw_prompt (t)
-     char *t;
+redraw_prompt (char *t)
 {
   char *oldp;
 
@@ -2836,7 +2992,7 @@ redraw_prompt (t)
       
 /* Redisplay the current line after a SIGWINCH is received. */
 void
-_rl_redisplay_after_sigwinch ()
+_rl_redisplay_after_sigwinch (void)
 {
   char *t;
 
@@ -2881,7 +3037,7 @@ _rl_redisplay_after_sigwinch ()
 }
 
 void
-_rl_clean_up_for_exit ()
+_rl_clean_up_for_exit (void)
 {
   if (_rl_echoing_p)
     {
@@ -2894,7 +3050,7 @@ _rl_clean_up_for_exit ()
 }
 
 void
-_rl_erase_entire_line ()
+_rl_erase_entire_line (void)
 {
   cr ();
   _rl_clear_to_eol (0);
@@ -2903,7 +3059,7 @@ _rl_erase_entire_line ()
 }
 
 void
-_rl_ttyflush ()
+_rl_ttyflush (void)
 {
   fflush (rl_outstream);
 }
@@ -2911,7 +3067,7 @@ _rl_ttyflush ()
 /* return the `current display line' of the cursor -- the number of lines to
    move up to get to the first screen line of the current readline line. */
 int
-_rl_current_display_line ()
+_rl_current_display_line (void)
 {
   int ret, nleft;
 
@@ -2935,9 +3091,7 @@ _rl_current_display_line ()
    In the case of multibyte characters with stateful encoding, we have to
    scan from the beginning of the string to take the state into account. */
 static int
-_rl_col_width (str, start, end, flags)
-     const char *str;
-     int start, end, flags;
+_rl_col_width (const char *str, int start, int end, int flags)
 {
   wchar_t wc;
   mbstate_t ps;
diff --git a/doc/readline.3 b/doc/readline.3
index b371ee9..1257cdf 100644
--- a/doc/readline.3
+++ b/doc/readline.3
@@ -6,9 +6,9 @@
 .\"	Case Western Reserve University
 .\"	chet.ramey@case.edu
 .\"
-.\"	Last Change: Wed Nov 30 10:06:13 PST 2016
+.\"	Last Change: Fri Feb  3 16:02:47 EST 2017
 .\"
-.TH READLINE 3 "2016 November 30" "GNU Readline 7.0"
+.TH READLINE 3 "2017 February 3" "GNU Readline 7.0"
 .\"
 .\" File Name macro.  This used to be `.PN', for Path Name,
 .\" but Sun doesn't seem to like that very much.
@@ -771,6 +771,19 @@ alphanumeric characters (letters and digits).
 Move back to the start of the current or previous word.  Words are
 composed of alphanumeric characters (letters and digits).
 .TP
+.B previous\-screen\-line
+Attempt to move point to the same physical screen column on the previous
+physical screen line. This will not have the desired effect if the current
+Readline line does not take up more than one physical line or if point is not
+greater than the length of the prompt plus the screen width.
+.TP
+.B next\-screen\-line
+Attempt to move point to the same physical screen column on the next
+physical screen line. This will not have the desired effect if the current
+Readline line does not take up more than one physical line or if the length
+of the current Readline line is not greater than the length of the prompt
+plus the screen width.
+.TP
 .B clear\-screen (C\-l)
 Clear the screen leaving the current line at the top of the screen.
 With an argument, refresh the current line without clearing the
diff --git a/doc/rltech.texi b/doc/rltech.texi
index b8ce90f..2754ad2 100644
--- a/doc/rltech.texi
+++ b/doc/rltech.texi
@@ -90,6 +90,12 @@ If @code{readline} encounters an @code{EOF} while reading the line, and the
 line is empty at that point, then @code{(char *)NULL} is returned.
 Otherwise, the line is ended just as if a newline had been typed.
 
+Readline performs some expansion on the @var{prompt} before it is
+displayed on the screen.  See the description of @code{rl_expand_prompt}
+(@pxref{Redisplay}) for additional details, especially if @var{prompt}
+will contain characters that do not consume physical screen space when
+displayed.
+
 If you want the user to be able to get at the line later, (with
 @key{C-p} for example), you must call @code{add_history()} to save the
 line away in a @dfn{history} list of such lines.
diff --git a/doc/rluser.texi b/doc/rluser.texi
index 63a6b9d..22bbd1e 100644
--- a/doc/rluser.texi
+++ b/doc/rluser.texi
@@ -1138,6 +1138,19 @@ Move back to the start of the current or previous word.
 Words are delimited by non-quoted shell metacharacters.
 @end ifset
 
+@item previous-screen-line ()
+Attempt to move point to the same physical screen column on the previous
+physical screen line. This will not have the desired effect if the current
+Readline line does not take up more than one physical line or if point is not
+greater than the length of the prompt plus the screen width.
+
+@item next-screen-line ()
+Attempt to move point to the same physical screen column on the next
+physical screen line. This will not have the desired effect if the current
+Readline line does not take up more than one physical line or if the length
+of the current Readline line is not greater than the length of the prompt
+plus the screen width.
+
 @item clear-screen (C-l)
 Clear the screen and redraw the current line,
 leaving the current line at the top of the screen.
@@ -2201,7 +2214,7 @@ a shell function and bind it to a particular command using @code{complete -F}.
 
 The following function provides completions for the @code{cd} builtin.
 It is a reasonably good example of what shell functions must do when
-used for completion.  This function uses the word passsed as @code{$2}
+used for completion.  This function uses the word passed as @code{$2}
 to determine the directory name to complete.  You can also use the
 @code{COMP_WORDS} array variable; the current word is indexed by the
 @code{COMP_CWORD} variable.
diff --git a/doc/version.texi b/doc/version.texi
index f74d629..fac7b5e 100644
--- a/doc/version.texi
+++ b/doc/version.texi
@@ -1,10 +1,10 @@
 @ignore
-Copyright (C) 1988-2016 Free Software Foundation, Inc. 
+Copyright (C) 1988-2017 Free Software Foundation, Inc. 
 @end ignore
 
 @set EDITION 7.0
 @set VERSION 7.0
-@set UPDATED 30 November 2016
-@set UPDATED-MONTH November 2016
+@set UPDATED 21 April 2017
+@set UPDATED-MONTH April 2017
 
-@set LASTCHANGE Wed Nov 30 10:06:36 PST 2016
+@set LASTCHANGE Fri Apr 21 15:25:17 EDT 2017
diff --git a/emacs_keymap.c b/emacs_keymap.c
index cb6e140..b5e53f4 100644
--- a/emacs_keymap.c
+++ b/emacs_keymap.c
@@ -1,6 +1,6 @@
 /* emacs_keymap.c -- the keymap for emacs_mode in readline (). */
 
-/* Copyright (C) 1987-2009 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 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.      
diff --git a/examples/rlcat.c b/examples/rlcat.c
index fa9e06f..b494241 100644
--- a/examples/rlcat.c
+++ b/examples/rlcat.c
@@ -137,7 +137,7 @@ fcopy(fp)
       if (vflag && isascii ((unsigned char)c) && isprint((unsigned char)c) == 0)
 	{
 	  x = rl_untranslate_keyseq (c);
-	  if (fputs (x, stdout) != 0)
+	  if (fputs (x, stdout) == EOF)
 	    return 1;
 	}
       else if (putchar (c) == EOF)
diff --git a/funmap.c b/funmap.c
index 34b1d6b..aaf144d 100644
--- a/funmap.c
+++ b/funmap.c
@@ -1,6 +1,6 @@
 /* funmap.c -- attach names to functions. */
 
-/* Copyright (C) 1987-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 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.      
@@ -110,6 +110,7 @@ static const FUNMAP default_funmap[] = {
   { "menu-complete", rl_menu_complete },
   { "menu-complete-backward", rl_backward_menu_complete },
   { "next-history", rl_get_next_history },
+  { "next-screen-line", rl_next_screen_line },
   { "non-incremental-forward-search-history", rl_noninc_forward_search },
   { "non-incremental-reverse-search-history", rl_noninc_reverse_search },
   { "non-incremental-forward-search-history-again", rl_noninc_forward_search_again },
@@ -121,6 +122,7 @@ static const FUNMAP default_funmap[] = {
 #endif
   { "possible-completions", rl_possible_completions },
   { "previous-history", rl_get_previous_history },
+  { "previous-screen-line", rl_previous_screen_line },
   { "print-last-kbd-macro", rl_print_last_kbd_macro },
   { "quoted-insert", rl_quoted_insert },
   { "re-read-init-file", rl_re_read_init_file },
@@ -204,9 +206,7 @@ static const FUNMAP default_funmap[] = {
 };
 
 int
-rl_add_funmap_entry (name, function)
-     const char *name;
-     rl_command_func_t *function;
+rl_add_funmap_entry (const char *name, rl_command_func_t *function)
 {
   if (funmap_entry + 2 >= funmap_size)
     {
@@ -226,7 +226,7 @@ static int funmap_initialized;
 
 /* Make the funmap contain all of the default entries. */
 void
-rl_initialize_funmap ()
+rl_initialize_funmap (void)
 {
   register int i;
 
@@ -244,7 +244,7 @@ rl_initialize_funmap ()
    is sorted.  The array itself is allocated, but not the strings inside.
    You should free () the array when you done, but not the pointers. */
 const char **
-rl_funmap_names ()
+rl_funmap_names (void)
 {
   const char **result;
   int result_size, result_index;
diff --git a/histexpand.c b/histexpand.c
index b84a6b8..e9c333d 100644
--- a/histexpand.c
+++ b/histexpand.c
@@ -1,6 +1,6 @@
 /* histexpand.c -- history expansion. */
 
-/* Copyright (C) 1989-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1989-2017 Free Software Foundation, Inc.
 
    This file contains the GNU History Library (History), a set of
    routines for managing the text of previously typed lines.
@@ -132,10 +132,7 @@ static char *search_match;
    So you might call this function like:
    line = get_history_event ("!echo:p", &index, 0);  */
 char *
-get_history_event (string, caller_index, delimiting_quote)
-     const char *string;
-     int *caller_index;
-     int delimiting_quote;
+get_history_event (const char *string, int *caller_index, int delimiting_quote)
 {
   register int i;
   register char c;
@@ -316,9 +313,7 @@ get_history_event (string, caller_index, delimiting_quote)
    to the closing single quote.  FLAGS currently used to allow backslash
    to escape a single quote (e.g., for bash $'...'). */
 static void
-hist_string_extract_single_quoted (string, sindex, flags)
-     char *string;
-     int *sindex, flags;
+hist_string_extract_single_quoted (char *string, int *sindex, int flags)
 {
   register int i;
 
@@ -332,8 +327,7 @@ hist_string_extract_single_quoted (string, sindex, flags)
 }
 
 static char *
-quote_breaks (s)
-     char *s;
+quote_breaks (char *s)
 {
   register char *p, *r;
   char *ret;
@@ -374,9 +368,7 @@ quote_breaks (s)
 }
 
 static char *
-hist_error(s, start, current, errtype)
-      char *s;
-      int start, current, errtype;
+hist_error(char *s, int start, int current, int errtype)
 {
   char *temp;
   const char *emsg;
@@ -433,9 +425,7 @@ hist_error(s, start, current, errtype)
    subst_rhs is allowed to be set to the empty string. */
 
 static char *
-get_subst_pattern (str, iptr, delimiter, is_rhs, lenptr)
-     char *str;
-     int *iptr, delimiter, is_rhs, *lenptr;
+get_subst_pattern (char *str, int *iptr, int delimiter, int is_rhs, int *lenptr)
 {
   register int si, i, j, k;
   char *s;
@@ -490,7 +480,7 @@ get_subst_pattern (str, iptr, delimiter, is_rhs, lenptr)
 }
 
 static void
-postproc_subst_rhs ()
+postproc_subst_rhs (void)
 {
   char *new;
   int i, j, new_size;
@@ -526,12 +516,9 @@ postproc_subst_rhs ()
    if the `p' modifier was supplied and the caller should just print
    the returned string.  Returns the new index into string in
    *END_INDEX_PTR, and the expanded specifier in *RET_STRING. */
+/* need current line for !# */
 static int
-history_expand_internal (string, start, qc, end_index_ptr, ret_string, current_line)
-     char *string;
-     int start, qc, *end_index_ptr;
-     char **ret_string;
-     char *current_line;	/* for !# */
+history_expand_internal (char *string, int start, int qc, int *end_index_ptr, char **ret_string, char *current_line)
 {
   int i, n, starting_index;
   int substitute_globally, subst_bywords, want_quotes, print_only;
@@ -908,9 +895,7 @@ history_expand_internal (string, start, qc, end_index_ptr, ret_string, current_l
 	while (0)
 
 int
-history_expand (hstring, output)
-     char *hstring;
-     char **output;
+history_expand (char *hstring, char **output)
 {
   register int j;
   int i, r, l, passc, cc, modified, eindex, only_printing, dquote, squote, flag;
@@ -1249,9 +1234,7 @@ history_expand (hstring, output)
    CALLER_INDEX is the offset in SPEC to start looking; it is updated
    to point to just after the last character parsed. */
 static char *
-get_history_word_specifier (spec, from, caller_index)
-     char *spec, *from;
-     int *caller_index;
+get_history_word_specifier (char *spec, char *from, int *caller_index)
 {
   register int i = *caller_index;
   int first, last;
@@ -1357,9 +1340,7 @@ get_history_word_specifier (spec, from, caller_index)
    tokens, so that FIRST = -1 means the next to last token on the line).
    If LAST is `$' the last arg from STRING is used. */
 char *
-history_arg_extract (first, last, string)
-     int first, last;
-     const char *string;
+history_arg_extract (int first, int last, const char *string)
 {
   register int i, len;
   char *result;
@@ -1418,9 +1399,7 @@ history_arg_extract (first, last, string)
 }
 
 static int
-history_tokenize_word (string, ind)
-     const char *string;
-     int ind;
+history_tokenize_word (const char *string, int ind)
 {
   register int i, j;
   int delimiter, nestdelim, delimopen;
@@ -1570,9 +1549,7 @@ get_word:
 }
 
 static char *
-history_substring (string, start, end)
-     const char *string;
-     int start, end;
+history_substring (const char *string, int start, int end)
 {
   register int len;
   register char *result;
@@ -1589,9 +1566,7 @@ history_substring (string, start, end)
    WIND.  The position in the returned array of strings is returned in
    *INDP. */
 static char **
-history_tokenize_internal (string, wind, indp)
-     const char *string;
-     int wind, *indp;
+history_tokenize_internal (const char *string, int wind, int *indp)
 {
   char **result;
   register int i, start, result_index, size;
@@ -1644,17 +1619,14 @@ history_tokenize_internal (string, wind, indp)
 /* Return an array of tokens, much as the shell might.  The tokens are
    parsed out of STRING. */
 char **
-history_tokenize (string)
-     const char *string;
+history_tokenize (const char *string)
 {
   return (history_tokenize_internal (string, -1, (int *)NULL));
 }
 
 /* Free members of WORDS from START to an empty string */
 static void
-freewords (words, start)
-     char **words;
-     int start;
+freewords (char **words, int start)
 {
   register int i;
 
@@ -1666,9 +1638,7 @@ freewords (words, start)
    in the history line LINE.  Used to save the word matched by the
    last history !?string? search. */
 static char *
-history_find_word (line, ind)
-     char *line;
-     int ind;
+history_find_word (char *line, int ind)
 {
   char **words, *s;
   int i, wind;
diff --git a/histfile.c b/histfile.c
index 2e69c58..399bcc3 100644
--- a/histfile.c
+++ b/histfile.c
@@ -1,6 +1,6 @@
 /* histfile.c - functions to manipulate the history file. */
 
-/* Copyright (C) 1989-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1989-2017 Free Software Foundation, Inc.
 
    This file contains the GNU History Library (History), a set of
    routines for managing the text of previously typed lines.
@@ -143,8 +143,7 @@ static int histfile_restore PARAMS((const char *, const char *));
    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;
+history_filename (const char *filename)
 {
   char *return_val;
   const char *home;
@@ -179,8 +178,7 @@ history_filename (filename)
 }
 
 static char *
-history_backupfile (filename)
-     const char *filename;
+history_backupfile (const char *filename)
 {
   const char *fn;
   char *ret, linkbuf[PATH_MAX+1];
@@ -208,8 +206,7 @@ history_backupfile (filename)
 }
   
 static char *
-history_tempfile (filename)
-     const char *filename;
+history_tempfile (const char *filename)
 {
   const char *fn;
   char *ret, linkbuf[PATH_MAX+1];
@@ -251,8 +248,7 @@ history_tempfile (filename)
    If FILENAME is NULL, then read from ~/.history.  Returns 0 if
    successful, or errno if not. */
 int
-read_history (filename)
-     const char *filename;
+read_history (const char *filename)
 {
   return (read_history_range (filename, 0, -1));
 }
@@ -263,9 +259,7 @@ read_history (filename)
    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;
+read_history_range (const char *filename, int from, int to)
 {
   register char *line_start, *line_end, *p;
   char *input, *buffer, *bufend, *last_ts;
@@ -289,6 +283,16 @@ read_history_range (filename, from, to)
   if ((file < 0) || (fstat (file, &finfo) == -1))
     goto error_and_exit;
 
+  if (S_ISREG (finfo.st_mode) == 0)
+    {
+#ifdef EFTYPE
+      errno = EFTYPE;
+#else
+      errno = EINVAL;
+#endif
+      goto error_and_exit;
+    }
+
   file_size = (size_t)finfo.st_size;
 
   /* check for overflow on very large files */
@@ -298,6 +302,12 @@ read_history_range (filename, from, to)
       goto error_and_exit;
     }
 
+  if (file_size == 0)
+    {
+      free (input);
+      return 0;	/* don't waste time if we don't have to */
+    }
+
 #ifdef HISTORY_USE_MMAP
   /* We map read/write and private so we can change newlines to NULs without
      affecting the underlying object. */
@@ -344,6 +354,7 @@ read_history_range (filename, from, to)
 
   /* Start at beginning of file, work to end. */
   bufend = buffer + chars_read;
+  *bufend = '\0';		/* null-terminate buffer for timestamp checks */
   current_line = 0;
 
   /* Heuristic: the history comment character rarely changes, so assume we
@@ -427,9 +438,7 @@ read_history_range (filename, from, to)
 /* Save FILENAME to BACK, handling case where FILENAME is a symlink
    (e.g., ~/.bash_history -> .histfiles/.bash_history.$HOSTNAME) */
 static int
-histfile_backup (filename, back)
-     const char *filename;
-     const char *back;
+histfile_backup (const char *filename, const char *back)
 {
 #if defined (HAVE_READLINK)
   char linkbuf[PATH_MAX+1];
@@ -448,9 +457,7 @@ histfile_backup (filename, back)
 /* Restore ORIG from BACKUP handling case where ORIG is a symlink
    (e.g., ~/.bash_history -> .histfiles/.bash_history.$HOSTNAME) */
 static int
-histfile_restore (backup, orig)
-     const char *backup;
-     const char *orig;
+histfile_restore (const char *backup, const char *orig)
 {
 #if defined (HAVE_READLINK)
   char linkbuf[PATH_MAX+1];
@@ -470,9 +477,7 @@ histfile_restore (backup, orig)
    If FNAME is NULL, then use ~/.history.  Writes a new file and renames
    it to the original name.  Returns 0 on success, errno on failure. */
 int
-history_truncate_file (fname, lines)
-     const char *fname;
-     int lines;
+history_truncate_file (const char *fname, int lines)
 {
   char *buffer, *filename, *tempname, *bp, *bp1;		/* bp1 == bp+1 */
   int file, chars_read, rv, orig_lines, exists, r;
@@ -625,9 +630,7 @@ history_truncate_file (fname, lines)
    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;
+history_do_write (const char *filename, int nelements, int overwrite)
 {
   register int i;
   char *output, *tempname, *histname;
@@ -773,9 +776,7 @@ mmap_error:
 /* 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;
+append_history (int nelements, const char *filename)
 {
   return (history_do_write (filename, nelements, HISTORY_APPEND));
 }
@@ -784,8 +785,7 @@ append_history (nelements, filename)
    then write the history list to ~/.history.  Values returned
    are as in read_history ().*/
 int
-write_history (filename)
-     const char *filename;
+write_history (const char *filename)
 {
   return (history_do_write (filename, history_length, HISTORY_OVERWRITE));
 }
diff --git a/history.c b/history.c
index ef293c7..67158b1 100644
--- a/history.c
+++ b/history.c
@@ -1,6 +1,6 @@
 /* history.c -- standalone history library */
 
-/* Copyright (C) 1989-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1989-2017 Free Software Foundation, Inc.
 
    This file contains the GNU History Library (History), a set of
    routines for managing the text of previously typed lines.
@@ -97,7 +97,7 @@ int history_base = 1;
 
 /* Return the current HISTORY_STATE of the history. */
 HISTORY_STATE *
-history_get_history_state ()
+history_get_history_state (void)
 {
   HISTORY_STATE *state;
 
@@ -115,8 +115,7 @@ history_get_history_state ()
 
 /* Set the state of the current history array to STATE. */
 void
-history_set_history_state (state)
-     HISTORY_STATE *state;
+history_set_history_state (HISTORY_STATE *state)
 {
   the_history = state->entries;
   history_offset = state->offset;
@@ -129,7 +128,7 @@ history_set_history_state (state)
 /* Begin a session in which the history functions might be used.  This
    initializes interactive variables. */
 void
-using_history ()
+using_history (void)
 {
   history_offset = history_length;
 }
@@ -138,7 +137,7 @@ using_history ()
    This just adds up the lengths of the_history->lines and the associated
    timestamps. */
 int
-history_total_bytes ()
+history_total_bytes (void)
 {
   register int i, result;
 
@@ -151,7 +150,7 @@ history_total_bytes ()
 /* Returns the magic number which says what history element we are
    looking at now.  In this implementation, it returns history_offset. */
 int
-where_history ()
+where_history (void)
 {
   return (history_offset);
 }
@@ -159,8 +158,7 @@ where_history ()
 /* Make the current history item be the one at POS, an absolute index.
    Returns zero if POS is out of range, else non-zero. */
 int
-history_set_pos (pos)
-     int pos;
+history_set_pos (int pos)
 {
   if (pos > history_length || pos < 0 || !the_history)
     return (0);
@@ -172,7 +170,7 @@ history_set_pos (pos)
    is the actual array of data, and could be bashed or made corrupt easily.
    The array is terminated with a NULL pointer. */
 HIST_ENTRY **
-history_list ()
+history_list (void)
 {
   return (the_history);
 }
@@ -180,7 +178,7 @@ history_list ()
 /* Return the history entry at the current position, as determined by
    history_offset.  If there is no entry there, return a NULL pointer. */
 HIST_ENTRY *
-current_history ()
+current_history (void)
 {
   return ((history_offset == history_length) || the_history == 0)
 		? (HIST_ENTRY *)NULL
@@ -191,7 +189,7 @@ current_history ()
    a pointer to that entry.  If there is no previous entry then return
    a NULL pointer. */
 HIST_ENTRY *
-previous_history ()
+previous_history (void)
 {
   return history_offset ? the_history[--history_offset] : (HIST_ENTRY *)NULL;
 }
@@ -200,7 +198,7 @@ previous_history ()
    a pointer to that entry.  If there is no next entry then return a
    NULL pointer. */
 HIST_ENTRY *
-next_history ()
+next_history (void)
 {
   return (history_offset == history_length) ? (HIST_ENTRY *)NULL : the_history[++history_offset];
 }
@@ -208,8 +206,7 @@ next_history ()
 /* Return the history entry which is logically at OFFSET in the history array.
    OFFSET is relative to history_base. */
 HIST_ENTRY *
-history_get (offset)
-     int offset;
+history_get (int offset)
 {
   int local_index;
 
@@ -220,9 +217,7 @@ history_get (offset)
 }
 
 HIST_ENTRY *
-alloc_history_entry (string, ts)
-     char *string;
-     char *ts;
+alloc_history_entry (char *string, char *ts)
 {
   HIST_ENTRY *temp;
 
@@ -236,8 +231,7 @@ alloc_history_entry (string, ts)
 }
 
 time_t
-history_get_time (hist)
-     HIST_ENTRY *hist;
+history_get_time (HIST_ENTRY *hist)
 {
   char *ts;
   time_t t;
@@ -255,7 +249,7 @@ history_get_time (hist)
 }
 
 static char *
-hist_inittime ()
+hist_inittime (void)
 {
   time_t t;
   char ts[64], *ret;
@@ -275,8 +269,7 @@ hist_inittime ()
 /* Place STRING at the end of the history list.  The data field
    is  set to NULL. */
 void
-add_history (string)
-     const char *string;
+add_history (const char *string)
 {
   HIST_ENTRY *temp;
   int new_length;
@@ -335,8 +328,7 @@ add_history (string)
 
 /* Change the time stamp of the most recent history entry to STRING. */
 void
-add_history_time (string)
-     const char *string;
+add_history_time (const char *string)
 {
   HIST_ENTRY *hs;
 
@@ -350,8 +342,7 @@ add_history_time (string)
 /* Free HIST and return the data so the calling application can free it
    if necessary and desired. */
 histdata_t
-free_history_entry (hist)
-     HIST_ENTRY *hist;
+free_history_entry (HIST_ENTRY *hist)
 {
   histdata_t x;
 
@@ -365,8 +356,7 @@ free_history_entry (hist)
 }
 
 HIST_ENTRY *
-copy_history_entry (hist)
-     HIST_ENTRY *hist;
+copy_history_entry (HIST_ENTRY *hist)
 {
   HIST_ENTRY *ret;
   char *ts;
@@ -388,10 +378,7 @@ copy_history_entry (hist)
    the old entry so you can dispose of the data.  In the case of an
    invalid WHICH, a NULL pointer is returned. */
 HIST_ENTRY *
-replace_history_entry (which, line, data)
-     int which;
-     const char *line;
-     histdata_t data;
+replace_history_entry (int which, const char *line, histdata_t data)
 {
   HIST_ENTRY *temp, *old_value;
 
@@ -413,9 +400,7 @@ replace_history_entry (which, line, data)
    end of the current line first.  This can be used to construct multi-line
    history entries while reading lines from the history file. */
 void
-_hs_append_history_line (which, line)
-     int which;
-     const char *line;
+_hs_append_history_line (int which, const char *line)
 {
   HIST_ENTRY *hent;
   size_t newlen, curlen, minlen;
@@ -451,9 +436,7 @@ _hs_append_history_line (which, line)
    WHICH >= 0 means to replace that particular history entry's data, as
    long as it matches OLD. */
 void
-_hs_replace_history_data (which, old, new)
-     int which;
-     histdata_t *old, *new;
+_hs_replace_history_data (int which, histdata_t *old, histdata_t *new)
 {
   HIST_ENTRY *entry;
   register int i, last;
@@ -493,8 +476,7 @@ _hs_replace_history_data (which, old, new)
    element is returned to you so you can free the line, data,
    and containing structure. */
 HIST_ENTRY *
-remove_history (which)
-     int which;
+remove_history (int which)
 {
   HIST_ENTRY *return_value;
   register int i;
@@ -526,8 +508,7 @@ remove_history (which)
 }
 
 HIST_ENTRY **
-remove_history_range (first, last)
-     int first, last;
+remove_history_range (int first, int last)
 {
   HIST_ENTRY **return_value;
   register int i;
@@ -564,8 +545,7 @@ remove_history_range (first, last)
 
 /* Stifle the history list, remembering only MAX number of lines. */
 void
-stifle_history (max)
-     int max;
+stifle_history (int max)
 {
   register int i, j;
 
@@ -593,7 +573,7 @@ stifle_history (max)
    number of history entries.  The value is positive if the history
    was stifled, negative if it wasn't. */
 int
-unstifle_history ()
+unstifle_history (void)
 {
   if (history_stifled)
     {
@@ -605,13 +585,13 @@ unstifle_history ()
 }
 
 int
-history_is_stifled ()
+history_is_stifled (void)
 {
   return (history_stifled);
 }
 
 void
-clear_history ()
+clear_history (void)
 {
   register int i;
 
diff --git a/histsearch.c b/histsearch.c
index ab18f97..b6771fd 100644
--- a/histsearch.c
+++ b/histsearch.c
@@ -1,6 +1,6 @@
 /* histsearch.c -- searching the history list. */
 
-/* Copyright (C) 1989, 1992-2009 Free Software Foundation, Inc.
+/* Copyright (C) 1989, 1992-2009,2017 Free Software Foundation, Inc.
 
    This file contains the GNU History Library (History), a set of
    routines for managing the text of previously typed lines.
@@ -64,9 +64,7 @@ static int history_search_internal PARAMS((const char *, int, int));
    returned. */
 
 static int
-history_search_internal (string, direction, flags)
-     const char *string;
-     int direction, flags;
+history_search_internal (const char *string, int direction, int flags)
 {
   register int i, reverse;
   register char *line;
@@ -198,9 +196,7 @@ history_search_internal (string, direction, flags)
 }
 
 int
-_hs_history_patsearch (string, direction, flags)
-     const char *string;
-     int direction, flags;
+_hs_history_patsearch (const char *string, int direction, int flags)
 {
   char *pat;
   size_t len;
@@ -244,18 +240,14 @@ _hs_history_patsearch (string, direction, flags)
 	
 /* Do a non-anchored search for STRING through the history in DIRECTION. */
 int
-history_search (string, direction)
-     const char *string;
-     int direction;
+history_search (const char *string, int direction)
 {
   return (history_search_internal (string, direction, NON_ANCHORED_SEARCH));
 }
 
 /* Do an anchored search for string through the history in DIRECTION. */
 int
-history_search_prefix (string, direction)
-     const char *string;
-     int direction;
+history_search_prefix (const char *string, int direction)
 {
   return (history_search_internal (string, direction, ANCHORED_SEARCH));
 }
@@ -264,9 +256,7 @@ history_search_prefix (string, direction)
    backwards.  POS is an absolute index into the history list at
    which point to begin searching. */
 int
-history_search_pos (string, dir, pos)
-     const char *string;
-     int dir, pos;
+history_search_pos (const char *string, int dir, int pos)
 {
   int ret, old;
 
diff --git a/input.c b/input.c
index 10ce4e0..b57bba6 100644
--- a/input.c
+++ b/input.c
@@ -1,6 +1,6 @@
 /* input.c -- character input functions for readline. */
 
-/* Copyright (C) 1994-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1994-2017 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.      
@@ -102,6 +102,7 @@ static int rl_gather_tyi PARAMS((void));
 /* Windows isatty returns true for every character device, including the null
    device, so we need to perform additional checks. */
 #if defined (_WIN32) && !defined (__CYGWIN__)
+#include <conio.h>
 #include <io.h>
 #define WIN32_LEAN_AND_MEAN 1
 #include <windows.h>
@@ -128,13 +129,13 @@ static int ibuffer_len = sizeof (ibuffer) - 1;
 #define any_typein (push_index != pop_index)
 
 int
-_rl_any_typein ()
+_rl_any_typein (void)
 {
   return any_typein;
 }
 
 int
-_rl_pushed_input_available ()
+_rl_pushed_input_available (void)
 {
   return (push_index != pop_index);
 }
@@ -142,7 +143,7 @@ _rl_pushed_input_available ()
 /* Return the amount of space available in the buffer for stuffing
    characters. */
 static int
-ibuffer_space ()
+ibuffer_space (void)
 {
   if (pop_index > push_index)
     return (pop_index - push_index - 1);
@@ -154,8 +155,7 @@ ibuffer_space ()
    Return the key in KEY.
    Result is non-zero if there was a key, or 0 if there wasn't. */
 static int
-rl_get_char (key)
-     int *key;
+rl_get_char (int *key)
 {
   if (push_index == pop_index)
     return (0);
@@ -175,8 +175,7 @@ rl_get_char (key)
    Returns non-zero if successful, zero if there is
    no space left in the buffer. */
 int
-_rl_unget_char (key)
-     int key;
+_rl_unget_char (int key)
 {
   if (ibuffer_space ())
     {
@@ -193,7 +192,7 @@ _rl_unget_char (key)
    IBUFFER.  Otherwise, just return.  Returns number of characters read
    (0 if none available) and -1 on error (EIO). */
 static int
-rl_gather_tyi ()
+rl_gather_tyi (void)
 {
   int tty;
   register int tem, result;
@@ -296,8 +295,7 @@ rl_gather_tyi ()
 }
 
 int
-rl_set_keyboard_input_timeout (u)
-     int u;
+rl_set_keyboard_input_timeout (int u)
 {
   int o;
 
@@ -314,7 +312,7 @@ rl_set_keyboard_input_timeout (u)
    the user, it should use _rl_input_queued(timeout_value_in_microseconds)
    instead. */
 int
-_rl_input_available ()
+_rl_input_available (void)
 {
 #if defined(HAVE_SELECT)
   fd_set readfds, exceptfds;
@@ -356,8 +354,7 @@ _rl_input_available ()
 }
 
 int
-_rl_input_queued (t)
-     int t;
+_rl_input_queued (int t)
 {
   int old_timeout, r;
 
@@ -368,8 +365,7 @@ _rl_input_queued (t)
 }
 
 void
-_rl_insert_typein (c)
-     int c;     
+_rl_insert_typein (int c)
 {    	
   int key, t, i;
   char *string;
@@ -394,8 +390,7 @@ _rl_insert_typein (c)
 /* Add KEY to the buffer of characters to be read.  Returns 1 if the
    character was stuffed correctly; 0 otherwise. */
 int
-rl_stuff_char (key)
-     int key;
+rl_stuff_char (int key)
 {
   if (ibuffer_space () == 0)
     return 0;
@@ -419,8 +414,7 @@ rl_stuff_char (key)
 
 /* Make C be the next command to be executed. */
 int
-rl_execute_next (c)
-     int c;
+rl_execute_next (int c)
 {
   rl_pending_input = c;
   RL_SETSTATE (RL_STATE_INPUTPENDING);
@@ -429,7 +423,7 @@ rl_execute_next (c)
 
 /* Clear any pending input pushed with rl_execute_next() */
 int
-rl_clear_pending_input ()
+rl_clear_pending_input (void)
 {
   rl_pending_input = 0;
   RL_UNSETSTATE (RL_STATE_INPUTPENDING);
@@ -444,20 +438,20 @@ rl_clear_pending_input ()
 
 /* Read a key, including pending input. */
 int
-rl_read_key ()
+rl_read_key (void)
 {
   int c, r;
 
   if (rl_pending_input)
     {
-      c = rl_pending_input;
+      c = rl_pending_input;	/* XXX - cast to unsigned char if > 0? */
       rl_clear_pending_input ();
     }
   else
     {
       /* If input is coming from a macro, then use that. */
       if (c = _rl_next_macro_key ())
-	return (c);
+	return ((unsigned char)c);
 
       /* If the user has an event function, then call it periodically. */
       if (rl_event_hook)
@@ -494,8 +488,7 @@ rl_read_key ()
 }
 
 int
-rl_getc (stream)
-     FILE *stream;
+rl_getc (FILE *stream)
 {
   int result;
   unsigned char c;
@@ -611,9 +604,7 @@ handle_error:
 #if defined (HANDLE_MULTIBYTE)
 /* read multibyte char */
 int
-_rl_read_mbchar (mbchar, size)
-     char *mbchar;
-     int size;
+_rl_read_mbchar (char *mbchar, int size)
 {
   int mb_len, c;
   size_t mbchar_bytes_length;
@@ -662,10 +653,7 @@ _rl_read_mbchar (mbchar, size)
    may be FIRST.  Used by the search functions, among others.  Very similar
    to _rl_read_mbchar. */
 int
-_rl_read_mbstring (first, mb, mlen)
-     int first;
-     char *mb;
-     int mlen;
+_rl_read_mbstring (int first, char *mb, int mlen)
 {
   int i, c;
   mbstate_t ps;
diff --git a/isearch.c b/isearch.c
index 819fcbc..10419cd 100644
--- a/isearch.c
+++ b/isearch.c
@@ -6,7 +6,7 @@
 /*								    */
 /* **************************************************************** */
 
-/* Copyright (C) 1987-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 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.      
@@ -78,8 +78,7 @@ static int last_isearch_string_len;
 static char * const default_isearch_terminators = "\033\012";
 
 _rl_search_cxt *
-_rl_scxt_alloc (type, flags)
-     int type, flags;
+_rl_scxt_alloc (int type, int flags)
 {
   _rl_search_cxt *cxt;
 
@@ -120,9 +119,7 @@ _rl_scxt_alloc (type, flags)
 }
 
 void
-_rl_scxt_dispose (cxt, flags)
-     _rl_search_cxt *cxt;
-     int flags;
+_rl_scxt_dispose (_rl_search_cxt *cxt, int flags)
 {
   FREE (cxt->search_string);
   FREE (cxt->allocated_line);
@@ -134,8 +131,7 @@ _rl_scxt_dispose (cxt, flags)
 /* Search backwards through the history looking for a string which is typed
    interactively.  Start with the current line. */
 int
-rl_reverse_search_history (sign, key)
-     int sign, key;
+rl_reverse_search_history (int sign, int key)
 {
   return (rl_search_history (-sign, key));
 }
@@ -143,8 +139,7 @@ rl_reverse_search_history (sign, key)
 /* Search forwards through the history looking for a string which is typed
    interactively.  Start with the current line. */
 int
-rl_forward_search_history (sign, key)
-     int sign, key;
+rl_forward_search_history (int sign, int key)
 {
   return (rl_search_history (sign, key));
 }
@@ -155,9 +150,7 @@ rl_forward_search_history (sign, key)
    WHERE is the history list number of the current line.  If it is
    -1, then this line is the starting one. */
 static void
-rl_display_search (search_string, flags, where)
-     char *search_string;
-     int flags, where;
+rl_display_search (char *search_string, int flags, int where)
 {
   char *message;
   int msglen, searchlen;
@@ -206,8 +199,7 @@ rl_display_search (search_string, flags, where)
 }
 
 static _rl_search_cxt *
-_rl_isearch_init (direction)
-     int direction;
+_rl_isearch_init (int direction)
 {
   _rl_search_cxt *cxt;
   register int i;
@@ -267,8 +259,7 @@ _rl_isearch_init (direction)
 }
 
 static void
-_rl_isearch_fini (cxt)
-     _rl_search_cxt *cxt;
+_rl_isearch_fini (_rl_search_cxt *cxt)
 {
   /* First put back the original state. */
   strcpy (rl_line_buffer, cxt->lines[cxt->save_line]);
@@ -306,8 +297,7 @@ _rl_isearch_fini (cxt)
 }
 
 int
-_rl_search_getchar (cxt)
-     _rl_search_cxt *cxt;
+_rl_search_getchar (_rl_search_cxt *cxt)
 {
   int c;
 
@@ -334,9 +324,7 @@ _rl_search_getchar (cxt)
    -1 if the caller should just free the context and return, 0 if we should
    break out of the loop, and 1 if we should continue to read characters. */
 int
-_rl_isearch_dispatch (cxt, c)
-     _rl_search_cxt *cxt;
-     int c;
+_rl_isearch_dispatch (_rl_search_cxt *cxt, int c)
 {
   int n, wstart, wlen, limit, cval;
   rl_command_func_t *f;
@@ -734,9 +722,7 @@ add_character:
 }
 
 int
-_rl_isearch_cleanup (cxt, r)
-     _rl_search_cxt *cxt;
-     int r;
+_rl_isearch_cleanup (_rl_search_cxt *cxt, int r)
 {
   if (r >= 0)
     _rl_isearch_fini (cxt);
@@ -753,8 +739,7 @@ _rl_isearch_cleanup (cxt, r)
    DIRECTION is which direction to search; >= 0 means forward, < 0 means
    backwards. */
 static int
-rl_search_history (direction, invoking_key)
-     int direction, invoking_key;
+rl_search_history (int direction, int invoking_key)
 {
   _rl_search_cxt *cxt;		/* local for now, but saved globally */
   int c, r;
@@ -792,8 +777,7 @@ rl_search_history (direction, invoking_key)
    If _rl_isearch_dispatch finishes searching, this function is responsible
    for turning off RL_STATE_ISEARCH, which it does using _rl_isearch_cleanup. */
 int
-_rl_isearch_callback (cxt)
-     _rl_search_cxt *cxt;
+_rl_isearch_callback (_rl_search_cxt *cxt)
 {
   int c, r;
 
diff --git a/keymaps.c b/keymaps.c
index 58661e2..0400668 100644
--- a/keymaps.c
+++ b/keymaps.c
@@ -1,6 +1,6 @@
 /* keymaps.c -- Functions and keymaps for the GNU Readline library. */
 
-/* Copyright (C) 1988,1989-2009 Free Software Foundation, Inc.
+/* Copyright (C) 1988,1989-2009,2017 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.      
@@ -54,7 +54,7 @@
 /* Return a new, empty keymap.
    Free it with free() when you are done. */
 Keymap
-rl_make_bare_keymap ()
+rl_make_bare_keymap (void)
 {
   register int i;
   Keymap keymap;
@@ -80,8 +80,7 @@ rl_make_bare_keymap ()
 /* Return a new keymap which is a copy of MAP.  Just copies pointers, does
    not copy text of macros or descend into child keymaps. */
 Keymap
-rl_copy_keymap (map)
-     Keymap map;
+rl_copy_keymap (Keymap map)
 {
   register int i;
   Keymap temp;
@@ -99,7 +98,7 @@ rl_copy_keymap (map)
    the uppercase Meta characters bound to run their lowercase equivalents,
    and the Meta digits bound to produce numeric arguments. */
 Keymap
-rl_make_keymap ()
+rl_make_keymap (void)
 {
   register int i;
   Keymap newmap;
@@ -125,8 +124,7 @@ rl_make_keymap ()
 
 /* Free the storage associated with MAP. */
 void
-rl_discard_keymap (map)
-     Keymap map;
+rl_discard_keymap (Keymap map)
 {
   int i;
 
@@ -154,8 +152,7 @@ rl_discard_keymap (map)
 
 /* Convenience function that discards, then frees, MAP. */
 void
-rl_free_keymap (map)
-     Keymap map;
+rl_free_keymap (Keymap map)
 {
   rl_discard_keymap (map);
   xfree ((char *)map);
diff --git a/kill.c b/kill.c
index 696f193..65ab7e9 100644
--- a/kill.c
+++ b/kill.c
@@ -1,6 +1,6 @@
 /* kill.c -- kill ring management. */
 
-/* Copyright (C) 1994-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1994-2017 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.      
@@ -78,8 +78,7 @@ static int rl_yank_nth_arg_internal PARAMS((int, int, int));
 /* How to say that you only want to save a certain amount
    of kill material. */
 int
-rl_set_retained_kills (num)
-     int num;
+rl_set_retained_kills (int num)
 {
   return 0;
 }
@@ -89,9 +88,7 @@ rl_set_retained_kills (num)
    non-zero, and the last command was a kill, the text is appended to the
    current kill ring slot, otherwise prepended. */
 static int
-_rl_copy_to_kill_ring (text, append)
-     char *text;
-     int append;
+_rl_copy_to_kill_ring (char *text, int append)
 {
   char *old, *new;
   int slot;
@@ -131,7 +128,7 @@ _rl_copy_to_kill_ring (text, append)
     slot = rl_kill_ring_length - 1;
 
   /* If the last command was a kill, prepend or append. */
-  if (_rl_last_command_was_kill && rl_editing_mode != vi_mode)
+  if (_rl_last_command_was_kill && rl_kill_ring[slot] && rl_editing_mode != vi_mode)
     {
       old = rl_kill_ring[slot];
       new = (char *)xmalloc (1 + strlen (old) + strlen (text));
@@ -163,8 +160,7 @@ _rl_copy_to_kill_ring (text, append)
    last command was not a kill command, then a new slot is made for
    this kill. */
 int
-rl_kill_text (from, to)
-     int from, to;
+rl_kill_text (int from, int to)
 {
   char *text;
 
@@ -198,8 +194,7 @@ rl_kill_text (from, to)
 
 /* Delete the word at point, saving the text in the kill ring. */
 int
-rl_kill_word (count, key)
-     int count, key;
+rl_kill_word (int count, int key)
 {
   int orig_point;
 
@@ -222,17 +217,16 @@ rl_kill_word (count, key)
 
 /* Rubout the word before point, placing it on the kill ring. */
 int
-rl_backward_kill_word (count, ignore)
-     int count, ignore;
+rl_backward_kill_word (int count, int key)
 {
   int orig_point;
 
   if (count < 0)
-    return (rl_kill_word (-count, ignore));
+    return (rl_kill_word (-count, key));
   else
     {
       orig_point = rl_point;
-      rl_backward_word (count, ignore);
+      rl_backward_word (count, key);
 
       if (rl_point != orig_point)
 	rl_kill_text (orig_point, rl_point);
@@ -246,17 +240,16 @@ rl_backward_kill_word (count, ignore)
 /* Kill from here to the end of the line.  If DIRECTION is negative, kill
    back to the line start instead. */
 int
-rl_kill_line (direction, ignore)
-     int direction, ignore;
+rl_kill_line (int direction, int key)
 {
   int orig_point;
 
   if (direction < 0)
-    return (rl_backward_kill_line (1, ignore));
+    return (rl_backward_kill_line (1, key));
   else
     {
       orig_point = rl_point;
-      rl_end_of_line (1, ignore);
+      rl_end_of_line (1, key);
       if (orig_point != rl_point)
 	rl_kill_text (orig_point, rl_point);
       rl_point = orig_point;
@@ -269,13 +262,12 @@ rl_kill_line (direction, ignore)
 /* Kill backwards to the start of the line.  If DIRECTION is negative, kill
    forwards to the line end instead. */
 int
-rl_backward_kill_line (direction, ignore)
-     int direction, ignore;
+rl_backward_kill_line (int direction, int key)
 {
   int orig_point;
 
   if (direction < 0)
-    return (rl_kill_line (1, ignore));
+    return (rl_kill_line (1, key));
   else
     {
       if (rl_point == 0)
@@ -283,7 +275,7 @@ rl_backward_kill_line (direction, ignore)
       else
 	{
 	  orig_point = rl_point;
-	  rl_beg_of_line (1, ignore);
+	  rl_beg_of_line (1, key);
 	  if (rl_point != orig_point)
 	    rl_kill_text (orig_point, rl_point);
 	  if (rl_editing_mode == emacs_mode)
@@ -295,8 +287,7 @@ rl_backward_kill_line (direction, ignore)
 
 /* Kill the whole line, no matter where point is. */
 int
-rl_kill_full_line (count, ignore)
-     int count, ignore;
+rl_kill_full_line (int count, int key)
 {
   rl_begin_undo_group ();
   rl_point = 0;
@@ -313,8 +304,7 @@ rl_kill_full_line (count, ignore)
 /* This does what C-w does in Unix.  We can't prevent people from
    using behaviour that they expect. */
 int
-rl_unix_word_rubout (count, key)
-     int count, key;
+rl_unix_word_rubout (int count, int key)
 {
   int orig_point;
 
@@ -346,8 +336,7 @@ rl_unix_word_rubout (count, key)
 /* This deletes one filename component in a Unix pathname.  That is, it
    deletes backward to directory separator (`/') or whitespace.  */
 int
-rl_unix_filename_rubout (count, key)
-     int count, key;
+rl_unix_filename_rubout (int count, int key)
 {
   int orig_point, c;
 
@@ -390,8 +379,7 @@ rl_unix_filename_rubout (count, key)
    into the line at all, and if you aren't, then you know what you are
    doing. */
 int
-rl_unix_line_discard (count, key)
-     int count, key;
+rl_unix_line_discard (int count, int key)
 {
   if (rl_point == 0)
     rl_ding ();
@@ -408,8 +396,7 @@ rl_unix_line_discard (count, key)
 /* Copy the text in the `region' to the kill ring.  If DELETE is non-zero,
    delete the text from the line as well. */
 static int
-region_kill_internal (delete)
-     int delete;
+region_kill_internal (int delete)
 {
   char *text;
 
@@ -427,16 +414,14 @@ region_kill_internal (delete)
 
 /* Copy the text in the region to the kill ring. */
 int
-rl_copy_region_to_kill (count, ignore)
-     int count, ignore;
+rl_copy_region_to_kill (int count, int key)
 {
   return (region_kill_internal (0));
 }
 
 /* Kill the text between the point and mark. */
 int
-rl_kill_region (count, ignore)
-     int count, ignore;
+rl_kill_region (int count, int key)
 {
   int r, npoint;
 
@@ -450,8 +435,7 @@ rl_kill_region (count, ignore)
 /* Copy COUNT words to the kill ring.  DIR says which direction we look
    to find the words. */
 static int
-_rl_copy_word_as_kill (count, dir)
-     int count, dir;
+_rl_copy_word_as_kill (int count, int dir)
 {
   int om, op, r;
 
@@ -479,8 +463,7 @@ _rl_copy_word_as_kill (count, dir)
 }
 
 int
-rl_copy_forward_word (count, key)
-     int count, key;
+rl_copy_forward_word (int count, int key)
 {
   if (count < 0)
     return (rl_copy_backward_word (-count, key));
@@ -489,8 +472,7 @@ rl_copy_forward_word (count, key)
 }
 
 int
-rl_copy_backward_word (count, key)
-     int count, key;
+rl_copy_backward_word (int count, int key)
 {
   if (count < 0)
     return (rl_copy_forward_word (-count, key));
@@ -500,8 +482,7 @@ rl_copy_backward_word (count, key)
   
 /* Yank back the last killed text.  This ignores arguments. */
 int
-rl_yank (count, ignore)
-     int count, ignore;
+rl_yank (int count, int key)
 {
   if (rl_kill_ring == 0)
     {
@@ -519,8 +500,7 @@ rl_yank (count, ignore)
    delete that text from the line, rotate the index down, and
    yank back some other text. */
 int
-rl_yank_pop (count, key)
-     int count, key;
+rl_yank_pop (int count, int key)
 {
   int l, n;
 
@@ -552,8 +532,7 @@ rl_yank_pop (count, key)
 
 #if defined (VI_MODE)
 int
-rl_vi_yank_pop (count, key)
-     int count, key;
+rl_vi_yank_pop (int count, int key)
 {
   int l, n;
 
@@ -587,8 +566,7 @@ rl_vi_yank_pop (count, key)
 /* Yank the COUNTh argument from the previous history line, skipping
    HISTORY_SKIP lines before looking for the `previous line'. */
 static int
-rl_yank_nth_arg_internal (count, ignore, history_skip)
-     int count, ignore, history_skip;
+rl_yank_nth_arg_internal (int count, int key, int history_skip)
 {
   register HIST_ENTRY *entry;
   char *arg;
@@ -629,7 +607,7 @@ rl_yank_nth_arg_internal (count, ignore, history_skip)
      inserts it right *after* rl_point. */
   if (rl_editing_mode == vi_mode)
     {
-      rl_vi_append_mode (1, ignore);
+      rl_vi_append_mode (1, key);
       rl_insert_text (" ");
     }
 #endif /* VI_MODE */
@@ -643,18 +621,16 @@ rl_yank_nth_arg_internal (count, ignore, history_skip)
 
 /* Yank the COUNTth argument from the previous history line. */
 int
-rl_yank_nth_arg (count, ignore)
-     int count, ignore;
+rl_yank_nth_arg (int count, int key)
 {
-  return (rl_yank_nth_arg_internal (count, ignore, 0));
+  return (rl_yank_nth_arg_internal (count, key, 0));
 }
 
 /* Yank the last argument from the previous history line.  This `knows'
    how rl_yank_nth_arg treats a count of `$'.  With an argument, this
    behaves the same as rl_yank_nth_arg. */
 int
-rl_yank_last_arg (count, key)
-     int count, key;
+rl_yank_last_arg (int count, int key)
 {
   static int history_skip = 0;
   static int explicit_arg_p = 0;
@@ -695,8 +671,7 @@ rl_yank_last_arg (count, key)
    closing sequence and insert the pasted text as a single unit without
    interpretation. */
 int
-rl_bracketed_paste_begin (count, key)
-     int count, key;
+rl_bracketed_paste_begin (int count, int key)
 {
   int retval, c;
   size_t len, cap;
@@ -740,13 +715,12 @@ rl_bracketed_paste_begin (count, key)
   return (retval);
 }
 
-/* A special paste command for Windows users.. */
+/* A special paste command for Windows users. */
 #if defined (_WIN32)
 #include <windows.h>
 
 int
-rl_paste_from_clipboard (count, key)
-     int count, key;
+rl_paste_from_clipboard (int count, int key)
 {
   char *data, *ptr;
   int len;
diff --git a/macro.c b/macro.c
index 47525c7..92cc55c 100644
--- a/macro.c
+++ b/macro.c
@@ -1,6 +1,6 @@
 /* macro.c -- keyboard macros for readline. */
 
-/* Copyright (C) 1994-2009 Free Software Foundation, Inc.
+/* Copyright (C) 1994-2009,2017 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.      
@@ -90,8 +90,7 @@ static int macro_level = 0;
 /* Set up to read subsequent input from STRING.
    STRING is free ()'ed when we are done with it. */
 void
-_rl_with_macro_input (string)
-     char *string;
+_rl_with_macro_input (char *string)
 {
   if (macro_level > MAX_MACRO_LEVEL)
     {
@@ -112,7 +111,7 @@ _rl_with_macro_input (string)
 /* Return the next character available from a macro, or 0 if
    there are no macro characters. */
 int
-_rl_next_macro_key ()
+_rl_next_macro_key (void)
 {
   int c;
 
@@ -138,7 +137,7 @@ _rl_next_macro_key ()
 }
 
 int
-_rl_peek_macro_key ()
+_rl_peek_macro_key (void)
 {
   if (rl_executing_macro == 0)
     return (0);
@@ -150,7 +149,7 @@ _rl_peek_macro_key ()
 }
 
 int
-_rl_prev_macro_key ()
+_rl_prev_macro_key (void)
 {
   if (rl_executing_macro == 0)
     return (0);
@@ -164,7 +163,7 @@ _rl_prev_macro_key ()
 
 /* Save the currently executing macro on a stack of saved macros. */
 void
-_rl_push_executing_macro ()
+_rl_push_executing_macro (void)
 {
   struct saved_macro *saver;
 
@@ -181,7 +180,7 @@ _rl_push_executing_macro ()
 /* Discard the current macro, replacing it with the one
    on the top of the stack of saved macros. */
 void
-_rl_pop_executing_macro ()
+_rl_pop_executing_macro (void)
 {
   struct saved_macro *macro;
 
@@ -206,8 +205,7 @@ _rl_pop_executing_macro ()
 
 /* Add a character to the macro being built. */
 void
-_rl_add_macro_char (c)
-     int c;
+_rl_add_macro_char (int c)
 {
   if (current_macro_index + 1 >= current_macro_size)
     {
@@ -222,7 +220,7 @@ _rl_add_macro_char (c)
 }
 
 void
-_rl_kill_kbd_macro ()
+_rl_kill_kbd_macro (void)
 {
   if (current_macro)
     {
@@ -245,8 +243,7 @@ _rl_kill_kbd_macro ()
    definition to the end of the existing macro, and start by
    re-executing the existing macro. */
 int
-rl_start_kbd_macro (ignore1, ignore2)
-     int ignore1, ignore2;
+rl_start_kbd_macro (int ignore1, int ignore2)
 {
   if (RL_ISSTATE (RL_STATE_MACRODEF))
     {
@@ -270,8 +267,7 @@ rl_start_kbd_macro (ignore1, ignore2)
    A numeric argument says to execute the macro right now,
    that many times, counting the definition as the first time. */
 int
-rl_end_kbd_macro (count, ignore)
-     int count, ignore;
+rl_end_kbd_macro (int count, int ignore)
 {
   if (RL_ISSTATE (RL_STATE_MACRODEF) == 0)
     {
@@ -290,8 +286,7 @@ rl_end_kbd_macro (count, ignore)
 /* Execute the most recently defined keyboard macro.
    COUNT says how many times to execute it. */
 int
-rl_call_last_kbd_macro (count, ignore)
-     int count, ignore;
+rl_call_last_kbd_macro (int count, int ignore)
 {
   if (current_macro == 0)
     _rl_abort_internal ();
@@ -309,8 +304,7 @@ rl_call_last_kbd_macro (count, ignore)
 }
 
 int
-rl_print_last_kbd_macro (count, ignore)
-     int count, ignore;
+rl_print_last_kbd_macro (int count, int ignore)
 {
   char *m;
 
@@ -332,8 +326,7 @@ rl_print_last_kbd_macro (count, ignore)
 }
 
 void
-rl_push_macro_input (macro)
-     char *macro;
+rl_push_macro_input (char *macro)
 {
   _rl_with_macro_input (macro);
 }
diff --git a/mbutil.c b/mbutil.c
index df1c484..fac1460 100644
--- a/mbutil.c
+++ b/mbutil.c
@@ -1,6 +1,6 @@
 /* mbutil.c -- readline multibyte character utility functions */
 
-/* Copyright (C) 2001-2015 Free Software Foundation, Inc.
+/* Copyright (C) 2001-2017 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.      
@@ -76,9 +76,7 @@ int _rl_utf8locale = 0;
 #if defined(HANDLE_MULTIBYTE)
 
 static int
-_rl_find_next_mbchar_internal (string, seed, count, find_non_zero)
-     char *string;
-     int seed, count, find_non_zero;
+_rl_find_next_mbchar_internal (char *string, int seed, int count, int find_non_zero)
 {
   size_t tmp, len;
   mbstate_t ps;
@@ -153,9 +151,7 @@ _rl_find_next_mbchar_internal (string, seed, count, find_non_zero)
 }
 
 /*static*/ int
-_rl_find_prev_mbchar_internal (string, seed, find_non_zero)
-     char *string;
-     int seed, find_non_zero;
+_rl_find_prev_mbchar_internal (char *string, int seed, int find_non_zero)
 {
   mbstate_t ps;
   int prev, non_zero_prev, point, length;
@@ -173,7 +169,14 @@ _rl_find_prev_mbchar_internal (string, seed, find_non_zero)
   prev = non_zero_prev = point = 0;
   while (point < seed)
     {
-      tmp = mbrtowc (&wc, string + point, length - point, &ps);
+      if (_rl_utf8locale && UTF8_SINGLEBYTE(string[point]))
+	{
+	  tmp = 1;
+	  wc = (wchar_t) string[point];
+	  memset(&ps, 0, sizeof(mbstate_t));
+	}
+      else
+	tmp = mbrtowc (&wc, string + point, length - point, &ps);
       if (MB_INVALIDCH ((size_t)tmp))
 	{
 	  /* in this case, bytes are invalid or too short to compose
@@ -213,9 +216,7 @@ _rl_find_prev_mbchar_internal (string, seed, find_non_zero)
    if an invalid multibyte sequence was encountered. It returns (size_t)(-2) 
    if it couldn't parse a complete  multibyte character.  */
 int
-_rl_get_char_len (src, ps)
-     char *src;
-     mbstate_t *ps;
+_rl_get_char_len (char *src, mbstate_t *ps)
 {
   size_t tmp;
 
@@ -244,13 +245,7 @@ _rl_get_char_len (src, ps)
 /* compare the specified two characters. If the characters matched,
    return 1. Otherwise return 0. */
 int
-_rl_compare_chars (buf1, pos1, ps1, buf2, pos2, ps2)
-     char *buf1;
-     int pos1;
-     mbstate_t *ps1;
-     char *buf2;
-     int pos2;
-     mbstate_t *ps2;
+_rl_compare_chars (char *buf1, int pos1, mbstate_t *ps1, char *buf2, int pos2, mbstate_t *ps2)
 {
   int i, w1, w2;
 
@@ -273,15 +268,13 @@ _rl_compare_chars (buf1, pos1, ps1, buf2, pos2, ps2)
    if point is invalied (point < 0 || more than string length),
    it returns -1 */
 int
-_rl_adjust_point (string, point, ps)
-     char *string;
-     int point;
-     mbstate_t *ps;
+_rl_adjust_point (char *string, int point, mbstate_t *ps)
 {
-  size_t tmp = 0;
-  int length;
-  int pos = 0;
+  size_t tmp;
+  int length, pos;
 
+  tmp = 0;
+  pos = 0;
   length = strlen(string);
   if (point < 0)
     return -1;
@@ -315,11 +308,7 @@ _rl_adjust_point (string, point, ps)
 }
 
 int
-_rl_is_mbchar_matched (string, seed, end, mbchar, length)
-     char *string;
-     int seed, end;
-     char *mbchar;
-     int length;
+_rl_is_mbchar_matched (char *string, int seed, int end, char *mbchar, int length)
 {
   int i;
 
@@ -333,9 +322,7 @@ _rl_is_mbchar_matched (string, seed, end, mbchar, length)
 }
 
 wchar_t
-_rl_char_value (buf, ind)
-     char *buf;
-     int ind;
+_rl_char_value (char *buf, int ind)
 {
   size_t tmp;
   wchar_t wc;
@@ -362,9 +349,7 @@ _rl_char_value (buf, ind)
    characters. */
 #undef _rl_find_next_mbchar
 int
-_rl_find_next_mbchar (string, seed, count, flags)
-     char *string;
-     int seed, count, flags;
+_rl_find_next_mbchar (char *string, int seed, int count, int flags)
 {
 #if defined (HANDLE_MULTIBYTE)
   return _rl_find_next_mbchar_internal (string, seed, count, flags);
@@ -378,9 +363,7 @@ _rl_find_next_mbchar (string, seed, count, flags)
    we look for non-zero-width multibyte characters. */
 #undef _rl_find_prev_mbchar
 int
-_rl_find_prev_mbchar (string, seed, flags)
-     char *string;
-     int seed, flags;
+_rl_find_prev_mbchar (char *string, int seed, int flags)
 {
 #if defined (HANDLE_MULTIBYTE)
   return _rl_find_prev_mbchar_internal (string, seed, flags);
diff --git a/misc.c b/misc.c
index f7acdee..716586c 100644
--- a/misc.c
+++ b/misc.c
@@ -1,6 +1,6 @@
 /* misc.c -- miscellaneous bindable readline functions. */
 
-/* Copyright (C) 1987-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 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.      
@@ -76,7 +76,7 @@ int _rl_history_saved_point = -1;
 /* **************************************************************** */
 
 int
-_rl_arg_overflow ()
+_rl_arg_overflow (void)
 {
   if (rl_numeric_arg > 1000000)
     {
@@ -92,7 +92,7 @@ _rl_arg_overflow ()
 }
 
 void
-_rl_arg_init ()
+_rl_arg_init (void)
 {
   rl_save_prompt ();
   _rl_argcxt = 0;
@@ -100,7 +100,7 @@ _rl_arg_init ()
 }
 
 int
-_rl_arg_getchar ()
+_rl_arg_getchar (void)
 {
   int c;
 
@@ -116,9 +116,7 @@ _rl_arg_getchar ()
    argument should be aborted, 0 if we should not read any more chars, and
    1 if we should continue to read chars. */
 int
-_rl_arg_dispatch (cxt, c)
-     _rl_arg_cxt cxt;
-     int c;
+_rl_arg_dispatch (_rl_arg_cxt cxt, int c)
 {
   int key, r;
 
@@ -193,7 +191,7 @@ _rl_arg_dispatch (cxt, c)
 
 /* Handle C-u style numeric args, as well as M--, and M-digits. */
 static int
-rl_digit_loop ()
+rl_digit_loop (void)
 {
   int c, r;
 
@@ -220,7 +218,7 @@ rl_digit_loop ()
 
 /* Create a default argument. */
 void
-_rl_reset_argument ()
+_rl_reset_argument (void)
 {
   rl_numeric_arg = rl_arg_sign = 1;
   rl_explicit_arg = 0;
@@ -229,8 +227,7 @@ _rl_reset_argument ()
 
 /* Start a numeric argument with initial value KEY */
 int
-rl_digit_argument (ignore, key)
-     int ignore, key;
+rl_digit_argument (int ignore, int key)
 {
   _rl_arg_init ();
   if (RL_ISSTATE (RL_STATE_CALLBACK))
@@ -250,8 +247,7 @@ rl_digit_argument (ignore, key)
    Read a key.  If the key has nothing to do with arguments, then
    dispatch on it.  If the key is the abort character then abort. */
 int
-rl_universal_argument (count, key)
-     int count, key;
+rl_universal_argument (int count, int key)
 {
   _rl_arg_init ();
   rl_numeric_arg *= 4;
@@ -260,8 +256,7 @@ rl_universal_argument (count, key)
 }
 
 int
-_rl_arg_callback (cxt)
-     _rl_arg_cxt cxt;
+_rl_arg_callback (_rl_arg_cxt cxt)
 {
   int c, r;
 
@@ -285,7 +280,7 @@ _rl_arg_callback (cxt)
 
 /* What to do when you abort reading an argument. */
 int
-rl_discard_argument ()
+rl_discard_argument (void)
 {
   rl_ding ();
   rl_clear_message ();
@@ -310,7 +305,7 @@ HIST_ENTRY *_rl_saved_line_for_history = (HIST_ENTRY *)NULL;
 
 /* Set the history pointer back to the last entry in the history. */
 void
-_rl_start_using_history ()
+_rl_start_using_history (void)
 {
   using_history ();
   if (_rl_saved_line_for_history)
@@ -321,8 +316,7 @@ _rl_start_using_history ()
 
 /* Free the contents (and containing structure) of a HIST_ENTRY. */
 void
-_rl_free_history_entry (entry)
-     HIST_ENTRY *entry;
+_rl_free_history_entry (HIST_ENTRY *entry)
 {
   if (entry == 0)
     return;
@@ -335,7 +329,7 @@ _rl_free_history_entry (entry)
 
 /* Perhaps put back the current line if it has changed. */
 int
-rl_maybe_replace_line ()
+rl_maybe_replace_line (void)
 {
   HIST_ENTRY *temp;
 
@@ -353,7 +347,7 @@ rl_maybe_replace_line ()
 
 /* Restore the _rl_saved_line_for_history if there is one. */
 int
-rl_maybe_unsave_line ()
+rl_maybe_unsave_line (void)
 {
   if (_rl_saved_line_for_history)
     {
@@ -372,7 +366,7 @@ rl_maybe_unsave_line ()
 
 /* Save the current line in _rl_saved_line_for_history. */
 int
-rl_maybe_save_line ()
+rl_maybe_save_line (void)
 {
   if (_rl_saved_line_for_history == 0)
     {
@@ -386,7 +380,7 @@ rl_maybe_save_line ()
 }
 
 int
-_rl_free_saved_history_line ()
+_rl_free_saved_history_line (void)
 {
   if (_rl_saved_line_for_history)
     {
@@ -397,7 +391,7 @@ _rl_free_saved_history_line ()
 }
 
 static void
-_rl_history_set_point ()
+_rl_history_set_point (void)
 {
   rl_point = (_rl_history_preserve_point && _rl_history_saved_point != -1)
 		? _rl_history_saved_point
@@ -415,9 +409,7 @@ _rl_history_set_point ()
 }
 
 void
-rl_replace_from_history (entry, flags)
-     HIST_ENTRY *entry;
-     int flags;			/* currently unused */
+rl_replace_from_history (HIST_ENTRY *entry, int flags)
 {
   /* Can't call with `1' because rl_undo_list might point to an undo list
      from a history entry, just like we're setting up here. */
@@ -441,7 +433,7 @@ rl_replace_from_history (entry, flags)
    intended to be called while actively editing, and the current line is
    not assumed to have been added to the history list. */
 void
-_rl_revert_all_lines ()
+_rl_revert_all_lines (void)
 {
   int hpos;
   HIST_ENTRY *entry;
@@ -490,7 +482,7 @@ _rl_revert_all_lines ()
    to an UNDO_LIST * saved as some history entry's data member.  This
    should not be called while editing is active. */
 void
-rl_clear_history ()
+rl_clear_history (void)
 {
   HIST_ENTRY **hlist, *hent;
   register int i;
@@ -524,16 +516,14 @@ rl_clear_history ()
 
 /* Meta-< goes to the start of the history. */
 int
-rl_beginning_of_history (count, key)
-     int count, key;
+rl_beginning_of_history (int count, int key)
 {
   return (rl_get_previous_history (1 + where_history (), key));
 }
 
 /* Meta-> goes to the end of the history.  (The current line). */
 int
-rl_end_of_history (count, key)
-     int count, key;
+rl_end_of_history (int count, int key)
 {
   rl_maybe_replace_line ();
   using_history ();
@@ -543,8 +533,7 @@ rl_end_of_history (count, key)
 
 /* Move down to the next history line. */
 int
-rl_get_next_history (count, key)
-     int count, key;
+rl_get_next_history (int count, int key)
 {
   HIST_ENTRY *temp;
 
@@ -582,15 +571,14 @@ rl_get_next_history (count, key)
 /* Get the previous item out of our interactive history, making it the current
    line.  If there is no previous history, just ding. */
 int
-rl_get_previous_history (count, key)
-     int count, key;
+rl_get_previous_history (int count, int key)
 {
   HIST_ENTRY *old_temp, *temp;
 
   if (count < 0)
     return (rl_get_next_history (-count, key));
 
-  if (count == 0)
+  if (count == 0 || history_list () == 0)
     return 0;
 
   /* either not saved by rl_newline or at end of line, so set appropriately. */
@@ -620,7 +608,10 @@ rl_get_previous_history (count, key)
     temp = old_temp;
 
   if (temp == 0)
-    rl_ding ();
+    {
+      rl_maybe_unsave_line ();
+      rl_ding ();
+    }
   else
     {
       rl_replace_from_history (temp, 0);
@@ -637,8 +628,7 @@ rl_get_previous_history (count, key)
 /* **************************************************************** */
 /* How to toggle back and forth between editing modes. */
 int
-rl_vi_editing_mode (count, key)
-     int count, key;
+rl_vi_editing_mode (int count, int key)
 {
 #if defined (VI_MODE)
   _rl_set_insert_mode (RL_IM_INSERT, 1);	/* vi mode ignores insert mode */
@@ -650,8 +640,7 @@ rl_vi_editing_mode (count, key)
 }
 
 int
-rl_emacs_editing_mode (count, key)
-     int count, key;
+rl_emacs_editing_mode (int count, int key)
 {
   rl_editing_mode = emacs_mode;
   _rl_set_insert_mode (RL_IM_INSERT, 1); /* emacs mode default is insert mode */
@@ -665,8 +654,7 @@ rl_emacs_editing_mode (count, key)
 
 /* Function for the rest of the library to use to set insert/overwrite mode. */
 void
-_rl_set_insert_mode (im, force)
-     int im, force;
+_rl_set_insert_mode (int im, int force)
 {
 #ifdef CURSOR_MODE
   _rl_set_cursor (im, force);
@@ -678,8 +666,7 @@ _rl_set_insert_mode (im, force)
 /* Toggle overwrite mode.  A positive explicit argument selects overwrite
    mode.  A negative or zero explicit argument selects insert mode. */
 int
-rl_overwrite_mode (count, key)
-     int count, key;
+rl_overwrite_mode (int count, int key)
 {
   if (rl_explicit_arg == 0)
     _rl_set_insert_mode (rl_insert_mode ^ 1, 0);
diff --git a/nls.c b/nls.c
index 7f3e2d8..d2f67e0 100644
--- a/nls.c
+++ b/nls.c
@@ -1,6 +1,6 @@
 /* nls.c -- skeletal internationalization code. */
 
-/* Copyright (C) 1996-2009 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2017 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.      
@@ -86,8 +86,7 @@ static char *find_codeset PARAMS((char *, size_t *));
 static char *_rl_get_locale_var PARAMS((const char *));
 
 static char *
-_rl_get_locale_var (v)
-     const char *v;
+_rl_get_locale_var (const char *v)
 {
   char *lspec;
 
@@ -101,8 +100,7 @@ _rl_get_locale_var (v)
 }
 
 static int
-utf8locale (lspec)
-     char *lspec;
+utf8locale (char *lspec)
 {
   char *cp;
   size_t len;
@@ -122,7 +120,7 @@ utf8locale (lspec)
 /* Query the right environment variables and call setlocale() to initialize
    the C library locale settings. */
 char *
-_rl_init_locale ()
+_rl_init_locale (void)
 {
   char *ret, *lspec;
 
@@ -148,7 +146,7 @@ _rl_init_locale ()
    to decide the defaults for 8-bit character input and output.  Returns
    1 if we set eight-bit mode. */
 int
-_rl_init_eightbit ()
+_rl_init_eightbit (void)
 {
 /* If we have setlocale(3), just check the current LC_CTYPE category
    value, and go into eight-bit mode if it's not C or POSIX. */
@@ -196,8 +194,7 @@ _rl_init_eightbit ()
 
 #if !defined (HAVE_SETLOCALE)
 static char *
-normalize_codeset (codeset)
-     char *codeset;
+normalize_codeset (char *codeset)
 {
   size_t namelen, i;
   int len, all_digits;
@@ -244,9 +241,7 @@ normalize_codeset (codeset)
 
 /* Isolate codeset portion of locale specification. */
 static char *
-find_codeset (name, lenp)
-     char *name;
-     size_t *lenp;
+find_codeset (char *name, size_t *lenp)
 {
   char *cp, *language, *result;
 
diff --git a/parens.c b/parens.c
index ecc465c..af47977 100644
--- a/parens.c
+++ b/parens.c
@@ -1,6 +1,6 @@
 /* parens.c -- implementation of matching parentheses feature. */
 
-/* Copyright (C) 1987, 1989, 1992-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1987, 1989, 1992-2015, 2017 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.      
@@ -64,8 +64,7 @@ static int _paren_blink_usec = 500000;
 /* Change emacs_standard_keymap to have bindings for paren matching when
    ON_OR_OFF is 1, change them back to self_insert when ON_OR_OFF == 0. */
 void
-_rl_enable_paren_matching (on_or_off)
-     int on_or_off;
+_rl_enable_paren_matching (int on_or_off)
 {
   if (on_or_off)
     {
@@ -98,8 +97,7 @@ _rl_enable_paren_matching (on_or_off)
 }
 
 int
-rl_set_paren_blink_timeout (u)
-     int u;
+rl_set_paren_blink_timeout (int u)
 {
   int o;
 
@@ -110,8 +108,7 @@ rl_set_paren_blink_timeout (u)
 }
 
 int
-rl_insert_close (count, invoking_key)
-     int count, invoking_key;
+rl_insert_close (int count, int invoking_key)
 {
   if (rl_explicit_arg || !rl_blink_matching_paren)
     _rl_insert_char (count, invoking_key);
@@ -148,9 +145,7 @@ rl_insert_close (count, invoking_key)
 }
 
 static int
-find_matching_open (string, from, closer)
-     char *string;
-     int from, closer;
+find_matching_open (char *string, int from, int closer)
 {
   register int i;
   int opener, level, delimiter;
diff --git a/parse-colors.c b/parse-colors.c
index 98b2e9d..05ec9bc 100644
--- a/parse-colors.c
+++ b/parse-colors.c
@@ -2,8 +2,8 @@
 
    Modified by Chet Ramey for Readline.
 
-   Copyright (C) 1985, 1988, 1990-1991, 1995-2010, 2012 Free Software Foundation,
-   Inc.
+   Copyright (C) 1985, 1988, 1990-1991, 1995-2010, 2012, 2017
+   Free Software Foundation, Inc.
 
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
@@ -297,7 +297,7 @@ get_funky_string (char **dest, const char **src, bool equals_end, size_t *output
 }
 #endif /* COLOR_SUPPORT */
 
-void _rl_parse_colors()
+void _rl_parse_colors(void)
 {
 #if defined (COLOR_SUPPORT)
   const char *p;		/* Pointer to character being parsed */
diff --git a/readline.c b/readline.c
index c022fb1..f174d5d 100644
--- a/readline.c
+++ b/readline.c
@@ -1,7 +1,7 @@
 /* readline.c -- a general facility for reading lines of input
    with emacs style editing and completion. */
 
-/* Copyright (C) 1987-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 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.      
@@ -325,8 +325,7 @@ int _rl_meta_flag = 0;	/* Forward declaration */
 /* Set up the prompt and expand it.  Called from readline() and
    rl_callback_handler_install (). */
 int
-rl_set_prompt (prompt)
-     const char *prompt;
+rl_set_prompt (const char *prompt)
 {
   FREE (rl_prompt);
   rl_prompt = prompt ? savestring (prompt) : (char *)NULL;
@@ -339,8 +338,7 @@ rl_set_prompt (prompt)
 /* Read a line of input.  Prompt with PROMPT.  An empty PROMPT means
    none.  A return value of NULL means that EOF was encountered. */
 char *
-readline (prompt)
-     const char *prompt;
+readline (const char *prompt)
 {
   char *value;
 #if 0
@@ -401,7 +399,7 @@ readline (prompt)
 #endif
 
 STATIC_CALLBACK void
-readline_internal_setup ()
+readline_internal_setup (void)
 {
   char *nprompt;
 
@@ -419,7 +417,10 @@ readline_internal_setup ()
 #if defined (VI_MODE)
   if (rl_editing_mode == vi_mode)
     rl_vi_insertion_mode (1, 'i');	/* don't want to reset last */
+  else
 #endif /* VI_MODE */
+    if (_rl_show_mode_in_prompt)
+      _rl_reset_prompt ();
 
   /* If we're not echoing, we still want to at least print a prompt, because
      rl_redisplay will not do it for us.  If the calling application has a
@@ -450,8 +451,7 @@ readline_internal_setup ()
 }
 
 STATIC_CALLBACK char *
-readline_internal_teardown (eof)
-     int eof;
+readline_internal_teardown (int eof)
 {
   char *temp;
   HIST_ENTRY *entry;
@@ -493,7 +493,7 @@ readline_internal_teardown (eof)
 }
 
 void
-_rl_internal_char_cleanup ()
+_rl_internal_char_cleanup (void)
 {
 #if defined (VI_MODE)
   /* In vi mode, when you exit insert mode, the cursor moves back
@@ -524,9 +524,9 @@ _rl_internal_char_cleanup ()
 
 STATIC_CALLBACK int
 #if defined (READLINE_CALLBACKS)
-readline_internal_char ()
+readline_internal_char (void)
 #else
-readline_internal_charloop ()
+readline_internal_charloop (void)
 #endif
 {
   static int lastc, eof_found;
@@ -648,7 +648,7 @@ readline_internal_charloop ()
 
 #if defined (READLINE_CALLBACKS)
 static int
-readline_internal_charloop ()
+readline_internal_charloop (void)
 {
   int eof = 1;
 
@@ -662,7 +662,7 @@ readline_internal_charloop ()
    the global rl_outstream.
    If rl_prompt is non-null, then that is our prompt. */
 static char *
-readline_internal ()
+readline_internal (void)
 {
   int eof;
 
@@ -672,7 +672,7 @@ readline_internal ()
 }
 
 void
-_rl_init_line_state ()
+_rl_init_line_state (void)
 {
   rl_point = rl_end = rl_mark = 0;
   the_line = rl_line_buffer;
@@ -680,14 +680,14 @@ _rl_init_line_state ()
 }
 
 void
-_rl_set_the_line ()
+_rl_set_the_line (void)
 {
   the_line = rl_line_buffer;
 }
 
 #if defined (READLINE_CALLBACKS)
 _rl_keyseq_cxt *
-_rl_keyseq_cxt_alloc ()
+_rl_keyseq_cxt_alloc (void)
 {
   _rl_keyseq_cxt *cxt;
 
@@ -703,14 +703,13 @@ _rl_keyseq_cxt_alloc ()
 }
 
 void
-_rl_keyseq_cxt_dispose (cxt)
-    _rl_keyseq_cxt *cxt;
+_rl_keyseq_cxt_dispose (_rl_keyseq_cxt *cxt)
 {
   xfree (cxt);
 }
 
 void
-_rl_keyseq_chain_dispose ()
+_rl_keyseq_chain_dispose (void)
 {
   _rl_keyseq_cxt *cxt;
 
@@ -724,8 +723,7 @@ _rl_keyseq_chain_dispose ()
 #endif
 
 static int
-_rl_subseq_getchar (key)
-     int key;
+_rl_subseq_getchar (int key)
 {
   int k;
 
@@ -742,8 +740,7 @@ _rl_subseq_getchar (key)
 
 #if defined (READLINE_CALLBACKS)
 int
-_rl_dispatch_callback (cxt)
-     _rl_keyseq_cxt *cxt;
+_rl_dispatch_callback (_rl_keyseq_cxt *cxt)
 {
   int nkey, r;
 
@@ -794,19 +791,14 @@ _rl_dispatch_callback (cxt)
    If the associated command is really a keymap, then read
    another key, and dispatch into that map. */
 int
-_rl_dispatch (key, map)
-     register int key;
-     Keymap map;
+_rl_dispatch (register int key, Keymap map)
 {
   _rl_dispatching_keymap = map;
   return _rl_dispatch_subseq (key, map, 0);
 }
 
 int
-_rl_dispatch_subseq (key, map, got_subseq)
-     register int key;
-     Keymap map;
-     int got_subseq;
+_rl_dispatch_subseq (register int key, Keymap map, int got_subseq)
 {
   int r, newkey;
   char *macro;
@@ -1023,10 +1015,7 @@ _rl_dispatch_subseq (key, map, got_subseq)
 }
 
 static int
-_rl_subseq_result (r, map, key, got_subseq)
-     int r;
-     Keymap map;
-     int key, got_subseq;
+_rl_subseq_result (int r, Keymap map, int key, int got_subseq)
 {
   Keymap m;
   int type, nt;
@@ -1078,7 +1067,7 @@ _rl_subseq_result (r, map, key, got_subseq)
       _rl_dispatching_keymap = map;
       return -2;
     }
-  else if (r && got_subseq)
+  else if (r < 0 && got_subseq)		/* XXX */
     {
       /* OK, back up the chain. */
       if (RL_ISSTATE (RL_STATE_MACROINPUT))
@@ -1100,7 +1089,7 @@ _rl_subseq_result (r, map, key, got_subseq)
 
 /* Initialize readline (and terminal if not already). */
 int
-rl_initialize ()
+rl_initialize (void)
 {
   /* If we have never been called before, initialize the
      terminal and data structures. */
@@ -1148,7 +1137,7 @@ rl_initialize ()
 #if 0
 #if defined (__EMX__)
 static void
-_emx_build_environ ()
+_emx_build_environ (void)
 {
   TIB *tibp;
   PIB *pibp;
@@ -1173,7 +1162,7 @@ _emx_build_environ ()
 
 /* Initialize the entire state of the world. */
 static void
-readline_initialize_everything ()
+readline_initialize_everything (void)
 {
 #if 0
 #if defined (__EMX__)
@@ -1258,7 +1247,7 @@ readline_initialize_everything ()
    input editing characters, then bind them to their readline
    equivalents, iff the characters are not bound to keymaps. */
 static void
-readline_default_bindings ()
+readline_default_bindings (void)
 {
   if (_rl_bind_stty_chars)
     rl_tty_set_default_bindings (_rl_keymap);
@@ -1267,7 +1256,7 @@ readline_default_bindings ()
 /* Reset the default bindings for the terminal special characters we're
    interested in back to rl_insert and read the new ones. */
 static void
-reset_default_bindings ()
+reset_default_bindings (void)
 {
   if (_rl_bind_stty_chars)
     {
@@ -1278,8 +1267,7 @@ reset_default_bindings ()
 
 /* Bind some common arrow key sequences in MAP. */
 static void
-bind_arrow_keys_internal (map)
-     Keymap map;
+bind_arrow_keys_internal (Keymap map)
 {
   Keymap xkeymap;
 
@@ -1307,6 +1295,15 @@ bind_arrow_keys_internal (map)
   rl_bind_keyseq_if_unbound ("\033OH", rl_beg_of_line);
   rl_bind_keyseq_if_unbound ("\033OF", rl_end_of_line);
 
+  /* Key bindings for control-arrow keys */
+  rl_bind_keyseq_if_unbound ("\033[1;5C", rl_forward_word);
+  rl_bind_keyseq_if_unbound ("\033[1;5D", rl_backward_word);
+  rl_bind_keyseq_if_unbound ("\033[3;5~", rl_kill_word);
+
+  /* Key bindings for alt-arrow keys */
+  rl_bind_keyseq_if_unbound ("\033[1;3C", rl_forward_word);
+  rl_bind_keyseq_if_unbound ("\033[1;3D", rl_backward_word);
+
 #if defined (__MINGW32__)
   rl_bind_keyseq_if_unbound ("\340H", rl_get_previous_history);
   rl_bind_keyseq_if_unbound ("\340P", rl_get_next_history);
@@ -1335,7 +1332,7 @@ bind_arrow_keys_internal (map)
    the inputrc file a chance to bind them and create `real' keymaps
    for the arrow key prefix. */
 static void
-bind_arrow_keys ()
+bind_arrow_keys (void)
 {
   bind_arrow_keys_internal (emacs_standard_keymap);
 
@@ -1350,7 +1347,7 @@ bind_arrow_keys ()
 }
 
 static void
-bind_bracketed_paste_prefix ()
+bind_bracketed_paste_prefix (void)
 {
   Keymap xkeymap;
 
@@ -1372,8 +1369,7 @@ bind_bracketed_paste_prefix ()
 /* **************************************************************** */
 
 int
-rl_save_state (sp)
-     struct readline_state *sp;
+rl_save_state (struct readline_state *sp)
 {
   if (sp == 0)
     return -1;
@@ -1413,8 +1409,7 @@ rl_save_state (sp)
 }
 
 int
-rl_restore_state (sp)
-     struct readline_state *sp;
+rl_restore_state (struct readline_state *sp)
 {
   if (sp == 0)
     return -1;
diff --git a/readline.h b/readline.h
index bc1e5b5..8af4e62 100644
--- a/readline.h
+++ b/readline.h
@@ -98,6 +98,9 @@ extern int rl_clear_screen PARAMS((int, int));
 extern int rl_skip_csi_sequence PARAMS((int, int));
 extern int rl_arrow_keys PARAMS((int, int));
 
+extern int rl_previous_screen_line PARAMS((int, int));
+extern int rl_next_screen_line PARAMS((int, int));
+
 /* Bindable commands for inserting and deleting text. */
 extern int rl_insert PARAMS((int, int));
 extern int rl_quoted_insert PARAMS((int, int));
diff --git a/rlconf.h b/rlconf.h
index 98c970a..b6d6a2f 100644
--- a/rlconf.h
+++ b/rlconf.h
@@ -42,7 +42,7 @@
 /* The next-to-last-ditch effort file name for a user-specific init file. */
 #define DEFAULT_INPUTRC "~/.inputrc"
 
-/* The ultimate last-ditch filenname for an init file -- system-wide. */
+/* The ultimate last-ditch filename for an init file -- system-wide. */
 #define SYS_INPUTRC "/etc/inputrc"
 
 /* If defined, expand tabs to spaces. */
diff --git a/rlmbutil.h b/rlmbutil.h
index 2d083b9..8b88de4 100644
--- a/rlmbutil.h
+++ b/rlmbutil.h
@@ -200,6 +200,10 @@ _rl_wcwidth (wc)
 
 #define UTF8_SINGLEBYTE(c)	(1)
 
+#if !defined (HAVE_WCHAR_T) && !defined (wchar_t)
+#  define wchar_t int
+#endif
+
 #endif /* !HANDLE_MULTIBYTE */
 
 extern int rl_byte_oriented;
diff --git a/rltty.c b/rltty.c
index b1c7929..6d777ad 100644
--- a/rltty.c
+++ b/rltty.c
@@ -1,7 +1,7 @@
 /* rltty.c -- functions to prepare and restore the terminal for readline's
    use. */
 
-/* Copyright (C) 1992-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2017 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.
@@ -130,8 +130,7 @@ static void prepare_terminal_settings PARAMS((int, TIOTYPE, TIOTYPE *));
 static void set_special_char PARAMS((Keymap, TIOTYPE *, int, rl_command_func_t *));
 
 static void
-save_tty_chars (tiop)
-     TIOTYPE *tiop;
+save_tty_chars (TIOTYPE *tiop)
 {
   _rl_last_tty_chars = _rl_tty_chars;
 
@@ -168,9 +167,7 @@ save_tty_chars (tiop)
 }
 
 static int
-get_tty_settings (tty, tiop)
-     int tty;
-     TIOTYPE *tiop;
+get_tty_settings (int tty, TIOTYPE *tiop)
 {
   set_winsize (tty);
 
@@ -200,9 +197,7 @@ get_tty_settings (tty, tiop)
 }
 
 static int
-set_tty_settings (tty, tiop)
-     int tty;
-     TIOTYPE *tiop;
+set_tty_settings (int tty, TIOTYPE *tiop)
 {
   if (tiop->flags & SGTTY_SET)
     {
@@ -239,9 +234,7 @@ set_tty_settings (tty, tiop)
 }
 
 static void
-prepare_terminal_settings (meta_flag, oldtio, tiop)
-     int meta_flag;
-     TIOTYPE oldtio, *tiop;
+prepare_terminal_settings (int meta_flag, TIOTYPE oldtio, TIOTYPE *tiop)
 {
   _rl_echoing_p = (oldtio.sgttyb.sg_flags & ECHO);
   _rl_echoctl = (oldtio.sgttyb.sg_flags & ECHOCTL);
@@ -357,8 +350,7 @@ static void _rl_bind_tty_special_chars PARAMS((Keymap, TIOTYPE));
 #endif
 
 static void
-save_tty_chars (tiop)
-     TIOTYPE *tiop;
+save_tty_chars (TIOTYPE *tiop)
 {
   _rl_last_tty_chars = _rl_tty_chars;
 
@@ -403,7 +395,7 @@ save_tty_chars (tiop)
 #if defined (_AIX) || defined (_AIX41)
 /* Currently this is only used on AIX */
 static void
-rltty_warning (msg)
+rltty_warning (char *msg)
      char *msg;
 {
   _rl_errmsg ("warning: %s", msg);
@@ -412,8 +404,7 @@ rltty_warning (msg)
 
 #if defined (_AIX)
 void
-setopost(tp)
-TIOTYPE *tp;
+setopost (TIOTYPE *tp)
 {
   if ((tp->c_oflag & OPOST) == 0)
     {
@@ -424,9 +415,7 @@ TIOTYPE *tp;
 #endif
 
 static int
-_get_tty_settings (tty, tiop)
-     int tty;
-     TIOTYPE *tiop;
+_get_tty_settings (int tty, TIOTYPE *tiop)
 {
   int ioctl_ret;
 
@@ -457,9 +446,7 @@ _get_tty_settings (tty, tiop)
 }
 
 static int
-get_tty_settings (tty, tiop)
-     int tty;
-     TIOTYPE *tiop;
+get_tty_settings (int tty, TIOTYPE *tiop)
 {
   set_winsize (tty);
 
@@ -475,9 +462,7 @@ get_tty_settings (tty, tiop)
 }
 
 static int
-_set_tty_settings (tty, tiop)
-     int tty;
-     TIOTYPE *tiop;
+_set_tty_settings (int tty, TIOTYPE *tiop)
 {
   while (SETATTR (tty, tiop) < 0)
     {
@@ -489,9 +474,7 @@ _set_tty_settings (tty, tiop)
 }
 
 static int
-set_tty_settings (tty, tiop)
-     int tty;
-     TIOTYPE *tiop;
+set_tty_settings (int tty, TIOTYPE *tiop)
 {
   if (_set_tty_settings (tty, tiop) < 0)
     return -1;
@@ -518,9 +501,7 @@ set_tty_settings (tty, tiop)
 }
 
 static void
-prepare_terminal_settings (meta_flag, oldtio, tiop)
-     int meta_flag;
-     TIOTYPE oldtio, *tiop;
+prepare_terminal_settings (int meta_flag, TIOTYPE oldtio, TIOTYPE *tiop)
 {
   _rl_echoing_p = (oldtio.c_lflag & ECHO);
 #if defined (ECHOCTL)
@@ -585,21 +566,19 @@ prepare_terminal_settings (meta_flag, oldtio, tiop)
 /* Put the terminal in CBREAK mode so that we can detect key presses. */
 #if defined (NO_TTY_DRIVER)
 void
-rl_prep_terminal (meta_flag)
-     int meta_flag;
+rl_prep_terminal (int meta_flag)
 {
   _rl_echoing_p = 1;
 }
 
 void
-rl_deprep_terminal ()
+rl_deprep_terminal (void)
 {
 }
 
 #else /* ! NO_TTY_DRIVER */
 void
-rl_prep_terminal (meta_flag)
-     int meta_flag;
+rl_prep_terminal (int meta_flag)
 {
   int tty, nprep;
   TIOTYPE tio;
@@ -682,7 +661,7 @@ rl_prep_terminal (meta_flag)
 
 /* Restore the terminal's normal settings and modes. */
 void
-rl_deprep_terminal ()
+rl_deprep_terminal (void)
 {
   int tty;
 
@@ -718,8 +697,7 @@ rl_deprep_terminal ()
 /* Set readline's idea of whether or not it is echoing output to the terminal,
    returning the old value. */
 int
-rl_tty_set_echoing (u)
-     int u;
+rl_tty_set_echoing (int u)
 {
   int o;
 
@@ -735,8 +713,7 @@ rl_tty_set_echoing (u)
 /* **************************************************************** */
 
 int
-rl_restart_output (count, key)
-     int count, key;
+rl_restart_output (int count, int key)
 {
 #if defined (__MINGW32__)
   return 0;
@@ -773,8 +750,7 @@ rl_restart_output (count, key)
 }
 
 int
-rl_stop_output (count, key)
-     int count, key;
+rl_stop_output (int count, int key)
 {
 #if defined (__MINGW32__)
   return 0;
@@ -822,11 +798,7 @@ rl_stop_output (count, key)
 
 #elif defined (NEW_TTY_DRIVER)
 static void
-set_special_char (kmap, tiop, sc, func)
-     Keymap kmap;
-     TIOTYPE *tiop;
-     int sc;
-     rl_command_func_t *func;
+set_special_char (Keymap kmap, TIOTYPE *tiop, int sc, rl_command_func_t *func)
 {
   if (sc != -1 && kmap[(unsigned char)sc].type == ISFUNC)
     kmap[(unsigned char)sc].function = func;
@@ -837,9 +809,7 @@ set_special_char (kmap, tiop, sc, func)
     kmap[(unsigned char)c].function = rl_insert;
 
 static void
-_rl_bind_tty_special_chars (kmap, ttybuff)
-     Keymap kmap;
-     TIOTYPE ttybuff;
+_rl_bind_tty_special_chars (Keymap kmap, TIOTYPE ttybuff)
 {
   if (ttybuff.flags & SGTTY_SET)
     {
@@ -858,11 +828,7 @@ _rl_bind_tty_special_chars (kmap, ttybuff)
 
 #else /* !NEW_TTY_DRIVER */
 static void
-set_special_char (kmap, tiop, sc, func)
-     Keymap kmap;
-     TIOTYPE *tiop;
-     int sc;
-     rl_command_func_t *func;
+set_special_char (Keymap kmap, TIOTYPE *tiop, int sc, rl_command_func_t *func)
 {
   unsigned char uc;
 
@@ -877,9 +843,7 @@ set_special_char (kmap, tiop, sc, func)
     kmap[uc].function = rl_insert;
 
 static void
-_rl_bind_tty_special_chars (kmap, ttybuff)
-     Keymap kmap;
-     TIOTYPE ttybuff;
+_rl_bind_tty_special_chars (Keymap kmap, TIOTYPE ttybuff)
 {
   SET_SPECIAL (VERASE, rl_rubout);
   SET_SPECIAL (VKILL, rl_unix_line_discard);
@@ -903,8 +867,7 @@ _rl_bind_tty_special_chars (kmap, ttybuff)
 /* Set the system's default editing characters to their readline equivalents
    in KMAP.  Should be static, now that we have rl_tty_set_default_bindings. */
 void
-rltty_set_default_bindings (kmap)
-     Keymap kmap;
+rltty_set_default_bindings (Keymap kmap)
 {
 #if !defined (NO_TTY_DRIVER)
   TIOTYPE ttybuff;
@@ -920,8 +883,7 @@ rltty_set_default_bindings (kmap)
 /* New public way to set the system default editing chars to their readline
    equivalents. */
 void
-rl_tty_set_default_bindings (kmap)
-     Keymap kmap;
+rl_tty_set_default_bindings (Keymap kmap)
 {
   rltty_set_default_bindings (kmap);
 }
@@ -931,8 +893,7 @@ rl_tty_set_default_bindings (kmap)
    chars with save_tty_chars().  This only works on POSIX termios or termio
    systems. */
 void
-rl_tty_unset_default_bindings (kmap)
-     Keymap kmap;
+rl_tty_unset_default_bindings (Keymap kmap)
 {
   /* Don't bother before we've saved the tty special chars at least once. */
   if (RL_ISSTATE(RL_STATE_TTYCSAVED) == 0)
@@ -954,13 +915,13 @@ rl_tty_unset_default_bindings (kmap)
 
 #if defined (NEW_TTY_DRIVER) || defined (NO_TTY_DRIVER)
 int
-_rl_disable_tty_signals ()
+_rl_disable_tty_signals (void)
 {
   return 0;
 }
 
 int
-_rl_restore_tty_signals ()
+_rl_restore_tty_signals (void)
 {
   return 0;
 }
@@ -970,7 +931,7 @@ static TIOTYPE sigstty, nosigstty;
 static int tty_sigs_disabled = 0;
 
 int
-_rl_disable_tty_signals ()
+_rl_disable_tty_signals (void)
 {
   if (tty_sigs_disabled)
     return 0;
@@ -991,7 +952,7 @@ _rl_disable_tty_signals ()
 }
 
 int
-_rl_restore_tty_signals ()
+_rl_restore_tty_signals (void)
 {
   int r;
 
diff --git a/savestring.c b/savestring.c
index af98538..f4bb6aa 100644
--- a/savestring.c
+++ b/savestring.c
@@ -1,6 +1,6 @@
 /* savestring.c - function version of savestring for backwards compatibility */
 
-/* Copyright (C) 1998,2003 Free Software Foundation, Inc.
+/* Copyright (C) 1998,2003,2017 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.      
@@ -30,8 +30,7 @@
 /* Backwards compatibility, now that savestring has been removed from
    all `public' readline header files. */
 char *
-savestring (s)
-     const char *s;
+savestring (const char *s)
 {
   char *ret;
 
diff --git a/search.c b/search.c
index 131d12d..6492561 100644
--- a/search.c
+++ b/search.c
@@ -1,6 +1,6 @@
 /* search.c - code for non-incremental searching in emacs and vi modes. */
 
-/* Copyright (C) 1992-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1992-2017 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.      
@@ -87,8 +87,7 @@ static int _rl_nsearch_dispatch PARAMS((_rl_search_cxt *, int));
    current line.  This doesn't do anything with rl_point; the caller
    must set it. */
 static void
-make_history_line_current (entry)
-     HIST_ENTRY *entry;
+make_history_line_current (HIST_ENTRY *entry)
 {
   _rl_replace_text (entry->line, 0, rl_end);
   _rl_fix_point (1);
@@ -112,10 +111,7 @@ make_history_line_current (entry)
    for STRING.  DIR < 0 means to search backwards through the history list,
    DIR >= 0 means to search forward. */
 static int
-noninc_search_from_pos (string, pos, dir, flags, ncp)
-     char *string;
-     int pos, dir, flags;
-     int *ncp;
+noninc_search_from_pos (char *string, int pos, int dir, int flags, int *ncp)
 {
   int ret, old, sflags;
   char *s;
@@ -161,10 +157,7 @@ noninc_search_from_pos (string, pos, dir, flags, ncp)
    search is backwards through previous entries, else through subsequent
    entries.  Returns 1 if the search was successful, 0 otherwise. */
 static int
-noninc_dosearch (string, dir, flags)
-     char *string;
-     int dir;
-     int flags;
+noninc_dosearch (char *string, int dir, int flags)
 {
   int oldpos, pos;
   HIST_ENTRY *entry;
@@ -207,8 +200,7 @@ noninc_dosearch (string, dir, flags)
 }
 
 static _rl_search_cxt *
-_rl_nsearch_init (dir, pchar)
-     int dir, pchar;
+_rl_nsearch_init (int dir, int pchar)
 {
   _rl_search_cxt *cxt;
   char *p;
@@ -247,9 +239,7 @@ _rl_nsearch_init (dir, pchar)
 }
 
 int
-_rl_nsearch_cleanup (cxt, r)
-     _rl_search_cxt *cxt;
-     int r;
+_rl_nsearch_cleanup (_rl_search_cxt *cxt, int r)
 {
   _rl_scxt_dispose (cxt, 0);
   _rl_nscxt = 0;
@@ -260,8 +250,7 @@ _rl_nsearch_cleanup (cxt, r)
 }
 
 static void
-_rl_nsearch_abort (cxt)
-     _rl_search_cxt *cxt;
+_rl_nsearch_abort (_rl_search_cxt *cxt)
 {
   rl_maybe_unsave_line ();
   rl_clear_message ();
@@ -276,10 +265,11 @@ _rl_nsearch_abort (cxt)
    if the caller should abort the search, 0 if we should break out of the
    loop, and 1 if we should continue to read characters. */
 static int
-_rl_nsearch_dispatch (cxt, c)
-     _rl_search_cxt *cxt;
-     int c;
+_rl_nsearch_dispatch (_rl_search_cxt *cxt, int c)
 {
+  if (c < 0)
+    c = CTRL ('C');  
+
   switch (c)
     {
     case CTRL('W'):
@@ -329,8 +319,7 @@ _rl_nsearch_dispatch (cxt, c)
    using _rl_nsearch_cleanup ().  Returns 1 if the search was successful,
    0 otherwise. */
 static int
-_rl_nsearch_dosearch (cxt)
-     _rl_search_cxt *cxt;
+_rl_nsearch_dosearch (_rl_search_cxt *cxt)
 {
   rl_mark = cxt->save_mark;
 
@@ -372,9 +361,7 @@ _rl_nsearch_dosearch (cxt)
    history list.  PCHAR is the character to use for prompting when reading
    the search string; if not specified (0), it defaults to `:'. */
 static int
-noninc_search (dir, pchar)
-     int dir;
-     int pchar;
+noninc_search (int dir, int pchar)
 {
   _rl_search_cxt *cxt;
   int c, r;
@@ -390,6 +377,12 @@ noninc_search (dir, pchar)
     {
       c = _rl_search_getchar (cxt);
 
+      if (c < 0)
+	{
+	  _rl_nsearch_abort (cxt);
+	  return 1;
+	}
+	  
       if (c == 0)
 	break;
 
@@ -407,8 +400,7 @@ noninc_search (dir, pchar)
 /* Search forward through the history list for a string.  If the vi-mode
    code calls this, KEY will be `?'. */
 int
-rl_noninc_forward_search (count, key)
-     int count, key;
+rl_noninc_forward_search (int count, int key)
 {
   return noninc_search (1, (key == '?') ? '?' : 0);
 }
@@ -416,8 +408,7 @@ rl_noninc_forward_search (count, key)
 /* Reverse search the history list for a string.  If the vi-mode code
    calls this, KEY will be `/'. */
 int
-rl_noninc_reverse_search (count, key)
-     int count, key;
+rl_noninc_reverse_search (int count, int key)
 {
   return noninc_search (-1, (key == '/') ? '/' : 0);
 }
@@ -426,8 +417,7 @@ rl_noninc_reverse_search (count, key)
    for.  If there is no saved search string, abort.  If the vi-mode code
    calls this, KEY will be `N'. */
 int
-rl_noninc_forward_search_again (count, key)
-     int count, key;
+rl_noninc_forward_search_again (int count, int key)
 {
   int r;
 
@@ -449,8 +439,7 @@ rl_noninc_forward_search_again (count, key)
    for.  If there is no saved search string, abort.  If the vi-mode code
    calls this, KEY will be `n'. */
 int
-rl_noninc_reverse_search_again (count, key)
-     int count, key;
+rl_noninc_reverse_search_again (int count, int key)
 {
   int r;
 
@@ -470,12 +459,17 @@ rl_noninc_reverse_search_again (count, key)
 
 #if defined (READLINE_CALLBACKS)
 int
-_rl_nsearch_callback (cxt)
-     _rl_search_cxt *cxt;
+_rl_nsearch_callback (_rl_search_cxt *cxt)
 {
   int c, r;
 
   c = _rl_search_getchar (cxt);
+  if (c <= 0)
+    {
+      if (c < 0)
+        _rl_nsearch_abort (cxt);
+      return 1;
+    }
   r = _rl_nsearch_dispatch (cxt, c);
   if (r != 0)
     return 1;
@@ -486,8 +480,7 @@ _rl_nsearch_callback (cxt)
 #endif
   
 static int
-rl_history_search_internal (count, dir)
-     int count, dir;
+rl_history_search_internal (int count, int dir)
 {
   HIST_ENTRY *temp;
   int ret, oldpos, newcol;
@@ -565,8 +558,7 @@ rl_history_search_internal (count, dir)
 }
 
 static void
-rl_history_search_reinit (flags)
-     int flags;
+rl_history_search_reinit (int flags)
 {
   int sind;
 
@@ -596,8 +588,7 @@ rl_history_search_reinit (flags)
    from the start of the line to rl_point.  This is a non-incremental
    search.  The search is anchored to the beginning of the history line. */
 int
-rl_history_search_forward (count, ignore)
-     int count, ignore;
+rl_history_search_forward (int count, int ignore)
 {
   if (count == 0)
     return (0);
@@ -615,8 +606,7 @@ rl_history_search_forward (count, ignore)
    from the start of the line to rl_point.  This is a non-incremental
    search. */
 int
-rl_history_search_backward (count, ignore)
-     int count, ignore;
+rl_history_search_backward (int count, int ignore)
 {
   if (count == 0)
     return (0);
@@ -635,8 +625,7 @@ rl_history_search_backward (count, ignore)
    search.  The search succeeds if the search string is present anywhere
    in the history line. */
 int
-rl_history_substr_search_forward (count, ignore)
-     int count, ignore;
+rl_history_substr_search_forward (int count, int ignore)
 {
   if (count == 0)
     return (0);
@@ -654,8 +643,7 @@ rl_history_substr_search_forward (count, ignore)
    from the start of the line to rl_point.  This is a non-incremental
    search. */
 int
-rl_history_substr_search_backward (count, ignore)
-     int count, ignore;
+rl_history_substr_search_backward (int count, int ignore)
 {
   if (count == 0)
     return (0);
diff --git a/shell.c b/shell.c
index 6947295..7fe2e97 100644
--- a/shell.c
+++ b/shell.c
@@ -1,7 +1,7 @@
 /* shell.c -- readline utility functions that are normally provided by
 	      bash when readline is linked as part of the shell. */
 
-/* Copyright (C) 1997-2009 Free Software Foundation, Inc.
+/* Copyright (C) 1997-2009,2017 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.      
@@ -92,8 +92,7 @@ extern struct passwd *getpwuid PARAMS((uid_t));
 
 /* Does shell-like quoting using single quotes. */
 char *
-sh_single_quote (string)
-     char *string;
+sh_single_quote (char *string)
 {
   register int c;
   char *result, *r, *s;
@@ -127,8 +126,7 @@ static char putenv_buf1[INT_STRLEN_BOUND (int) + 6 + 1];	/* sizeof("LINES=") ==
 static char putenv_buf2[INT_STRLEN_BOUND (int) + 8 + 1];	/* sizeof("COLUMNS=") == 8 */
 
 void
-sh_set_lines_and_columns (lines, cols)
-     int lines, cols;
+sh_set_lines_and_columns (int lines, int cols)
 {
 #if defined (HAVE_SETENV)
   sprintf (setenv_buf, "%d", lines);
@@ -148,14 +146,13 @@ sh_set_lines_and_columns (lines, cols)
 }
 
 char *
-sh_get_env_value (varname)
-     const char *varname;
+sh_get_env_value (const char *varname)
 {
   return ((char *)getenv (varname));
 }
 
 char *
-sh_get_home_dir ()
+sh_get_home_dir (void)
 {
   static char *home_dir = (char *)NULL;
   struct passwd *entry;
@@ -188,8 +185,7 @@ sh_get_home_dir ()
 #endif
 
 int
-sh_unset_nodelay_mode (fd)
-     int fd;
+sh_unset_nodelay_mode (int fd)
 {
 #if defined (HAVE_FCNTL)
   int flags, bflags;
diff --git a/signals.c b/signals.c
index 768c5d1..fcf45b7 100644
--- a/signals.c
+++ b/signals.c
@@ -1,6 +1,6 @@
 /* signals.c -- signal handling support for readline. */
 
-/* Copyright (C) 1987-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 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.      
@@ -138,8 +138,7 @@ void *_rl_sigcleanarg;
 
 /* Called from RL_CHECK_SIGNALS() macro */
 RETSIGTYPE
-_rl_signal_handler (sig)
-     int sig;
+_rl_signal_handler (int sig)
 {
   _rl_caught_signal = 0;	/* XXX */
 
@@ -162,8 +161,7 @@ _rl_signal_handler (sig)
 }
 
 static RETSIGTYPE
-rl_signal_handler (sig)
-     int sig;
+rl_signal_handler (int sig)
 {
   if (_rl_interrupt_immediately)
     {
@@ -177,8 +175,7 @@ rl_signal_handler (sig)
 }
 
 static RETSIGTYPE
-_rl_handle_signal (sig)
-     int sig;
+_rl_handle_signal (int sig)
 {
 #if defined (HAVE_POSIX_SIGNALS)
   sigset_t set;
@@ -293,8 +290,7 @@ _rl_handle_signal (sig)
 
 #if defined (SIGWINCH)
 static RETSIGTYPE
-rl_sigwinch_handler (sig)
-     int sig;
+rl_sigwinch_handler (int sig)
 {
   SigHandler *oh;
 
@@ -325,9 +321,7 @@ rl_sigwinch_handler (sig)
 
 #if !defined (HAVE_POSIX_SIGNALS)
 static int
-rl_sigaction (sig, nh, oh)
-     int sig;
-     sighandler_cxt *nh, *oh;
+rl_sigaction (int sig, sighandler_cxt *nh, sighandler_cxt *oh)
 {
   oh->sa_handler = signal (sig, nh->sa_handler);
   return 0;
@@ -338,10 +332,7 @@ rl_sigaction (sig, nh, oh)
    information in OHANDLER.  Return the old signal handler, like
    signal(). */
 static SigHandler *
-rl_set_sighandler (sig, handler, ohandler)
-     int sig;
-     SigHandler *handler;
-     sighandler_cxt *ohandler;
+rl_set_sighandler (int sig, SigHandler *handler, sighandler_cxt *ohandler)
 {
   sighandler_cxt old_handler;
 #if defined (HAVE_POSIX_SIGNALS)
@@ -372,10 +363,7 @@ rl_set_sighandler (sig, handler, ohandler)
 /* Set disposition of SIG to HANDLER, returning old state in OHANDLER.  Don't
    change disposition if OHANDLER indicates the signal was ignored. */
 static void
-rl_maybe_set_sighandler (sig, handler, ohandler)
-     int sig;
-     SigHandler *handler;
-     sighandler_cxt *ohandler;
+rl_maybe_set_sighandler (int sig, SigHandler *handler, sighandler_cxt *ohandler)
 {
   sighandler_cxt dummy;
   SigHandler *oh;
@@ -392,9 +380,7 @@ rl_maybe_set_sighandler (sig, handler, ohandler)
    disposition was changed using rl_maybe_set_sighandler or for which the
    SIG_IGN check was performed inline (e.g., SIGALRM below). */
 static void
-rl_maybe_restore_sighandler (sig, handler)
-     int sig;
-     sighandler_cxt *handler;
+rl_maybe_restore_sighandler (int sig, sighandler_cxt *handler)
 {
   sighandler_cxt dummy;
 
@@ -405,7 +391,7 @@ rl_maybe_restore_sighandler (sig, handler)
 }
 
 int
-rl_set_signals ()
+rl_set_signals (void)
 {
   sighandler_cxt dummy;
   SigHandler *oh;
@@ -511,7 +497,7 @@ rl_set_signals ()
 }
 
 int
-rl_clear_signals ()
+rl_clear_signals (void)
 {
   sighandler_cxt dummy;
 
@@ -564,7 +550,7 @@ rl_clear_signals ()
 /* Clean up the terminal and readline state after catching a signal, before
    resending it to the calling application. */
 void
-rl_cleanup_after_signal ()
+rl_cleanup_after_signal (void)
 {
   _rl_clean_up_for_exit ();
   if (rl_deprep_term_function)
@@ -575,7 +561,7 @@ rl_cleanup_after_signal ()
 
 /* Reset the terminal and readline state after a signal handler returns. */
 void
-rl_reset_after_signal ()
+rl_reset_after_signal (void)
 {
   if (rl_prep_term_function)
     (*rl_prep_term_function) (_rl_meta_flag);
@@ -587,7 +573,7 @@ rl_reset_after_signal ()
    numeric arguments in process) after catching a signal, before calling
    rl_cleanup_after_signal(). */ 
 void
-rl_free_line_state ()
+rl_free_line_state (void)
 {
   register HIST_ENTRY *entry;
 
@@ -603,7 +589,7 @@ rl_free_line_state ()
 }
 
 int
-rl_pending_signal ()
+rl_pending_signal (void)
 {
   return (_rl_caught_signal);
 }
@@ -631,7 +617,7 @@ static int sigwinch_blocked;
 /* Cause SIGINT to not be delivered until the corresponding call to
    release_sigint(). */
 void
-_rl_block_sigint ()
+_rl_block_sigint (void)
 {
   if (sigint_blocked)
     return;
@@ -641,7 +627,7 @@ _rl_block_sigint ()
 
 /* Allow SIGINT to be delivered. */
 void
-_rl_release_sigint ()
+_rl_release_sigint (void)
 {
   if (sigint_blocked == 0)
     return;
@@ -653,7 +639,7 @@ _rl_release_sigint ()
 /* Cause SIGWINCH to not be delivered until the corresponding call to
    release_sigwinch(). */
 void
-_rl_block_sigwinch ()
+_rl_block_sigwinch (void)
 {
   if (sigwinch_blocked)
     return;
@@ -682,7 +668,7 @@ _rl_block_sigwinch ()
 
 /* Allow SIGWINCH to be delivered. */
 void
-_rl_release_sigwinch ()
+_rl_release_sigwinch (void)
 {
   if (sigwinch_blocked == 0)
     return;
@@ -712,8 +698,7 @@ _rl_release_sigwinch ()
 /*								    */
 /* **************************************************************** */
 void
-rl_echo_signal_char (sig)
-     int sig;
+rl_echo_signal_char (int sig)
 {
   char cstr[3];
   int cslen, c;
diff --git a/terminal.c b/terminal.c
index ef2884e..793fda3 100644
--- a/terminal.c
+++ b/terminal.c
@@ -1,6 +1,6 @@
 /* terminal.c -- controlling the terminal with termcap. */
 
-/* Copyright (C) 1996-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1996-2017 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.      
@@ -131,6 +131,7 @@ char *_rl_term_IC;
 char *_rl_term_dc;
 char *_rl_term_DC;
 
+/* How to move forward a char, non-destructively */
 char *_rl_term_forward_char;
 
 /* How to go up a line. */
@@ -188,8 +189,7 @@ int _rl_enable_meta = 1;
 
 #if defined (__EMX__)
 static void
-_emx_get_screensize (swp, shp)
-     int *swp, *shp;
+_emx_get_screensize (int *swp, int *shp)
 {
   int sz[2];
 
@@ -204,8 +204,7 @@ _emx_get_screensize (swp, shp)
 
 #if defined (__MINGW32__)
 static void
-_win_get_screensize (swp, shp)
-     int *swp, *shp;
+_win_get_screensize (int *swp, int *shp)
 {
   HANDLE hConOut;
   CONSOLE_SCREEN_BUFFER_INFO scr;
@@ -227,8 +226,7 @@ _win_get_screensize (swp, shp)
    values of $LINES and $COLUMNS.  The tests for TERM_STRING_BUFFER being
    non-null serve to check whether or not we have initialized termcap. */
 void
-_rl_get_screen_size (tty, ignore_env)
-     int tty, ignore_env;
+_rl_get_screen_size (int tty, int ignore_env)
 {
   char *ss;
 #if defined (TIOCGWINSZ)
@@ -318,8 +316,7 @@ _rl_get_screen_size (tty, ignore_env)
 }
 
 void
-_rl_set_screen_size (rows, cols)
-     int rows, cols;
+_rl_set_screen_size (int rows, int cols)
 {
   if (_rl_term_autowrap == -1)
     _rl_init_terminal_io (rl_terminal_name);
@@ -338,15 +335,13 @@ _rl_set_screen_size (rows, cols)
 }
 
 void
-rl_set_screen_size (rows, cols)
-     int rows, cols;
+rl_set_screen_size (int rows, int cols)
 {
   _rl_set_screen_size (rows, cols);
 }
 
 void
-rl_get_screen_size (rows, cols)
-     int *rows, *cols;
+rl_get_screen_size (int *rows, int *cols)
 {
   if (rows)
     *rows = _rl_screenheight;
@@ -355,19 +350,19 @@ rl_get_screen_size (rows, cols)
 }
 
 void
-rl_reset_screen_size ()
+rl_reset_screen_size (void)
 {
   _rl_get_screen_size (fileno (rl_instream), 0);
 }
 
 void
-_rl_sigwinch_resize_terminal ()
+_rl_sigwinch_resize_terminal (void)
 {
   _rl_get_screen_size (fileno (rl_instream), 1);
 }
 	
 void
-rl_resize_terminal ()
+rl_resize_terminal (void)
 {
   _rl_get_screen_size (fileno (rl_instream), 1);
   if (_rl_echoing_p)
@@ -424,8 +419,7 @@ static const struct _tc_string tc_strings[] =
 /* Read the desired terminal capability strings into BP.  The capabilities
    are described in the TC_STRINGS table. */
 static void
-get_term_capabilities (bp)
-     char **bp;
+get_term_capabilities (char **bp)
 {
 #if !defined (__DJGPP__)	/* XXX - doesn't DJGPP have a termcap library? */
   register int i;
@@ -437,8 +431,7 @@ get_term_capabilities (bp)
 }
 
 int
-_rl_init_terminal_io (terminal_name)
-     const char *terminal_name;
+_rl_init_terminal_io (const char *terminal_name)
 {
   const char *term;
   char *buffer;
@@ -584,8 +577,7 @@ _rl_init_terminal_io (terminal_name)
 
 /* Bind the arrow key sequences from the termcap description in MAP. */
 static void
-bind_termcap_arrow_keys (map)
-     Keymap map;
+bind_termcap_arrow_keys (Keymap map)
 {
   Keymap xkeymap;
 
@@ -606,8 +598,7 @@ bind_termcap_arrow_keys (map)
 }
 
 char *
-rl_get_termcap (cap)
-     const char *cap;
+rl_get_termcap (const char *cap)
 {
   register int i;
 
@@ -624,8 +615,7 @@ rl_get_termcap (cap)
 /* Re-initialize the terminal considering that the TERM/TERMCAP variable
    has changed. */
 int
-rl_reset_terminal (terminal_name)
-     const char *terminal_name;
+rl_reset_terminal (const char *terminal_name)
 {
   _rl_screenwidth = _rl_screenheight = 0;
   _rl_init_terminal_io (terminal_name);
@@ -635,15 +625,13 @@ rl_reset_terminal (terminal_name)
 /* A function for the use of tputs () */
 #ifdef _MINIX
 void
-_rl_output_character_function (c)
-     int c;
+_rl_output_character_function (int c)
 {
   putc (c, _rl_out_stream);
 }
 #else /* !_MINIX */
 int
-_rl_output_character_function (c)
-     int c;
+_rl_output_character_function (int c)
 {
   return putc (c, _rl_out_stream);
 }
@@ -651,17 +639,14 @@ _rl_output_character_function (c)
 
 /* Write COUNT characters from STRING to the output stream. */
 void
-_rl_output_some_chars (string, count)
-     const char *string;
-     int count;
+_rl_output_some_chars (const char *string, int count)
 {
   fwrite (string, 1, count, _rl_out_stream);
 }
 
 /* Move the cursor back. */
 int
-_rl_backspace (count)
-     int count;
+_rl_backspace (int count)
 {
   register int i;
 
@@ -678,7 +663,7 @@ _rl_backspace (count)
 
 /* Move to the start of the next line. */
 int
-rl_crlf ()
+rl_crlf (void)
 {
 #if defined (NEW_TTY_DRIVER) || defined (__MINT__)
   if (_rl_term_cr)
@@ -690,7 +675,7 @@ rl_crlf ()
 
 /* Ring the terminal bell. */
 int
-rl_ding ()
+rl_ding (void)
 {
   if (_rl_echoing_p)
     {
@@ -729,7 +714,7 @@ rl_ding ()
 static int enabled_meta = 0;	/* flag indicating we enabled meta mode */
 
 void
-_rl_enable_meta_key ()
+_rl_enable_meta_key (void)
 {
 #if !defined (__DJGPP__)
   if (term_has_meta && _rl_term_mm)
@@ -741,7 +726,7 @@ _rl_enable_meta_key ()
 }
 
 void
-_rl_disable_meta_key ()
+_rl_disable_meta_key (void)
 {
 #if !defined (__DJGPP__)
   if (term_has_meta && _rl_term_mo && enabled_meta)
@@ -753,8 +738,7 @@ _rl_disable_meta_key ()
 }
 
 void
-_rl_control_keypad (on)
-     int on;
+_rl_control_keypad (int on)
 {
 #if !defined (__DJGPP__)
   if (on && _rl_term_ks)
@@ -775,8 +759,7 @@ _rl_control_keypad (on)
    cursor.  Overwrite mode gets a very visible cursor.  Only does
    anything if we have both capabilities. */
 void
-_rl_set_cursor (im, force)
-     int im, force;
+_rl_set_cursor (int im, int force)
 {
 #ifndef __MSDOS__
   if (_rl_term_ve && _rl_term_vs)
diff --git a/text.c b/text.c
index e57344a..86a13b1 100644
--- a/text.c
+++ b/text.c
@@ -1,6 +1,6 @@
 /* text.c -- text handling commands for readline. */
 
-/* Copyright (C) 1987-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 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.      
@@ -83,8 +83,7 @@ int _rl_optimize_typeahead = 1;	/* rl_insert tries to read typeahead */
    way that you should do insertion.  _rl_insert_char () calls this
    function.  Returns the number of characters inserted. */
 int
-rl_insert_text (string)
-     const char *string;
+rl_insert_text (const char *string)
 {
   register int i, l;
 
@@ -121,8 +120,7 @@ rl_insert_text (string)
 /* Delete the string between FROM and TO.  FROM is inclusive, TO is not.
    Returns the number of characters deleted. */
 int
-rl_delete_text (from, to)
-     int from, to;
+rl_delete_text (int from, int to)
 {
   register char *text;
   register int diff, i;
@@ -172,8 +170,7 @@ rl_delete_text (from, to)
 	} while (0)
 
 void
-_rl_fix_point (fix_mark_too)
-     int fix_mark_too;
+_rl_fix_point (int fix_mark_too)
 {
   _RL_FIX_POINT (rl_point);
   if (fix_mark_too)
@@ -185,9 +182,7 @@ _rl_fix_point (fix_mark_too)
    TEXT.  The operation is undoable.  To replace the entire line in an
    undoable mode, use _rl_replace_text(text, 0, rl_end); */
 int
-_rl_replace_text (text, start, end)
-     const char *text;
-     int start, end;
+_rl_replace_text (const char *text, int start, int end)
 {
   int n;
 
@@ -206,9 +201,7 @@ _rl_replace_text (text, start, end)
 /* Replace the current line buffer contents with TEXT.  If CLEAR_UNDO is
    non-zero, we free the current undo list. */
 void
-rl_replace_line (text, clear_undo)
-     const char *text;
-     int clear_undo;
+rl_replace_line (const char *text, int clear_undo)
 {
   int len;
 
@@ -259,8 +252,7 @@ rl_replace_line (text, clear_undo)
 
 /* Move forward COUNT bytes. */
 int
-rl_forward_byte (count, key)
-     int count, key;
+rl_forward_byte (int count, int key)
 {
   if (count < 0)
     return (rl_backward_byte (-count, key));
@@ -292,8 +284,7 @@ rl_forward_byte (count, key)
 }
 
 int
-_rl_forward_char_internal (count)
-     int count;
+_rl_forward_char_internal (int count)
 {
   int point;
 
@@ -319,8 +310,7 @@ _rl_forward_char_internal (count)
 #if defined (HANDLE_MULTIBYTE)
 /* Move forward COUNT characters. */
 int
-rl_forward_char (count, key)
-     int count, key;
+rl_forward_char (int count, int key)
 {
   int point;
 
@@ -350,8 +340,7 @@ rl_forward_char (count, key)
 }
 #else /* !HANDLE_MULTIBYTE */
 int
-rl_forward_char (count, key)
-     int count, key;
+rl_forward_char (int count, int key)
 {
   return (rl_forward_byte (count, key));
 }
@@ -359,16 +348,14 @@ rl_forward_char (count, key)
   
 /* Backwards compatibility. */
 int
-rl_forward (count, key)
-     int count, key;
+rl_forward (int count, int key)
 {
   return (rl_forward_char (count, key));
 }
 
 /* Move backward COUNT bytes. */
 int
-rl_backward_byte (count, key)
-     int count, key;
+rl_backward_byte (int count, int key)
 {
   if (count < 0)
     return (rl_forward_byte (-count, key));
@@ -393,8 +380,7 @@ rl_backward_byte (count, key)
 #if defined (HANDLE_MULTIBYTE)
 /* Move backward COUNT characters. */
 int
-rl_backward_char (count, key)
-     int count, key;
+rl_backward_char (int count, int key)
 {
   int point;
 
@@ -426,8 +412,7 @@ rl_backward_char (count, key)
 }
 #else
 int
-rl_backward_char (count, key)
-     int count, key;
+rl_backward_char (int count, int key)
 {
   return (rl_backward_byte (count, key));
 }
@@ -435,16 +420,14 @@ rl_backward_char (count, key)
 
 /* Backwards compatibility. */
 int
-rl_backward (count, key)
-     int count, key;
+rl_backward (int count, int key)
 {
   return (rl_backward_char (count, key));
 }
 
 /* Move to the beginning of the line. */
 int
-rl_beg_of_line (count, key)
-     int count, key;
+rl_beg_of_line (int count, int key)
 {
   rl_point = 0;
   return 0;
@@ -452,8 +435,7 @@ rl_beg_of_line (count, key)
 
 /* Move to the end of the line. */
 int
-rl_end_of_line (count, key)
-     int count, key;
+rl_end_of_line (int count, int key)
 {
   rl_point = rl_end;
   return 0;
@@ -461,8 +443,7 @@ rl_end_of_line (count, key)
 
 /* Move forward a word.  We do what Emacs does.  Handles multibyte chars. */
 int
-rl_forward_word (count, key)
-     int count, key;
+rl_forward_word (int count, int key)
 {
   int c;
 
@@ -510,8 +491,7 @@ rl_forward_word (count, key)
 
 /* Move backward a word.  We do what Emacs does.  Handles multibyte chars. */
 int
-rl_backward_word (count, key)
-     int count, key;
+rl_backward_word (int count, int key)
 {
   int c, p;
 
@@ -560,8 +540,7 @@ rl_backward_word (count, key)
 
 /* Clear the current line.  Numeric argument to C-l does this. */
 int
-rl_refresh_line (ignore1, ignore2)
-     int ignore1, ignore2;
+rl_refresh_line (int ignore1, int ignore2)
 {
   int curr_line;
 
@@ -582,8 +561,7 @@ rl_refresh_line (ignore1, ignore2)
    the prompt and the current input line.  Given a numeric arg, redraw only
    the current line. */
 int
-rl_clear_screen (count, key)
-     int count, key;
+rl_clear_screen (int count, int key)
 {
   if (rl_explicit_arg)
     {
@@ -599,8 +577,25 @@ rl_clear_screen (count, key)
 }
 
 int
-rl_skip_csi_sequence (count, key)
-     int count, key;
+rl_previous_screen_line (int count, int key)
+{
+  int c;
+
+  c = _rl_term_autowrap ? _rl_screenwidth : (_rl_screenwidth + 1);
+  return (rl_backward_char (c, key));
+}
+
+int
+rl_next_screen_line (int count, int key)
+{
+  int c;
+
+  c = _rl_term_autowrap ? _rl_screenwidth : (_rl_screenwidth + 1);
+  return (rl_forward_char (c, key));
+}
+
+int
+rl_skip_csi_sequence (int count, int key)
 {
   int ch;
 
@@ -614,8 +609,7 @@ rl_skip_csi_sequence (count, key)
 }
 
 int
-rl_arrow_keys (count, c)
-     int count, c;
+rl_arrow_keys (int count, int key)
 {
   int ch;
 
@@ -672,8 +666,7 @@ static mbstate_t ps = {0};
    If C introduces a multibyte sequence, we read the whole sequence and
    then insert the multibyte char into the line buffer. */
 int
-_rl_insert_char (count, c)
-     int count, c;
+_rl_insert_char (int count, int c)
 {
   register int i;
   char *string;
@@ -879,8 +872,7 @@ _rl_insert_char (count, c)
    If C introduces a multibyte character sequence, read the entire sequence
    before starting the overwrite loop. */
 int
-_rl_overwrite_char (count, c)
-     int count, c;
+_rl_overwrite_char (int count, int c)
 {
   int i;
 #if defined (HANDLE_MULTIBYTE)
@@ -913,8 +905,7 @@ _rl_overwrite_char (count, c)
 }
 
 int
-rl_insert (count, c)
-     int count, c;
+rl_insert (int count, int c)
 {
   int r, n, x;
 
@@ -963,8 +954,7 @@ rl_insert (count, c)
 
 /* Insert the next typed character verbatim. */
 static int
-_rl_insert_next (count)
-     int count;
+_rl_insert_next (int count)
 {
   int c;
 
@@ -988,8 +978,7 @@ _rl_insert_next (count)
 
 #if defined (READLINE_CALLBACKS)
 static int
-_rl_insert_next_callback (data)
-     _rl_callback_generic_arg *data;
+_rl_insert_next_callback (_rl_callback_generic_arg *data)
 {
   int count;
 
@@ -1004,8 +993,7 @@ _rl_insert_next_callback (data)
 #endif
   
 int
-rl_quoted_insert (count, key)
-     int count, key;
+rl_quoted_insert (int count, int key)
 {
   /* Let's see...should the callback interface futz with signal handling? */
 #if defined (HANDLE_SIGNALS)
@@ -1027,8 +1015,7 @@ rl_quoted_insert (count, key)
 
 /* Insert a tab character. */
 int
-rl_tab_insert (count, key)
-     int count, key;
+rl_tab_insert (int count, int key)
 {
   return (_rl_insert_char (count, '\t'));
 }
@@ -1037,8 +1024,7 @@ rl_tab_insert (count, key)
    KEY is the key that invoked this command.  I guess it could have
    meaning in the future. */
 int
-rl_newline (count, key)
-     int count, key;
+rl_newline (int count, int key)
 {
   rl_done = 1;
 
@@ -1071,8 +1057,7 @@ rl_newline (count, key)
    is just a stub, you bind keys to it and the code in _rl_dispatch ()
    is special cased. */
 int
-rl_do_lowercase_version (ignore1, ignore2)
-     int ignore1, ignore2;
+rl_do_lowercase_version (int ignore1, int ignore2)
 {
   return 0;
 }
@@ -1081,8 +1066,7 @@ rl_do_lowercase_version (ignore1, ignore2)
    rubout in overwrite mode has one oddity:  it replaces a control
    character that's displayed as two characters (^X) with two spaces. */
 int
-_rl_overwrite_rubout (count, key)
-     int count, key;
+_rl_overwrite_rubout (int count, int key)
 {
   int opoint;
   int i, l;
@@ -1124,8 +1108,7 @@ _rl_overwrite_rubout (count, key)
   
 /* Rubout the character behind point. */
 int
-rl_rubout (count, key)
-     int count, key;
+rl_rubout (int count, int key)
 {
   if (count < 0)
     return (rl_delete (-count, key));
@@ -1143,8 +1126,7 @@ rl_rubout (count, key)
 }
 
 int
-_rl_rubout_char (count, key)
-     int count, key;
+_rl_rubout_char (int count, int key)
 {
   int orig_point;
   unsigned char c;
@@ -1189,8 +1171,7 @@ _rl_rubout_char (count, key)
 /* Delete the character under the cursor.  Given a numeric argument,
    kill that many characters instead. */
 int
-rl_delete (count, key)
-     int count, key;
+rl_delete (int count, int key)
 {
   int xpoint;
 
@@ -1227,8 +1208,7 @@ rl_delete (count, key)
    behind the cursor is deleted.  COUNT is obeyed and may be used
    to delete forward or backward that many characters. */      
 int
-rl_rubout_or_delete (count, key)
-     int count, key;
+rl_rubout_or_delete (int count, int key)
 {
   if (rl_end != 0 && rl_point == rl_end)
     return (_rl_rubout_char (count, key));
@@ -1238,8 +1218,7 @@ rl_rubout_or_delete (count, key)
 
 /* Delete all spaces and tabs around point. */
 int
-rl_delete_horizontal_space (count, ignore)
-     int count, ignore;
+rl_delete_horizontal_space (int count, int ignore)
 {
   int start;
 
@@ -1267,8 +1246,7 @@ rl_delete_horizontal_space (count, ignore)
    is caught before this is invoked, so this really does the same thing as
    delete-char-or-list-or-eof, as long as it's bound to the eof character. */
 int
-rl_delete_or_show_completions (count, key)
-     int count, key;
+rl_delete_or_show_completions (int count, int key)
 {
   if (rl_end != 0 && rl_point == rl_end)
     return (rl_possible_completions (count, key));
@@ -1283,8 +1261,7 @@ rl_delete_or_show_completions (count, key)
 /* Turn the current line into a comment in shell history.
    A K*rn shell style function. */
 int
-rl_insert_comment (count, key)
-     int count, key;
+rl_insert_comment (int count, int key)
 {
   char *rl_comment_text;
   int rl_comment_len;
@@ -1322,24 +1299,21 @@ rl_insert_comment (count, key)
 
 /* Uppercase the word at point. */
 int
-rl_upcase_word (count, key)
-     int count, key;
+rl_upcase_word (int count, int key)
 {
   return (rl_change_case (count, UpCase));
 }
 
 /* Lowercase the word at point. */
 int
-rl_downcase_word (count, key)
-     int count, key;
+rl_downcase_word (int count, int key)
 {
   return (rl_change_case (count, DownCase));
 }
 
 /* Upcase the first letter, downcase the rest. */
 int
-rl_capitalize_word (count, key)
-     int count, key;
+rl_capitalize_word (int count, int key)
 {
  return (rl_change_case (count, CapCase));
 }
@@ -1350,11 +1324,11 @@ rl_capitalize_word (count, key)
    If a negative argument is given, leave point where it started,
    otherwise, leave it where it moves to. */
 static int
-rl_change_case (count, op)
-     int count, op;
+rl_change_case (int count, int op)
 {
   int start, next, end;
-  int inword, c, nc, nop;
+  int inword, nc, nop;
+  wchar_t c;
 #if defined (HANDLE_MULTIBYTE)
   wchar_t wc, nwc;
   char mb[MB_LEN_MAX+1];
@@ -1404,7 +1378,10 @@ rl_change_case (count, op)
 	}
       else
 	nop = op;
-      if (MB_CUR_MAX == 1 || rl_byte_oriented || isascii ((unsigned char)c))
+      /* Can't check isascii here; some languages (e.g, Turkish) have
+	 multibyte upper and lower case equivalents of single-byte ascii
+	 characters */
+      if (MB_CUR_MAX == 1 || rl_byte_oriented)
 	{
 	  nc = (nop == UpCase) ? _rl_to_upper (c) : _rl_to_lower (c);
 	  rl_line_buffer[start] = nc;
@@ -1420,11 +1397,35 @@ rl_change_case (count, op)
 	  nwc = (nop == UpCase) ? _rl_to_wupper (wc) : _rl_to_wlower (wc);
 	  if  (nwc != wc)	/*  just skip unchanged characters */
 	    {
+	      char *s, *e;
 	      mlen = wcrtomb (mb, nwc, &mps);
 	      if (mlen > 0)
 		mb[mlen] = '\0';
-	      /* Assume the same width */
-	      strncpy (rl_line_buffer + start, mb, mlen);
+	      /* what to do if m != mlen? adjust below */
+	      /* m == length of old char, mlen == length of new char */
+	      s = rl_line_buffer + start;
+	      e = rl_line_buffer + rl_end;
+	      if (m == mlen)
+		memcpy (s, mb, mlen);
+	      else if (m > mlen)
+		{
+		  memcpy (s, mb, mlen);
+		  memmove (s + mlen, s + m, (e - s) - m);
+		  next -= m - mlen;	/* next char changes */
+		  end -= m - mlen;	/* end of word changes */
+		  rl_end -= m - mlen;	/* end of line changes */
+		  rl_line_buffer[rl_end] = 0;
+		}
+	      else if (m < mlen)
+		{
+		  rl_extend_line_buffer (mlen - m + 1);
+		  memmove (s + mlen, s + m, (e - s) - m);
+		  memcpy (s, mb, mlen);
+		  next += mlen - m;	/* next char changes */
+		  end += mlen - m;	/* end of word changes */
+		  rl_end += mlen - m;	/* end of line changes */
+		  rl_line_buffer[rl_end] = 0;
+		}
 	    }
 	}
 #endif
@@ -1445,8 +1446,7 @@ rl_change_case (count, op)
 /* Transpose the words at point.  If point is at the end of the line,
    transpose the two words before point. */
 int
-rl_transpose_words (count, key)
-     int count, key;
+rl_transpose_words (int count, int key)
 {
   char *word1, *word2;
   int w1_beg, w1_end, w2_beg, w2_end;
@@ -1506,8 +1506,7 @@ rl_transpose_words (count, key)
 /* Transpose the characters at point.  If point is at the end of the line,
    then transpose the characters before point. */
 int
-rl_transpose_chars (count, key)
-     int count, key;
+rl_transpose_chars (int count, int key)
 {
 #if defined (HANDLE_MULTIBYTE)
   char *dummy;
@@ -1571,13 +1570,9 @@ rl_transpose_chars (count, key)
 
 int
 #if defined (HANDLE_MULTIBYTE)
-_rl_char_search_internal (count, dir, smbchar, len)
-     int count, dir;
-     char *smbchar;
-     int len;
+_rl_char_search_internal (int count, int dir, char *smbchar, int len)
 #else
-_rl_char_search_internal (count, dir, schar)
-     int count, dir, schar;
+_rl_char_search_internal (int count, int dir, int schar)
 #endif
 {
   int pos, inc;
@@ -1641,8 +1636,7 @@ _rl_char_search_internal (count, dir, schar)
    that there are two separate versions of this function. */
 #if defined (HANDLE_MULTIBYTE)
 static int
-_rl_char_search (count, fdir, bdir)
-     int count, fdir, bdir;
+_rl_char_search (int count, int fdir, int bdir)
 {
   char mbchar[MB_LEN_MAX];
   int mb_len;
@@ -1659,8 +1653,7 @@ _rl_char_search (count, fdir, bdir)
 }
 #else /* !HANDLE_MULTIBYTE */
 static int
-_rl_char_search (count, fdir, bdir)
-     int count, fdir, bdir;
+_rl_char_search (int count, int fdir, int bdir)
 {
   int c;
 
@@ -1691,8 +1684,7 @@ _rl_char_search_callback (data)
 #endif
 
 int
-rl_char_search (count, key)
-     int count, key;
+rl_char_search (int count, int key)
 {
 #if defined (READLINE_CALLBACKS)
   if (RL_ISSTATE (RL_STATE_CALLBACK))
@@ -1709,8 +1701,7 @@ rl_char_search (count, key)
 }
 
 int
-rl_backward_char_search (count, key)
-     int count, key;
+rl_backward_char_search (int count, int key)
 {
 #if defined (READLINE_CALLBACKS)
   if (RL_ISSTATE (RL_STATE_CALLBACK))
@@ -1734,10 +1725,9 @@ rl_backward_char_search (count, key)
 
 /* Set the mark at POSITION. */
 int
-_rl_set_mark_at_pos (position)
-     int position;
+_rl_set_mark_at_pos (int position)
 {
-  if (position > rl_end)
+  if (position < 0 || position > rl_end)
     return 1;
 
   rl_mark = position;
@@ -1746,23 +1736,22 @@ _rl_set_mark_at_pos (position)
 
 /* A bindable command to set the mark. */
 int
-rl_set_mark (count, key)
-     int count, key;
+rl_set_mark (int count, int key)
 {
   return (_rl_set_mark_at_pos (rl_explicit_arg ? count : rl_point));
 }
 
 /* Exchange the position of mark and point. */
 int
-rl_exchange_point_and_mark (count, key)
-     int count, key;
+rl_exchange_point_and_mark (int count, int key)
 {
   if (rl_mark > rl_end)
     rl_mark = -1;
 
-  if (rl_mark == -1)
+  if (rl_mark < 0)
     {
       rl_ding ();
+      rl_mark = 0;		/* like _RL_FIX_POINT */
       return 1;
     }
   else
diff --git a/tilde.c b/tilde.c
index 95bc421..9d0f296 100644
--- a/tilde.c
+++ b/tilde.c
@@ -1,6 +1,6 @@
 /* tilde.c -- Tilde expansion code (~/foo := $HOME/foo). */
 
-/* Copyright (C) 1988-2009 Free Software Foundation, Inc.
+/* Copyright (C) 1988-2017 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.
@@ -125,9 +125,7 @@ static char *glue_prefix_and_suffix PARAMS((char *, const char *, int));
    the tilde which starts the expansion.  Place the length of the text
    which identified this tilde starter in LEN, excluding the tilde itself. */
 static int
-tilde_find_prefix (string, len)
-     const char *string;
-     int *len;
+tilde_find_prefix (const char *string, int *len)
 {
   register int i, j, string_len;
   register char **prefixes;
@@ -160,8 +158,7 @@ tilde_find_prefix (string, len)
 /* Find the end of a tilde expansion in STRING, and return the index of
    the character which ends the tilde definition.  */
 static int
-tilde_find_suffix (string)
-     const char *string;
+tilde_find_suffix (const char *string)
 {
   register int i, j, string_len;
   register char **suffixes;
@@ -189,8 +186,7 @@ tilde_find_suffix (string)
 
 /* Return a new string which is the result of tilde expanding STRING. */
 char *
-tilde_expand (string)
-     const char *string;
+tilde_expand (const char *string)
 {
   char *result;
   int result_size, result_index;
@@ -267,9 +263,7 @@ tilde_expand (string)
    non-null, the index of the end of the prefix into FNAME is returned in
    the location it points to. */
 static char *
-isolate_tilde_prefix (fname, lenp)
-     const char *fname;
-     int *lenp;
+isolate_tilde_prefix (const char *fname, int *lenp)
 {
   char *ret;
   int i;
@@ -293,9 +287,7 @@ isolate_tilde_prefix (fname, lenp)
    function.  Right now, it just calls tilde_find_suffix and allocates new
    memory, but it can be expanded to do different things later. */
 char *
-tilde_find_word (fname, flags, lenp)
-     const char *fname;
-     int flags, *lenp;
+tilde_find_word (const char *fname, int flags, int *lenp)
 {
   int x;
   char *r;
@@ -323,10 +315,7 @@ tilde_find_word (fname, flags, lenp)
 /* Return a string that is PREFIX concatenated with SUFFIX starting at
    SUFFIND. */
 static char *
-glue_prefix_and_suffix (prefix, suffix, suffind)
-     char *prefix;
-     const char *suffix;
-     int suffind;
+glue_prefix_and_suffix (char *prefix, const char *suffix, int suffind)
 {
   char *ret;
   int plen, slen;
@@ -344,8 +333,7 @@ glue_prefix_and_suffix (prefix, suffix, suffind)
    tilde.  If there is no expansion, call tilde_expansion_failure_hook.
    This always returns a newly-allocated string, never static storage. */
 char *
-tilde_expand_word (filename)
-     const char *filename;
+tilde_expand_word (const char *filename)
 {
   char *dirname, *expansion, *username;
   int user_len;
@@ -434,9 +422,7 @@ tilde_expand_word (filename)
 #undef NULL
 #include <stdio.h>
 
-main (argc, argv)
-     int argc;
-     char **argv;
+main (int argc, char **argv)
 {
   char *result, line[512];
   int done = 0;
@@ -464,11 +450,10 @@ main (argc, argv)
   exit (0);
 }
 
-static void memory_error_and_abort ();
+static void memory_error_and_abort (void);
 
 static void *
-xmalloc (bytes)
-     size_t bytes;
+xmalloc (size_t bytes)
 {
   void *temp = (char *)malloc (bytes);
 
@@ -478,9 +463,7 @@ xmalloc (bytes)
 }
 
 static void *
-xrealloc (pointer, bytes)
-     void *pointer;
-     int bytes;
+xrealloc (void *pointer, int bytes)
 {
   void *temp;
 
@@ -496,7 +479,7 @@ xrealloc (pointer, bytes)
 }
 
 static void
-memory_error_and_abort ()
+memory_error_and_abort (void)
 {
   fprintf (stderr, "readline: out of virtual memory\n");
   abort ();
diff --git a/undo.c b/undo.c
index 5836304..75874e5 100644
--- a/undo.c
+++ b/undo.c
@@ -1,6 +1,6 @@
 /* undo.c - manage list of changes to lines, offering opportunity to undo them */
 
-/* Copyright (C) 1987-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 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.      
@@ -68,10 +68,7 @@ UNDO_LIST *rl_undo_list = (UNDO_LIST *)NULL;
 /* **************************************************************** */
 
 static UNDO_LIST *
-alloc_undo_entry (what, start, end, text)
-     enum undo_code what;
-     int start, end;
-     char *text;
+alloc_undo_entry (enum undo_code what, int start, int end, char *text)
 {
   UNDO_LIST *temp;
 
@@ -88,10 +85,7 @@ alloc_undo_entry (what, start, end, text)
 /* Remember how to undo something.  Concatenate some undos if that
    seems right. */
 void
-rl_add_undo (what, start, end, text)
-     enum undo_code what;
-     int start, end;
-     char *text;
+rl_add_undo (enum undo_code what, int start, int end, char *text)
 {
   UNDO_LIST *temp;
 
@@ -102,8 +96,7 @@ rl_add_undo (what, start, end, text)
 
 /* Free an UNDO_LIST */
 void
-_rl_free_undo_list (ul)
-     UNDO_LIST *ul;
+_rl_free_undo_list (UNDO_LIST *ul)
 {
   UNDO_LIST *release;
 
@@ -121,7 +114,7 @@ _rl_free_undo_list (ul)
 
 /* Free the existing undo list. */
 void
-rl_free_undo_list ()
+rl_free_undo_list (void)
 {
   UNDO_LIST *release, *orig_list;
 
@@ -132,8 +125,7 @@ rl_free_undo_list ()
 }
 
 UNDO_LIST *
-_rl_copy_undo_entry (entry)
-     UNDO_LIST *entry;
+_rl_copy_undo_entry (UNDO_LIST *entry)
 {
   UNDO_LIST *new;
 
@@ -143,8 +135,7 @@ _rl_copy_undo_entry (entry)
 }
 
 UNDO_LIST *
-_rl_copy_undo_list (head)
-     UNDO_LIST *head;
+_rl_copy_undo_list (UNDO_LIST *head)
 {
   UNDO_LIST *list, *new, *roving, *c;
 
@@ -173,7 +164,7 @@ _rl_copy_undo_list (head)
 /* Undo the next thing in the list.  Return 0 if there
    is nothing to undo, or non-zero if there was. */
 int
-rl_do_undo ()
+rl_do_undo (void)
 {
   UNDO_LIST *release;
   int waiting_for_begin, start, end;
@@ -255,8 +246,7 @@ rl_do_undo ()
 #undef TRANS
 
 int
-_rl_fix_last_undo_of_type (type, start, end)
-     int type, start, end;
+_rl_fix_last_undo_of_type (int type, int start, int end)
 {
   UNDO_LIST *rl;
 
@@ -274,7 +264,7 @@ _rl_fix_last_undo_of_type (type, start, end)
 
 /* Begin a group.  Subsequent undos are undone as an atomic operation. */
 int
-rl_begin_undo_group ()
+rl_begin_undo_group (void)
 {
   rl_add_undo (UNDO_BEGIN, 0, 0, 0);
   _rl_undo_group_level++;
@@ -283,7 +273,7 @@ rl_begin_undo_group ()
 
 /* End an undo group started with rl_begin_undo_group (). */
 int
-rl_end_undo_group ()
+rl_end_undo_group (void)
 {
   rl_add_undo (UNDO_END, 0, 0, 0);
   _rl_undo_group_level--;
@@ -292,8 +282,7 @@ rl_end_undo_group ()
 
 /* Save an undo entry for the text from START to END. */
 int
-rl_modifying (start, end)
-     int start, end;
+rl_modifying (int start, int end)
 {
   if (start > end)
     {
@@ -313,8 +302,7 @@ rl_modifying (start, end)
 
 /* Revert the current line to its previous state. */
 int
-rl_revert_line (count, key)
-     int count, key;
+rl_revert_line (int count, int key)
 {
   if (rl_undo_list == 0)
     rl_ding ();
@@ -333,8 +321,7 @@ rl_revert_line (count, key)
 
 /* Do some undoing of things that were done. */
 int
-rl_undo_command (count, key)
-     int count, key;
+rl_undo_command (int count, int key)
 {
   if (count < 0)
     return 0;	/* Nothing to do. */
diff --git a/util.c b/util.c
index 4589c61..23e4edd 100644
--- a/util.c
+++ b/util.c
@@ -1,6 +1,6 @@
 /* util.c -- readline utility functions */
 
-/* Copyright (C) 1987-2015 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 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.      
@@ -70,8 +70,7 @@ int _rl_allow_pathname_alphabetic_chars = 0;
 static const char * const pathname_alphabetic_chars = "/-_=~.#$";
 
 int
-rl_alphabetic (c)
-     int c;
+rl_alphabetic (int c)
 {
   if (ALPHABETIC (c))
     return (1);
@@ -97,7 +96,7 @@ _rl_walphabetic (wchar_t wc)
 
 /* How to abort things. */
 int
-_rl_abort_internal ()
+_rl_abort_internal (void)
 {
   rl_ding ();
   rl_clear_message ();
@@ -117,22 +116,19 @@ _rl_abort_internal ()
 }
 
 int
-rl_abort (count, key)
-     int count, key;
+rl_abort (int count, int key)
 {
   return (_rl_abort_internal ());
 }
 
 int
-_rl_null_function (count, key)
-     int count, key;
+_rl_null_function (int count, int key)
 {
   return 0;
 }
 
 int
-rl_tty_status (count, key)
-     int count, key;
+rl_tty_status (int count, int key)
 {
 #if defined (TIOCSTAT)
   ioctl (1, TIOCSTAT, (char *)0);
@@ -146,8 +142,7 @@ rl_tty_status (count, key)
 /* Return a copy of the string between FROM and TO.
    FROM is inclusive, TO is not. */
 char *
-rl_copy_text (from, to)
-     int from, to;
+rl_copy_text (int from, int to)
 {
   register int length;
   char *copy;
@@ -166,8 +161,7 @@ rl_copy_text (from, to)
 /* Increase the size of RL_LINE_BUFFER until it has enough space to hold
    LEN characters. */
 void
-rl_extend_line_buffer (len)
-     int len;
+rl_extend_line_buffer (int len)
 {
   while (len >= rl_line_buffer_len)
     {
@@ -181,8 +175,7 @@ rl_extend_line_buffer (len)
 
 /* A function for simple tilde expansion. */
 int
-rl_tilde_expand (ignore, key)
-     int ignore, key;
+rl_tilde_expand (int ignore, int key)
 {
   register int start, end;
   char *homedir, *temp;
@@ -324,8 +317,7 @@ _rl_errmsg (format, arg1, arg2)
 /* Determine if s2 occurs in s1.  If so, return a pointer to the
    match in s1.  The compare is case insensitive. */
 char *
-_rl_strindex (s1, s2)
-     register const char *s1, *s2;
+_rl_strindex (const char *s1, const char *s2)
 {
   register int i, l, len;
 
@@ -339,8 +331,7 @@ _rl_strindex (s1, s2)
 /* Find the first occurrence in STRING1 of any character from STRING2.
    Return a pointer to the character in STRING1. */
 char *
-_rl_strpbrk (string1, string2)
-     const char *string1, *string2;
+_rl_strpbrk (const char *string1, const char *string2)
 {
   register const char *scan;
 #if defined (HANDLE_MULTIBYTE)
@@ -374,10 +365,7 @@ _rl_strpbrk (string1, string2)
 /* Compare at most COUNT characters from string1 to string2.  Case
    doesn't matter (strncasecmp). */
 int
-_rl_strnicmp (string1, string2, count)
-     const char *string1;
-     const char *string2;
-     int count;
+_rl_strnicmp (const char *string1, const char *string2, int count)
 {
   register const char *s1;
   register const char *s2;
@@ -404,9 +392,7 @@ _rl_strnicmp (string1, string2, count)
 
 /* strcmp (), but caseless (strcasecmp). */
 int
-_rl_stricmp (string1, string2)
-     const char *string1;
-     const char *string2;
+_rl_stricmp (const char *string1, const char *string2)
 {
   register const char *s1;
   register const char *s2;
@@ -431,8 +417,7 @@ _rl_stricmp (string1, string2)
 
 /* Stupid comparison routine for qsort () ing strings. */
 int
-_rl_qsort_string_compare (s1, s2)
-  char **s1, **s2;
+_rl_qsort_string_compare (char **s1, char **s2)
 {
 #if defined (HAVE_STRCOLL)
   return (strcoll (*s1, *s2));
@@ -448,7 +433,7 @@ _rl_qsort_string_compare (s1, s2)
 }
 
 /* Function equivalents for the macros defined in chardefs.h. */
-#define FUNCTION_FOR_MACRO(f)	int (f) (c) int c; { return f (c); }
+#define FUNCTION_FOR_MACRO(f)	int (f) (int c) { return f (c); }
 
 FUNCTION_FOR_MACRO (_rl_digit_p)
 FUNCTION_FOR_MACRO (_rl_digit_value)
@@ -461,8 +446,7 @@ FUNCTION_FOR_MACRO (_rl_uppercase_p)
 /* A convenience function, to force memory deallocation to be performed
    by readline.  DLLs on Windows apparently require this. */
 void
-rl_free (mem)
-     void *mem;
+rl_free (void *mem)
 {
   if (mem)
     free (mem);
@@ -472,8 +456,7 @@ rl_free (mem)
    all `public' readline header files. */
 #undef _rl_savestring
 char *
-_rl_savestring (s)
-     const char *s;
+_rl_savestring (const char *s)
 {
   return (strcpy ((char *)xmalloc (1 + (int)strlen (s)), (s)));
 }
@@ -512,7 +495,7 @@ _rl_trace (va_alist)
 }
 
 int
-_rl_tropen ()
+_rl_tropen (void)
 {
   char fnbuf[128], *x;
 
@@ -525,14 +508,14 @@ _rl_tropen ()
 #else
   x = "/var/tmp";
 #endif
-  sprintf (fnbuf, "%s/rltrace.%ld", x, (long)getpid());
+  snprintf (fnbuf, sizeof (fnbuf), "%s/rltrace.%ld", x, (long)getpid());
   unlink(fnbuf);
   _rl_tracefp = fopen (fnbuf, "w+");
   return _rl_tracefp != 0;
 }
 
 int
-_rl_trclose ()
+_rl_trclose (void)
 {
   int r;
 
@@ -542,8 +525,7 @@ _rl_trclose ()
 }
 
 void
-_rl_settracefp (fp)
-     FILE *fp;
+_rl_settracefp (FILE *fp)
 {
   _rl_tracefp = fp;
 }
@@ -559,8 +541,7 @@ _rl_settracefp (fp)
 
 /* Report STRING to the audit system. */
 void
-_rl_audit_tty (string)
-     char *string;
+_rl_audit_tty (char *string)
 {
   struct audit_message req;
   struct sockaddr_nl addr;
diff --git a/vi_keymap.c b/vi_keymap.c
index e5da2e0..045258b 100644
--- a/vi_keymap.c
+++ b/vi_keymap.c
@@ -1,6 +1,6 @@
 /* vi_keymap.c -- the keymap for vi_mode in readline (). */
 
-/* Copyright (C) 1987-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 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.      
diff --git a/vi_mode.c b/vi_mode.c
index 56d2e72..3613d19 100644
--- a/vi_mode.c
+++ b/vi_mode.c
@@ -1,7 +1,7 @@
 /* vi_mode.c -- A vi emulation mode for Bash.
    Derived from code written by Jeff Sparkes (jsparkes@bnr.ca).  */
 
-/* Copyright (C) 1987-2016 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2017 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.      
@@ -63,6 +63,8 @@
 #define member(c, s) ((c) ? (char *)strchr ((s), (c)) != (char *)NULL : 0)
 #endif
 
+/* This is global so other parts of the code can check whether the last
+   command was a text modification command. */
 int _rl_vi_last_command = 'i';	/* default `.' puts you in insert mode */
 
 _rl_vimotion_cxt *_rl_vimvcxt = 0;
@@ -146,7 +148,7 @@ static int vi_yank_dispatch PARAMS((_rl_vimotion_cxt *));
 static int vidomove_dispatch PARAMS((_rl_vimotion_cxt *));
 
 void
-_rl_vi_initialize_line ()
+_rl_vi_initialize_line (void)
 {
   register int i, n;
 
@@ -158,7 +160,7 @@ _rl_vi_initialize_line ()
 }
 
 void
-_rl_vi_reset_last ()
+_rl_vi_reset_last (void)
 {
   _rl_vi_last_command = 'i';
   _rl_vi_last_repeat = 1;
@@ -167,8 +169,7 @@ _rl_vi_reset_last ()
 }
 
 void
-_rl_vi_set_last (key, repeat, sign)
-     int key, repeat, sign;
+_rl_vi_set_last (int key, int repeat, int sign)
 {
   _rl_vi_last_command = key;
   _rl_vi_last_repeat = repeat;
@@ -178,8 +179,7 @@ _rl_vi_set_last (key, repeat, sign)
 /* A convenience function that calls _rl_vi_set_last to save the last command
    information and enters insertion mode. */
 void
-rl_vi_start_inserting (key, repeat, sign)
-     int key, repeat, sign;
+rl_vi_start_inserting (int key, int repeat, int sign)
 {
   _rl_vi_set_last (key, repeat, sign);
   rl_vi_insertion_mode (1, key);
@@ -187,22 +187,19 @@ rl_vi_start_inserting (key, repeat, sign)
 
 /* Is the command C a VI mode text modification command? */
 int
-_rl_vi_textmod_command (c)
-     int c;
+_rl_vi_textmod_command (int c)
 {
   return (member (c, vi_textmod));
 }
 
 int
-_rl_vi_motion_command (c)
-     int c;
+_rl_vi_motion_command (int c)
 {
   return (member (c, vi_motion));
 }
 
 static void
-_rl_vi_replace_insert (count)
-     int count;
+_rl_vi_replace_insert (int count)
 {
   int nchars;
 
@@ -217,8 +214,7 @@ _rl_vi_replace_insert (count)
 }
 
 static void
-_rl_vi_stuff_insert (count)
-     int count;
+_rl_vi_stuff_insert (int count)
 {
   rl_begin_undo_group ();
   while (count--)
@@ -230,8 +226,7 @@ _rl_vi_stuff_insert (count)
    redo a text modification command.  The default for _rl_vi_last_command
    puts you back into insert mode. */
 int
-rl_vi_redo (count, c)
-     int count, c;
+rl_vi_redo (int count, int c)
 {
   int r;
 
@@ -296,16 +291,14 @@ rl_vi_redo (count, c)
 
 /* A placeholder for further expansion. */
 int
-rl_vi_undo (count, key)
-     int count, key;
+rl_vi_undo (int count, int key)
 {
   return (rl_undo_command (count, key));
 }
     
 /* Yank the nth arg from the previous line into this line at point. */
 int
-rl_vi_yank_arg (count, key)
-     int count, key;
+rl_vi_yank_arg (int count, int key)
 {
   /* Readline thinks that the first word on a line is the 0th, while vi
      thinks the first word on a line is the 1st.  Compensate. */
@@ -320,8 +313,7 @@ rl_vi_yank_arg (count, key)
 /* With an argument, move back that many history lines, else move to the
    beginning of history. */
 int
-rl_vi_fetch_history (count, c)
-     int count, c;
+rl_vi_fetch_history (int count, int c)
 {
   int wanted;
 
@@ -345,8 +337,7 @@ rl_vi_fetch_history (count, c)
 
 /* Search again for the last thing searched for. */
 int
-rl_vi_search_again (count, key)
-     int count, key;
+rl_vi_search_again (int count, int key)
 {
   switch (key)
     {
@@ -363,8 +354,7 @@ rl_vi_search_again (count, key)
 
 /* Do a vi style search. */
 int
-rl_vi_search (count, key)
-     int count, key;
+rl_vi_search (int count, int key)
 {
   switch (key)
     {
@@ -387,8 +377,7 @@ rl_vi_search (count, key)
 
 /* Completion, from vi's point of view. */
 int
-rl_vi_complete (ignore, key)
-     int ignore, key;
+rl_vi_complete (int ignore, int key)
 {
   if ((rl_point < rl_end) && (!whitespace (rl_line_buffer[rl_point])))
     {
@@ -414,8 +403,7 @@ rl_vi_complete (ignore, key)
 
 /* Tilde expansion for vi mode. */
 int
-rl_vi_tilde_expand (ignore, key)
-     int ignore, key;
+rl_vi_tilde_expand (int ignore, int key)
 {
   rl_tilde_expand (0, key);
   rl_vi_start_inserting (key, 1, rl_arg_sign);
@@ -424,8 +412,7 @@ rl_vi_tilde_expand (ignore, key)
 
 /* Previous word in vi mode. */
 int
-rl_vi_prev_word (count, key)
-     int count, key;
+rl_vi_prev_word (int count, int key)
 {
   if (count < 0)
     return (rl_vi_next_word (-count, key));
@@ -446,8 +433,7 @@ rl_vi_prev_word (count, key)
 
 /* Next word in vi mode. */
 int
-rl_vi_next_word (count, key)
-     int count, key;
+rl_vi_next_word (int count, int key)
 {
   if (count < 0)
     return (rl_vi_prev_word (-count, key));
@@ -467,8 +453,7 @@ rl_vi_next_word (count, key)
 
 /* Move to the end of the ?next? word. */
 int
-rl_vi_end_word (count, key)
-     int count, key;
+rl_vi_end_word (int count, int key)
 {
   if (count < 0)
     {
@@ -485,8 +470,7 @@ rl_vi_end_word (count, key)
 
 /* Move forward a word the way that 'W' does. */
 int
-rl_vi_fWord (count, ignore)
-     int count, ignore;
+rl_vi_fWord (int count, int ignore)
 {
   while (count-- && rl_point < (rl_end - 1))
     {
@@ -502,8 +486,7 @@ rl_vi_fWord (count, ignore)
 }
 
 int
-rl_vi_bWord (count, ignore)
-     int count, ignore;
+rl_vi_bWord (int count, int ignore)
 {
   while (count-- && rl_point > 0)
     {
@@ -526,8 +509,7 @@ rl_vi_bWord (count, ignore)
 }
 
 int
-rl_vi_eWord (count, ignore)
-     int count, ignore;
+rl_vi_eWord (int count, int ignore)
 {
   while (count-- && rl_point < (rl_end - 1))
     {
@@ -557,8 +539,7 @@ rl_vi_eWord (count, ignore)
 }
 
 int
-rl_vi_fword (count, ignore)
-     int count, ignore;
+rl_vi_fword (int count, int ignore)
 {
   while (count-- && rl_point < (rl_end - 1))
     {
@@ -583,8 +564,7 @@ rl_vi_fword (count, ignore)
 }
 
 int
-rl_vi_bword (count, ignore)
-     int count, ignore;
+rl_vi_bword (int count, int ignore)
 {
   while (count-- && rl_point > 0)
     {
@@ -594,7 +574,8 @@ rl_vi_bword (count, ignore)
 	 so we will go back to the start of the previous word. */
       if (!whitespace (rl_line_buffer[rl_point]) &&
 	  whitespace (rl_line_buffer[rl_point - 1]))
-	rl_point--;
+	if (--rl_point == 0)
+	  break;
 
       /* If this character and the previous character are `opposite', move
 	 back so we don't get messed up by the rl_point++ down there in
@@ -622,8 +603,7 @@ rl_vi_bword (count, ignore)
 }
 
 int
-rl_vi_eword (count, ignore)
-     int count, ignore;
+rl_vi_eword (int count, int ignore)
 {
   while (count-- && rl_point < rl_end - 1)
     {
@@ -647,8 +627,7 @@ rl_vi_eword (count, ignore)
 }
 
 int
-rl_vi_insert_beg (count, key)
-     int count, key;
+rl_vi_insert_beg (int count, int key)
 {
   rl_beg_of_line (1, key);
   rl_vi_insert_mode (1, key);
@@ -656,8 +635,7 @@ rl_vi_insert_beg (count, key)
 }
 
 static void
-_rl_vi_append_forward (key)
-     int key;
+_rl_vi_append_forward (int key)
 {
   int point;
 
@@ -680,8 +658,7 @@ _rl_vi_append_forward (key)
 }
 
 int
-rl_vi_append_mode (count, key)
-     int count, key;
+rl_vi_append_mode (int count, int key)
 {
   _rl_vi_append_forward (key);
   rl_vi_start_inserting (key, 1, rl_arg_sign);
@@ -689,8 +666,7 @@ rl_vi_append_mode (count, key)
 }
 
 int
-rl_vi_append_eol (count, key)
-     int count, key;
+rl_vi_append_eol (int count, int key)
 {
   rl_end_of_line (1, key);
   rl_vi_append_mode (1, key);
@@ -699,8 +675,7 @@ rl_vi_append_eol (count, key)
 
 /* What to do in the case of C-d. */
 int
-rl_vi_eof_maybe (count, c)
-     int count, c;
+rl_vi_eof_maybe (int count, int c)
 {
   return (rl_newline (1, '\n'));
 }
@@ -710,8 +685,7 @@ rl_vi_eof_maybe (count, c)
 /* Switching from one mode to the other really just involves
    switching keymaps. */
 int
-rl_vi_insertion_mode (count, key)
-     int count, key;
+rl_vi_insertion_mode (int count, int key)
 {
   _rl_keymap = vi_insertion_keymap;
   _rl_vi_last_key_before_insert = key;
@@ -721,16 +695,14 @@ rl_vi_insertion_mode (count, key)
 }
 
 int
-rl_vi_insert_mode (count, key)
-     int count, key;
+rl_vi_insert_mode (int count, int key)
 {
   rl_vi_start_inserting (key, 1, rl_arg_sign);
   return (0);
 }
 
 static void
-vi_save_insert_buffer (start, len)
-     int start, len;
+vi_save_insert_buffer (int start, int len)
 {
   /* Same code as _rl_vi_save_insert below */
   if (len >= vi_insert_buffer_size)
@@ -743,7 +715,7 @@ vi_save_insert_buffer (start, len)
 }
 
 static void
-_rl_vi_save_replace ()
+_rl_vi_save_replace (void)
 {
   int len, start, end;
   UNDO_LIST *up;
@@ -766,8 +738,7 @@ _rl_vi_save_replace ()
 }
 
 static void
-_rl_vi_save_insert (up)
-      UNDO_LIST *up;
+_rl_vi_save_insert (UNDO_LIST *up)
 {
   int len, start, end;
 
@@ -786,7 +757,7 @@ _rl_vi_save_insert (up)
 }
     
 void
-_rl_vi_done_inserting ()
+_rl_vi_done_inserting (void)
 {
   if (_rl_vi_doing_insert)
     {
@@ -821,8 +792,7 @@ _rl_vi_done_inserting ()
 }
 
 int
-rl_vi_movement_mode (count, key)
-     int count, key;
+rl_vi_movement_mode (int count, int key)
 {
   if (rl_point > 0)
     rl_backward_char (1, key);
@@ -843,8 +813,7 @@ rl_vi_movement_mode (count, key)
 }
 
 int
-rl_vi_arg_digit (count, c)
-     int count, c;
+rl_vi_arg_digit (int count, int c)
 {
   if (c == '0' && rl_numeric_arg == 1 && !rl_explicit_arg)
     return (rl_beg_of_line (1, c));
@@ -855,8 +824,7 @@ rl_vi_arg_digit (count, c)
 /* Change the case of the next COUNT characters. */
 #if defined (HANDLE_MULTIBYTE)
 static int
-_rl_vi_change_mbchar_case (count)
-     int count;
+_rl_vi_change_mbchar_case (int count)
 {
   wchar_t wc;
   char mb[MB_LEN_MAX+1];
@@ -909,8 +877,7 @@ _rl_vi_change_mbchar_case (count)
 #endif
 
 int
-rl_vi_change_case (count, ignore)
-     int count, ignore;
+rl_vi_change_case (int count, int ignore)
 {
   int c, p;
 
@@ -956,8 +923,7 @@ rl_vi_change_case (count, ignore)
 }
 
 int
-rl_vi_put (count, key)
-     int count, key;
+rl_vi_put (int count, int key)
 {
   if (!_rl_uppercase_p (key) && (rl_point + 1 <= rl_end))
     rl_point = _rl_find_next_mbchar (rl_line_buffer, rl_point, 1, MB_FIND_NONZERO);
@@ -969,8 +935,9 @@ rl_vi_put (count, key)
   return (0);
 }
 
+/* Move the cursor back one character. */
 static void
-_rl_vi_backup ()
+_rl_vi_backup (void)
 {
   if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
     rl_point = _rl_find_prev_mbchar (rl_line_buffer, rl_point, MB_FIND_NONZERO);
@@ -978,8 +945,9 @@ _rl_vi_backup ()
     rl_point--;
 }
 
+/* Move the cursor back one character if you're at the end of the line */
 int
-rl_vi_check ()
+rl_vi_check (void)
 {
   if (rl_point && rl_point == rl_end)
     {
@@ -991,9 +959,9 @@ rl_vi_check ()
   return (0);
 }
 
+/* Move to the character position specified by COUNT */
 int
-rl_vi_column (count, key)
-     int count, key;
+rl_vi_column (int count, int key)
 {
   if (count > rl_end)
     rl_end_of_line (1, key);
@@ -1006,8 +974,7 @@ rl_vi_column (count, key)
    argument should be aborted, 0 if we should not read any more chars, and
    1 if we should continue to read chars. */
 static int
-_rl_vi_arg_dispatch (c)
-     int c;
+_rl_vi_arg_dispatch (int c)
 {
   int key;
 
@@ -1041,7 +1008,7 @@ _rl_vi_arg_dispatch (c)
    Don't recognize minus sign?
    Should this do rl_save_prompt/rl_restore_prompt? */
 static int
-rl_digit_loop1 ()
+rl_digit_loop1 (void)
 {
   int c, r;
 
@@ -1061,10 +1028,12 @@ rl_digit_loop1 ()
   return (0);
 }
 
+/* This set of functions is basically to handle the commands that take a
+   motion argument while in callback mode: read the command, read the motion
+   command modifier, find the extent of the text to affect, and dispatch the
+   command for execution. */
 static void
-_rl_mvcxt_init (m, op, key)
-     _rl_vimotion_cxt *m;
-     int op, key;
+_rl_mvcxt_init (_rl_vimotion_cxt *m, int op, int key)
 {
   m->op = op;
   m->state = m->flags = 0;
@@ -1077,8 +1046,7 @@ _rl_mvcxt_init (m, op, key)
 }
 
 static _rl_vimotion_cxt *
-_rl_mvcxt_alloc (op, key)
-     int op, key;
+_rl_mvcxt_alloc (int op, int key)
 {
   _rl_vimotion_cxt *m;
 
@@ -1088,15 +1056,13 @@ _rl_mvcxt_alloc (op, key)
 }
 
 static void
-_rl_mvcxt_dispose (m)
-     _rl_vimotion_cxt *m;
+_rl_mvcxt_dispose (_rl_vimotion_cxt *m)
 {
   xfree (m);
 }
 
 static int
-rl_domove_motion_callback (m)
-     _rl_vimotion_cxt *m;
+rl_domove_motion_callback (_rl_vimotion_cxt *m)
 {
   int c;
 
@@ -1129,9 +1095,7 @@ rl_domove_motion_callback (m)
 }
 
 int
-_rl_vi_domove_motion_cleanup (c, m)
-     int c;
-     _rl_vimotion_cxt *m;
+_rl_vi_domove_motion_cleanup (int c, _rl_vimotion_cxt *m)
 {
   int r;
 
@@ -1193,8 +1157,7 @@ _rl_vi_domove_motion_cleanup (c, m)
 #define RL_VIMOVENUMARG()	(RL_ISSTATE (RL_STATE_VIMOTION) && RL_ISSTATE (RL_STATE_NUMERICARG))
 
 static int
-rl_domove_read_callback (m)
-     _rl_vimotion_cxt *m;
+rl_domove_read_callback (_rl_vimotion_cxt *m)
 {
   int c, save;
 
@@ -1260,8 +1223,7 @@ rl_domove_read_callback (m)
 }
 
 static int
-rl_vi_domove_getchar (m)
-     _rl_vimotion_cxt *m;
+rl_vi_domove_getchar (_rl_vimotion_cxt *m)
 {
   int c;
 
@@ -1274,8 +1236,7 @@ rl_vi_domove_getchar (m)
 
 #if defined (READLINE_CALLBACKS)
 int
-_rl_vi_domove_callback (m)
-     _rl_vimotion_cxt *m;
+_rl_vi_domove_callback (_rl_vimotion_cxt *m)
 {
   int c, r;
 
@@ -1288,10 +1249,9 @@ _rl_vi_domove_callback (m)
 }
 #endif
 
-/* This code path taken when not in callback mode. */
+/* This code path is taken when not in callback mode. */
 int
-rl_vi_domove (x, ignore)
-     int x, *ignore;
+rl_vi_domove (int x, int *ignore)
 {
   int r;
   _rl_vimotion_cxt *m;
@@ -1309,8 +1269,7 @@ rl_vi_domove (x, ignore)
 }
 
 static int
-vi_delete_dispatch (m)
-     _rl_vimotion_cxt *m;
+vi_delete_dispatch (_rl_vimotion_cxt *m)
 {
   /* These are the motion commands that do not require adjusting the
      mark. */
@@ -1323,8 +1282,7 @@ vi_delete_dispatch (m)
 }
 
 int
-rl_vi_delete_to (count, key)
-     int count, key;
+rl_vi_delete_to (int count, int key)
 {
   int c, r;
 
@@ -1373,8 +1331,7 @@ rl_vi_delete_to (count, key)
 }
 
 static int
-vi_change_dispatch (m)
-     _rl_vimotion_cxt *m;
+vi_change_dispatch (_rl_vimotion_cxt *m)
 {
   /* These are the motion commands that do not require adjusting the
      mark.  c[wW] are handled by special-case code in rl_vi_domove(),
@@ -1413,8 +1370,7 @@ vi_change_dispatch (m)
 }
 
 int
-rl_vi_change_to (count, key)
-     int count, key;
+rl_vi_change_to (int count, int key)
 {
   int c, r;
 
@@ -1463,8 +1419,7 @@ rl_vi_change_to (count, key)
 }
 
 static int
-vi_yank_dispatch (m)
-     _rl_vimotion_cxt *m;
+vi_yank_dispatch (_rl_vimotion_cxt *m)
 {
   /* These are the motion commands that do not require adjusting the
      mark. */
@@ -1482,8 +1437,7 @@ vi_yank_dispatch (m)
 }
 
 int
-rl_vi_yank_to (count, key)
-     int count, key;
+rl_vi_yank_to (int count, int key)
 {
   int c, r;
 
@@ -1532,8 +1486,7 @@ rl_vi_yank_to (count, key)
 }
 
 static int
-vidomove_dispatch (m)
-     _rl_vimotion_cxt *m;
+vidomove_dispatch (_rl_vimotion_cxt *m)
 {
   int r;
 
@@ -1559,8 +1512,7 @@ vidomove_dispatch (m)
 }
 
 int
-rl_vi_rubout (count, key)
-     int count, key;
+rl_vi_rubout (int count, int key)
 {
   int opoint;
 
@@ -1590,8 +1542,7 @@ rl_vi_rubout (count, key)
 }
 
 int
-rl_vi_delete (count, key)
-     int count, key;
+rl_vi_delete (int count, int key)
 {
   int end;
 
@@ -1626,8 +1577,7 @@ rl_vi_delete (count, key)
 #define vi_unix_word_boundary(c)	(whitespace(c) || ispunct(c))
 
 int
-rl_vi_unix_word_rubout (count, key)
-     int count, key;
+rl_vi_unix_word_rubout (int count, int key)
 {
   int orig_point;
 
@@ -1677,8 +1627,7 @@ rl_vi_unix_word_rubout (count, key)
 
 
 int
-rl_vi_back_to_indent (count, key)
-     int count, key;
+rl_vi_back_to_indent (int count, int key)
 {
   rl_beg_of_line (1, key);
   while (rl_point < rl_end && whitespace (rl_line_buffer[rl_point]))
@@ -1687,8 +1636,7 @@ rl_vi_back_to_indent (count, key)
 }
 
 int
-rl_vi_first_print (count, key)
-     int count, key;
+rl_vi_first_print (int count, int key)
 {
   return (rl_vi_back_to_indent (1, key));
 }
@@ -1697,8 +1645,7 @@ static int _rl_cs_dir, _rl_cs_orig_dir;
 
 #if defined (READLINE_CALLBACKS)
 static int
-_rl_vi_callback_char_search (data)
-     _rl_callback_generic_arg *data;
+_rl_vi_callback_char_search (_rl_callback_generic_arg *data)
 {
   int c;
 #if defined (HANDLE_MULTIBYTE)
@@ -1732,8 +1679,7 @@ _rl_vi_callback_char_search (data)
 #endif
 
 int
-rl_vi_char_search (count, key)
-     int count, key;
+rl_vi_char_search (int count, int key)
 {
   int c;
 #if defined (HANDLE_MULTIBYTE)
@@ -1826,8 +1772,7 @@ rl_vi_char_search (count, key)
 
 /* Match brackets */
 int
-rl_vi_match (ignore, key)
-     int ignore, key;
+rl_vi_match (int ignore, int key)
 {
   int count = 1, brack, pos, tmp, pre;
 
@@ -1916,8 +1861,7 @@ rl_vi_match (ignore, key)
 }
 
 int
-rl_vi_bracktype (c)
-     int c;
+rl_vi_bracktype (int c)
 {
   switch (c)
     {
@@ -1932,9 +1876,7 @@ rl_vi_bracktype (c)
 }
 
 static int
-_rl_vi_change_char (count, c, mb)
-     int count, c;
-     char *mb;
+_rl_vi_change_char (int count, int c, char *mb)
 {
   int p;
 
@@ -1965,9 +1907,7 @@ _rl_vi_change_char (count, c, mb)
 }
 
 static int
-_rl_vi_callback_getchar (mb, mlen)
-     char *mb;
-     int mlen;
+_rl_vi_callback_getchar (char *mb, int mlen)
 {
   int c;
 
@@ -1988,8 +1928,7 @@ _rl_vi_callback_getchar (mb, mlen)
 
 #if defined (READLINE_CALLBACKS)
 static int
-_rl_vi_callback_change_char (data)
-     _rl_callback_generic_arg *data;
+_rl_vi_callback_change_char (_rl_callback_generic_arg *data)
 {
   int c;
   char mb[MB_LEN_MAX];
@@ -2007,8 +1946,7 @@ _rl_vi_callback_change_char (data)
 #endif
 
 int
-rl_vi_change_char (count, key)
-     int count, key;
+rl_vi_change_char (int count, int key)
 {
   int c;
   char mb[MB_LEN_MAX];
@@ -2037,8 +1975,7 @@ rl_vi_change_char (count, key)
 }
 
 int
-rl_vi_subst (count, key)
-     int count, key;
+rl_vi_subst (int count, int key)
 {
   /* If we are redoing, rl_vi_change_to will stuff the last motion char */
   if (_rl_vi_redoing == 0)
@@ -2048,8 +1985,7 @@ rl_vi_subst (count, key)
 }
 
 int
-rl_vi_overstrike (count, key)
-     int count, key;
+rl_vi_overstrike (int count, int key)
 {
   if (_rl_vi_doing_insert == 0)
     {
@@ -2067,8 +2003,7 @@ rl_vi_overstrike (count, key)
 }
 
 int
-rl_vi_overstrike_delete (count, key)
-     int count, key;
+rl_vi_overstrike_delete (int count, int key)
 {
   int i, s;
 
@@ -2098,8 +2033,7 @@ rl_vi_overstrike_delete (count, key)
 }
 
 int
-rl_vi_replace (count, key)
-     int count, key;
+rl_vi_replace (int count, int key)
 {
   int i;
 
@@ -2145,7 +2079,7 @@ rl_vi_replace (count, key)
    the previous character.  A space matches everything.  Word delimiters are
    space and ;. */
 int
-rl_vi_possible_completions()
+rl_vi_possible_completions (void)
 {
   int save_pos = rl_point;
 
@@ -2170,7 +2104,7 @@ rl_vi_possible_completions()
 
 /* Functions to save and restore marks. */
 static int
-_rl_vi_set_mark ()
+_rl_vi_set_mark (void)
 {
   int ch;
 
@@ -2190,8 +2124,7 @@ _rl_vi_set_mark ()
 
 #if defined (READLINE_CALLBACKS)
 static int
-_rl_vi_callback_set_mark (data)
-     _rl_callback_generic_arg *data;
+_rl_vi_callback_set_mark (_rl_callback_generic_arg *data)
 {
   _rl_callback_func = 0;
   _rl_want_redisplay = 1;
@@ -2201,8 +2134,7 @@ _rl_vi_callback_set_mark (data)
 #endif
 
 int
-rl_vi_set_mark (count, key)
-     int count, key;
+rl_vi_set_mark (int count, int key)
 {
 #if defined (READLINE_CALLBACKS)
   if (RL_ISSTATE (RL_STATE_CALLBACK))
@@ -2217,7 +2149,7 @@ rl_vi_set_mark (count, key)
 }
 
 static int
-_rl_vi_goto_mark ()
+_rl_vi_goto_mark (void)
 {
   int ch;
 
@@ -2248,8 +2180,7 @@ _rl_vi_goto_mark ()
 
 #if defined (READLINE_CALLBACKS)
 static int
-_rl_vi_callback_goto_mark (data)
-     _rl_callback_generic_arg *data;
+_rl_vi_callback_goto_mark (_rl_callback_generic_arg *data)
 {
   _rl_callback_func = 0;
   _rl_want_redisplay = 1;
@@ -2259,8 +2190,7 @@ _rl_vi_callback_goto_mark (data)
 #endif
 
 int
-rl_vi_goto_mark (count, key)
-     int count, key;
+rl_vi_goto_mark (int count, int key)
 {
 #if defined (READLINE_CALLBACKS)
   if (RL_ISSTATE (RL_STATE_CALLBACK))
diff --git a/xfree.c b/xfree.c
index 37a81e6..c199b29 100644
--- a/xfree.c
+++ b/xfree.c
@@ -1,6 +1,6 @@
 /* xfree.c -- safe version of free that ignores attempts to free NUL */
 
-/* Copyright (C) 1991-2010 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2010,2017 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.      
@@ -42,8 +42,7 @@
 /* Use this as the function to call when adding unwind protects so we
    don't need to know what free() returns. */
 void
-xfree (string)
-     PTR_T string;
+xfree (PTR_T string)
 {
   if (string)
     free (string);
diff --git a/xmalloc.c b/xmalloc.c
index c77d763..5d01d75 100644
--- a/xmalloc.c
+++ b/xmalloc.c
@@ -1,6 +1,6 @@
 /* xmalloc.c -- safe versions of malloc and realloc */
 
-/* Copyright (C) 1991-2009 Free Software Foundation, Inc.
+/* Copyright (C) 1991-2017 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.      
@@ -42,8 +42,7 @@
 /* **************************************************************** */
 
 static void
-memory_error_and_abort (fname)
-     char *fname;
+memory_error_and_abort (char *fname)
 {
   fprintf (stderr, "%s: out of virtual memory\n", fname);
   exit (2);
@@ -53,8 +52,7 @@ memory_error_and_abort (fname)
    to hold BYTES number of bytes.  If the memory cannot be allocated,
    print an error message and abort. */
 PTR_T
-xmalloc (bytes)
-     size_t bytes;
+xmalloc (size_t bytes)
 {
   PTR_T temp;
 
@@ -65,9 +63,7 @@ xmalloc (bytes)
 }
 
 PTR_T
-xrealloc (pointer, bytes)
-     PTR_T pointer;
-     size_t bytes;
+xrealloc (PTR_T pointer, size_t bytes)
 {
   PTR_T temp;