commit bash-20140327 snapshot

lib/readline/display.c

@@ -2677,7 +2677,8 @@ _rl_clean_up_for_exit ()
 {
   if (_rl_echoing_p)
     {
-      _rl_move_vert (_rl_vis_botlin);
+      if (_rl_vis_botlin > 0)	/* minor optimization plus bug fix */
+	_rl_move_vert (_rl_vis_botlin);
       _rl_vis_botlin = 0;
       fflush (rl_outstream);
       rl_restart_output (1, 0);

lib/readline/kill.c

@@ -506,7 +506,7 @@ rl_yank (count, ignore)
   if (rl_kill_ring == 0)
     {
       _rl_abort_internal ();
-      return -1;
+      return 1;
     }
 
   _rl_set_mark_at_pos (rl_point);
@@ -528,7 +528,7 @@ rl_yank_pop (count, key)
       !rl_kill_ring)
     {
       _rl_abort_internal ();
-      return -1;
+      return 1;
     }
 
   l = strlen (rl_kill_ring[rl_kill_index]);
@@ -546,7 +546,7 @@ rl_yank_pop (count, key)
   else
     {
       _rl_abort_internal ();
-      return -1;
+      return 1;
     }
 }
 
@@ -575,7 +575,7 @@ rl_yank_nth_arg_internal (count, ignore, history_skip)
   if (entry == 0)
     {
       rl_ding ();
-      return -1;
+      return 1;
     }
 
   arg = history_arg_extract (count, count, entry->line);
@@ -583,7 +583,7 @@ rl_yank_nth_arg_internal (count, ignore, history_skip)
     {
       rl_ding ();
       FREE (arg);
-      return -1;
+      return 1;
     }
 
   rl_begin_undo_group ();

lib/readline/kill.c~

@@ -0,0 +1,694 @@
+/* kill.c -- kill ring management. */
+
+/* Copyright (C) 1994 Free Software Foundation, Inc.
+
+   This file is part of the GNU Readline Library (Readline), a library
+   for reading lines of text with interactive input and history editing.      
+
+   Readline is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   Readline is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with Readline.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#define READLINE_LIBRARY
+
+#if defined (HAVE_CONFIG_H)
+#  include <config.h>
+#endif
+
+#include <sys/types.h>
+
+#if defined (HAVE_UNISTD_H)
+#  include <unistd.h>           /* for _POSIX_VERSION */
+#endif /* HAVE_UNISTD_H */
+
+#if defined (HAVE_STDLIB_H)
+#  include <stdlib.h>
+#else
+#  include "ansi_stdlib.h"
+#endif /* HAVE_STDLIB_H */
+
+#include <stdio.h>
+
+/* System-specific feature definitions and include files. */
+#include "rldefs.h"
+
+/* Some standard library routines. */
+#include "readline.h"
+#include "history.h"
+
+#include "rlprivate.h"
+#include "xmalloc.h"
+
+/* **************************************************************** */
+/*								    */
+/*			Killing Mechanism			    */
+/*								    */
+/* **************************************************************** */
+
+/* What we assume for a max number of kills. */
+#define DEFAULT_MAX_KILLS 10
+
+/* The real variable to look at to find out when to flush kills. */
+static int rl_max_kills =  DEFAULT_MAX_KILLS;
+
+/* Where to store killed text. */
+static char **rl_kill_ring = (char **)NULL;
+
+/* Where we are in the kill ring. */
+static int rl_kill_index;
+
+/* How many slots we have in the kill ring. */
+static int rl_kill_ring_length;
+
+static int _rl_copy_to_kill_ring PARAMS((char *, int));
+static int region_kill_internal PARAMS((int));
+static int _rl_copy_word_as_kill PARAMS((int, int));
+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;
+{
+  return 0;
+}
+
+/* Add TEXT to the kill ring, allocating a new kill ring slot as necessary.
+   This uses TEXT directly, so the caller must not free it.  If APPEND is
+   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;
+{
+  char *old, *new;
+  int slot;
+
+  /* First, find the slot to work with. */
+  if (_rl_last_command_was_kill == 0)
+    {
+      /* Get a new slot.  */
+      if (rl_kill_ring == 0)
+	{
+	  /* If we don't have any defined, then make one. */
+	  rl_kill_ring = (char **)
+	    xmalloc (((rl_kill_ring_length = 1) + 1) * sizeof (char *));
+	  rl_kill_ring[slot = 0] = (char *)NULL;
+	}
+      else
+	{
+	  /* We have to add a new slot on the end, unless we have
+	     exceeded the max limit for remembering kills. */
+	  slot = rl_kill_ring_length;
+	  if (slot == rl_max_kills)
+	    {
+	      register int i;
+	      xfree (rl_kill_ring[0]);
+	      for (i = 0; i < slot; i++)
+		rl_kill_ring[i] = rl_kill_ring[i + 1];
+	    }
+	  else
+	    {
+	      slot = rl_kill_ring_length += 1;
+	      rl_kill_ring = (char **)xrealloc (rl_kill_ring, slot * sizeof (char *));
+	    }
+	  rl_kill_ring[--slot] = (char *)NULL;
+	}
+    }
+  else
+    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)
+    {
+      old = rl_kill_ring[slot];
+      new = (char *)xmalloc (1 + strlen (old) + strlen (text));
+
+      if (append)
+	{
+	  strcpy (new, old);
+	  strcat (new, text);
+	}
+      else
+	{
+	  strcpy (new, text);
+	  strcat (new, old);
+	}
+      xfree (old);
+      xfree (text);
+      rl_kill_ring[slot] = new;
+    }
+  else
+    rl_kill_ring[slot] = text;
+
+  rl_kill_index = slot;
+  return 0;
+}
+
+/* The way to kill something.  This appends or prepends to the last
+   kill, if the last command was a kill command.  if FROM is less
+   than TO, then the text is appended, otherwise prepended.  If the
+   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;
+{
+  char *text;
+
+  /* Is there anything to kill? */
+  if (from == to)
+    {
+      _rl_last_command_was_kill++;
+      return 0;
+    }
+
+  text = rl_copy_text (from, to);
+
+  /* Delete the copied text from the line. */
+  rl_delete_text (from, to);
+
+  _rl_copy_to_kill_ring (text, from < to);
+
+  _rl_last_command_was_kill++;
+  return 0;
+}
+
+/* Now REMEMBER!  In order to do prepending or appending correctly, kill
+   commands always make rl_point's original position be the FROM argument,
+   and rl_point's extent be the TO argument. */
+
+/* **************************************************************** */
+/*								    */
+/*			Killing Commands			    */
+/*								    */
+/* **************************************************************** */
+
+/* Delete the word at point, saving the text in the kill ring. */
+int
+rl_kill_word (count, key)
+     int count, key;
+{
+  int orig_point;
+
+  if (count < 0)
+    return (rl_backward_kill_word (-count, key));
+  else
+    {
+      orig_point = rl_point;
+      rl_forward_word (count, key);
+
+      if (rl_point != orig_point)
+	rl_kill_text (orig_point, rl_point);
+
+      rl_point = orig_point;
+      if (rl_editing_mode == emacs_mode)
+	rl_mark = rl_point;
+    }
+  return 0;
+}
+
+/* Rubout the word before point, placing it on the kill ring. */
+int
+rl_backward_kill_word (count, ignore)
+     int count, ignore;
+{
+  int orig_point;
+
+  if (count < 0)
+    return (rl_kill_word (-count, ignore));
+  else
+    {
+      orig_point = rl_point;
+      rl_backward_word (count, ignore);
+
+      if (rl_point != orig_point)
+	rl_kill_text (orig_point, rl_point);
+
+      if (rl_editing_mode == emacs_mode)
+	rl_mark = rl_point;
+    }
+  return 0;
+}
+
+/* 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;
+{
+  int orig_point;
+
+  if (direction < 0)
+    return (rl_backward_kill_line (1, ignore));
+  else
+    {
+      orig_point = rl_point;
+      rl_end_of_line (1, ignore);
+      if (orig_point != rl_point)
+	rl_kill_text (orig_point, rl_point);
+      rl_point = orig_point;
+      if (rl_editing_mode == emacs_mode)
+	rl_mark = rl_point;
+    }
+  return 0;
+}
+
+/* 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;
+{
+  int orig_point;
+
+  if (direction < 0)
+    return (rl_kill_line (1, ignore));
+  else
+    {
+      if (!rl_point)
+	rl_ding ();
+      else
+	{
+	  orig_point = rl_point;
+	  rl_beg_of_line (1, ignore);
+	  if (rl_point != orig_point)
+	    rl_kill_text (orig_point, rl_point);
+	  if (rl_editing_mode == emacs_mode)
+	    rl_mark = rl_point;
+	}
+    }
+  return 0;
+}
+
+/* Kill the whole line, no matter where point is. */
+int
+rl_kill_full_line (count, ignore)
+     int count, ignore;
+{
+  rl_begin_undo_group ();
+  rl_point = 0;
+  rl_kill_text (rl_point, rl_end);
+  rl_mark = 0;
+  rl_end_undo_group ();
+  return 0;
+}
+
+/* The next two functions mimic unix line editing behaviour, except they
+   save the deleted text on the kill ring.  This is safer than not saving
+   it, and since we have a ring, nobody should get screwed. */
+
+/* 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;
+{
+  int orig_point;
+
+  if (rl_point == 0)
+    rl_ding ();
+  else
+    {
+      orig_point = rl_point;
+      if (count <= 0)
+	count = 1;
+
+      while (count--)
+	{
+	  while (rl_point && whitespace (rl_line_buffer[rl_point - 1]))
+	    rl_point--;
+
+	  while (rl_point && (whitespace (rl_line_buffer[rl_point - 1]) == 0))
+	    rl_point--;
+	}
+
+      rl_kill_text (orig_point, rl_point);
+      if (rl_editing_mode == emacs_mode)
+	rl_mark = rl_point;
+    }
+
+  return 0;
+}
+
+/* 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;
+{
+  int orig_point, c;
+
+  if (rl_point == 0)
+    rl_ding ();
+  else
+    {
+      orig_point = rl_point;
+      if (count <= 0)
+	count = 1;
+
+      while (count--)
+	{
+	  c = rl_line_buffer[rl_point - 1];
+	  while (rl_point && (whitespace (c) || c == '/'))
+	    {
+	      rl_point--;
+	      c = rl_line_buffer[rl_point - 1];
+	    }
+
+	  while (rl_point && (whitespace (c) == 0) && c != '/')
+	    {
+	      rl_point--;
+	      c = rl_line_buffer[rl_point - 1];
+	    }
+	}
+
+      rl_kill_text (orig_point, rl_point);
+      if (rl_editing_mode == emacs_mode)
+	rl_mark = rl_point;
+    }
+
+  return 0;
+}
+
+/* Here is C-u doing what Unix does.  You don't *have* to use these
+   key-bindings.  We have a choice of killing the entire line, or
+   killing from where we are to the start of the line.  We choose the
+   latter, because if you are a Unix weenie, then you haven't backspaced
+   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;
+{
+  if (rl_point == 0)
+    rl_ding ();
+  else
+    {
+      rl_kill_text (rl_point, 0);
+      rl_point = 0;
+      if (rl_editing_mode == emacs_mode)
+	rl_mark = rl_point;
+    }
+  return 0;
+}
+
+/* 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;
+{
+  char *text;
+
+  if (rl_mark != rl_point)
+    {
+      text = rl_copy_text (rl_point, rl_mark);
+      if (delete)
+	rl_delete_text (rl_point, rl_mark);
+      _rl_copy_to_kill_ring (text, rl_point < rl_mark);
+    }
+
+  _rl_last_command_was_kill++;
+  return 0;
+}
+
+/* Copy the text in the region to the kill ring. */
+int
+rl_copy_region_to_kill (count, ignore)
+     int count, ignore;
+{
+  return (region_kill_internal (0));
+}
+
+/* Kill the text between the point and mark. */
+int
+rl_kill_region (count, ignore)
+     int count, ignore;
+{
+  int r, npoint;
+
+  npoint = (rl_point < rl_mark) ? rl_point : rl_mark;
+  r = region_kill_internal (1);
+  _rl_fix_point (1);
+  rl_point = npoint;
+  return r;
+}
+
+/* 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;
+{
+  int om, op, r;
+
+  om = rl_mark;
+  op = rl_point;
+
+  if (dir > 0)
+    rl_forward_word (count, 0);
+  else
+    rl_backward_word (count, 0);
+
+  rl_mark = rl_point;
+
+  if (dir > 0)
+    rl_backward_word (count, 0);
+  else
+    rl_forward_word (count, 0);
+
+  r = region_kill_internal (0);
+
+  rl_mark = om;
+  rl_point = op;
+
+  return r;
+}
+
+int
+rl_copy_forward_word (count, key)
+     int count, key;
+{
+  if (count < 0)
+    return (rl_copy_backward_word (-count, key));
+
+  return (_rl_copy_word_as_kill (count, 1));
+}
+
+int
+rl_copy_backward_word (count, key)
+     int count, key;
+{
+  if (count < 0)
+    return (rl_copy_forward_word (-count, key));
+
+  return (_rl_copy_word_as_kill (count, -1));
+}
+  
+/* Yank back the last killed text.  This ignores arguments. */
+int
+rl_yank (count, ignore)
+     int count, ignore;
+{
+  if (rl_kill_ring == 0)
+    {
+      _rl_abort_internal ();
+      return -1;
+    }
+
+  _rl_set_mark_at_pos (rl_point);
+  rl_insert_text (rl_kill_ring[rl_kill_index]);
+  return 0;
+}
+
+/* If the last command was yank, or yank_pop, and the text just
+   before point is identical to the current kill item, then
+   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;
+{
+  int l, n;
+
+  if (((rl_last_func != rl_yank_pop) && (rl_last_func != rl_yank)) ||
+      !rl_kill_ring)
+    {
+      _rl_abort_internal ();
+      return -1;
+    }
+
+  l = strlen (rl_kill_ring[rl_kill_index]);
+  n = rl_point - l;
+  if (n >= 0 && STREQN (rl_line_buffer + n, rl_kill_ring[rl_kill_index], l))
+    {
+      rl_delete_text (n, rl_point);
+      rl_point = n;
+      rl_kill_index--;
+      if (rl_kill_index < 0)
+	rl_kill_index = rl_kill_ring_length - 1;
+      rl_yank (1, 0);
+      return 0;
+    }
+  else
+    {
+      _rl_abort_internal ();
+      return -1;
+    }
+}
+
+/* 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;
+{
+  register HIST_ENTRY *entry;
+  char *arg;
+  int i, pos;
+
+  pos = where_history ();
+
+  if (history_skip)
+    {
+      for (i = 0; i < history_skip; i++)
+	entry = previous_history ();
+    }
+
+  entry = previous_history ();
+
+  history_set_pos (pos);
+
+  if (entry == 0)
+    {
+      rl_ding ();
+      return -1;
+    }
+
+  arg = history_arg_extract (count, count, entry->line);
+  if (!arg || !*arg)
+    {
+      rl_ding ();
+      FREE (arg);
+      return -1;
+    }
+
+  rl_begin_undo_group ();
+
+  _rl_set_mark_at_pos (rl_point);
+
+#if defined (VI_MODE)
+  /* Vi mode always inserts a space before yanking the argument, and it
+     inserts it right *after* rl_point. */
+  if (rl_editing_mode == vi_mode)
+    {
+      rl_vi_append_mode (1, ignore);
+      rl_insert_text (" ");
+    }
+#endif /* VI_MODE */
+
+  rl_insert_text (arg);
+  xfree (arg);
+
+  rl_end_undo_group ();
+  return 0;
+}
+
+/* Yank the COUNTth argument from the previous history line. */
+int
+rl_yank_nth_arg (count, ignore)
+     int count, ignore;
+{
+  return (rl_yank_nth_arg_internal (count, ignore, 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;
+{
+  static int history_skip = 0;
+  static int explicit_arg_p = 0;
+  static int count_passed = 1;
+  static int direction = 1;
+  static int undo_needed = 0;
+  int retval;
+
+  if (rl_last_func != rl_yank_last_arg)
+    {
+      history_skip = 0;
+      explicit_arg_p = rl_explicit_arg;
+      count_passed = count;
+      direction = 1;
+    }
+  else
+    {
+      if (undo_needed)
+	rl_do_undo ();
+      if (count < 0)		/* XXX - was < 1 */
+        direction = -direction;
+      history_skip += direction;
+      if (history_skip < 0)
+	history_skip = 0;
+    }
+ 
+  if (explicit_arg_p)
+    retval = rl_yank_nth_arg_internal (count_passed, key, history_skip);
+  else
+    retval = rl_yank_nth_arg_internal ('$', key, history_skip);
+
+  undo_needed = retval == 0;
+  return retval;
+}
+
+/* A special paste command for users of Cygnus's cygwin32. */
+#if defined (__CYGWIN__)
+#include <windows.h>
+
+int
+rl_paste_from_clipboard (count, key)
+     int count, key;
+{
+  char *data, *ptr;
+  int len;
+
+  if (OpenClipboard (NULL) == 0)
+    return (0);
+
+  data = (char *)GetClipboardData (CF_TEXT);
+  if (data)
+    {
+      ptr = strchr (data, '\r');
+      if (ptr)
+	{
+	  len = ptr - data;
+	  ptr = (char *)xmalloc (len + 1);
+	  ptr[len] = '\0';
+	  strncpy (ptr, data, len);
+	}
+      else
+        ptr = data;
+      _rl_set_mark_at_pos (rl_point);
+      rl_insert_text (ptr);
+      if (ptr != data)
+	xfree (ptr);
+      CloseClipboard ();
+    }
+  return (0);
+}
+#endif /* __CYGWIN__ */

lib/readline/macro.c

@@ -219,7 +219,7 @@ rl_start_kbd_macro (ignore1, ignore2)
   if (RL_ISSTATE (RL_STATE_MACRODEF))
     {
       _rl_abort_internal ();
-      return -1;
+      return 1;
     }
 
   if (rl_explicit_arg)
@@ -244,7 +244,7 @@ rl_end_kbd_macro (count, ignore)
   if (RL_ISSTATE (RL_STATE_MACRODEF) == 0)
     {
       _rl_abort_internal ();
-      return -1;
+      return 1;
     }
 
   current_macro_index -= rl_key_sequence_length;

lib/readline/macro.c~

@@ -0,0 +1,307 @@
+/* macro.c -- keyboard macros for readline. */
+
+/* Copyright (C) 1994-2009 Free Software Foundation, Inc.
+
+   This file is part of the GNU Readline Library (Readline), a library
+   for reading lines of text with interactive input and history editing.      
+
+   Readline is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation, either version 3 of the License, or
+   (at your option) any later version.
+
+   Readline is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with Readline.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#define READLINE_LIBRARY
+
+#if defined (HAVE_CONFIG_H)
+#  include <config.h>
+#endif
+
+#include <sys/types.h>
+
+#if defined (HAVE_UNISTD_H)
+#  include <unistd.h>           /* for _POSIX_VERSION */
+#endif /* HAVE_UNISTD_H */
+
+#if defined (HAVE_STDLIB_H)
+#  include <stdlib.h>
+#else
+#  include "ansi_stdlib.h"
+#endif /* HAVE_STDLIB_H */
+
+#include <stdio.h>
+
+/* System-specific feature definitions and include files. */
+#include "rldefs.h"
+
+/* Some standard library routines. */
+#include "readline.h"
+#include "history.h"
+
+#include "rlprivate.h"
+#include "xmalloc.h"
+
+/* **************************************************************** */
+/*								    */
+/*			Hacking Keyboard Macros 		    */
+/*								    */
+/* **************************************************************** */
+
+/* The currently executing macro string.  If this is non-zero,
+   then it is a malloc ()'ed string where input is coming from. */
+char *rl_executing_macro = (char *)NULL;
+
+/* The offset in the above string to the next character to be read. */
+static int executing_macro_index;
+
+/* The current macro string being built.  Characters get stuffed
+   in here by add_macro_char (). */
+static char *current_macro = (char *)NULL;
+
+/* The size of the buffer allocated to current_macro. */
+static int current_macro_size;
+
+/* The index at which characters are being added to current_macro. */
+static int current_macro_index;
+
+/* A structure used to save nested macro strings.
+   It is a linked list of string/index for each saved macro. */
+struct saved_macro {
+  struct saved_macro *next;
+  char *string;
+  int sindex;
+};
+
+/* The list of saved macros. */
+static struct saved_macro *macro_list = (struct saved_macro *)NULL;
+
+/* 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_push_executing_macro ();
+  rl_executing_macro = string;
+  executing_macro_index = 0;
+  RL_SETSTATE(RL_STATE_MACROINPUT);
+}
+
+/* Return the next character available from a macro, or 0 if
+   there are no macro characters. */
+int
+_rl_next_macro_key ()
+{
+  int c;
+
+  if (rl_executing_macro == 0)
+    return (0);
+
+  if (rl_executing_macro[executing_macro_index] == 0)
+    {
+      _rl_pop_executing_macro ();
+      return (_rl_next_macro_key ());
+    }
+
+#if defined (READLINE_CALLBACKS)
+  c = rl_executing_macro[executing_macro_index++];
+  if (RL_ISSTATE (RL_STATE_CALLBACK) && RL_ISSTATE (RL_STATE_READCMD|RL_STATE_MOREINPUT) && rl_executing_macro[executing_macro_index] == 0)
+      _rl_pop_executing_macro ();
+  return c;
+#else
+  return (rl_executing_macro[executing_macro_index++]);
+#endif
+}
+
+int
+_rl_prev_macro_key ()
+{
+  if (rl_executing_macro == 0)
+    return (0);
+
+  if (executing_macro_index == 0)
+    return (0);
+
+  executing_macro_index--;
+  return (rl_executing_macro[executing_macro_index]);
+}
+
+/* Save the currently executing macro on a stack of saved macros. */
+void
+_rl_push_executing_macro ()
+{
+  struct saved_macro *saver;
+
+  saver = (struct saved_macro *)xmalloc (sizeof (struct saved_macro));
+  saver->next = macro_list;
+  saver->sindex = executing_macro_index;
+  saver->string = rl_executing_macro;
+
+  macro_list = saver;
+}
+
+/* Discard the current macro, replacing it with the one
+   on the top of the stack of saved macros. */
+void
+_rl_pop_executing_macro ()
+{
+  struct saved_macro *macro;
+
+  FREE (rl_executing_macro);
+  rl_executing_macro = (char *)NULL;
+  executing_macro_index = 0;
+
+  if (macro_list)
+    {
+      macro = macro_list;
+      rl_executing_macro = macro_list->string;
+      executing_macro_index = macro_list->sindex;
+      macro_list = macro_list->next;
+      xfree (macro);
+    }
+
+  if (rl_executing_macro == 0)
+    RL_UNSETSTATE(RL_STATE_MACROINPUT);
+}
+
+/* Add a character to the macro being built. */
+void
+_rl_add_macro_char (c)
+     int c;
+{
+  if (current_macro_index + 1 >= current_macro_size)
+    {
+      if (current_macro == 0)
+	current_macro = (char *)xmalloc (current_macro_size = 25);
+      else
+	current_macro = (char *)xrealloc (current_macro, current_macro_size += 25);
+    }
+
+  current_macro[current_macro_index++] = c;
+  current_macro[current_macro_index] = '\0';
+}
+
+void
+_rl_kill_kbd_macro ()
+{
+  if (current_macro)
+    {
+      xfree (current_macro);
+      current_macro = (char *) NULL;
+    }
+  current_macro_size = current_macro_index = 0;
+
+  FREE (rl_executing_macro);
+  rl_executing_macro = (char *) NULL;
+  executing_macro_index = 0;
+
+  RL_UNSETSTATE(RL_STATE_MACRODEF);
+}
+
+/* Begin defining a keyboard macro.
+   Keystrokes are recorded as they are executed.
+   End the definition with rl_end_kbd_macro ().
+   If a numeric argument was explicitly typed, then append this
+   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;
+{
+  if (RL_ISSTATE (RL_STATE_MACRODEF))
+    {
+      _rl_abort_internal ();
+      return -1;
+    }
+
+  if (rl_explicit_arg)
+    {
+      if (current_macro)
+	_rl_with_macro_input (savestring (current_macro));
+    }
+  else
+    current_macro_index = 0;
+
+  RL_SETSTATE(RL_STATE_MACRODEF);
+  return 0;
+}
+
+/* Stop defining a keyboard macro.
+   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;
+{
+  if (RL_ISSTATE (RL_STATE_MACRODEF) == 0)
+    {
+      _rl_abort_internal ();
+      return -1;
+    }
+
+  current_macro_index -= rl_key_sequence_length;
+  current_macro[current_macro_index] = '\0';
+
+  RL_UNSETSTATE(RL_STATE_MACRODEF);
+
+  return (rl_call_last_kbd_macro (--count, 0));
+}
+
+/* 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;
+{
+  if (current_macro == 0)
+    _rl_abort_internal ();
+
+  if (RL_ISSTATE (RL_STATE_MACRODEF))
+    {
+      rl_ding ();		/* no recursive macros */
+      current_macro[--current_macro_index] = '\0';	/* erase this char */
+      return 0;
+    }
+
+  while (count--)
+    _rl_with_macro_input (savestring (current_macro));
+  return 0;
+}
+
+int
+rl_print_last_kbd_macro (count, ignore)
+     int count, ignore;
+{
+  char *m;
+
+  if (current_macro == 0)
+    {
+      rl_ding ();
+      return 0;
+    }
+  m = _rl_untranslate_macro_value (current_macro, 1);
+  rl_crlf ();
+  printf ("%s", m);
+  fflush (stdout);
+  rl_crlf ();
+  FREE (m);
+  rl_forced_update_display ();
+  rl_display_fixed = 1;
+
+  return 0;
+}
+
+void
+rl_push_macro_input (macro)
+     char *macro;
+{
+  _rl_with_macro_input (macro);
+}

lib/readline/text.c

@@ -906,7 +906,7 @@ _rl_insert_next (count)
   RL_UNSETSTATE(RL_STATE_MOREINPUT);
 
   if (c < 0)
-    return -1;
+    return 1;
 
   if (RL_ISSTATE (RL_STATE_MACRODEF))
     _rl_add_macro_char (c);
@@ -1066,7 +1066,7 @@ rl_rubout (count, key)
   if (!rl_point)
     {
       rl_ding ();
-      return -1;
+      return 1;
     }
 
   if (rl_insert_mode == RL_IM_OVERWRITE)
@@ -1089,7 +1089,7 @@ _rl_rubout_char (count, key)
   if (rl_point == 0)
     {
       rl_ding ();
-      return -1;
+      return 1;
     }
 
   orig_point = rl_point;
@@ -1133,7 +1133,7 @@ rl_delete (count, key)
   if (rl_point == rl_end)
     {
       rl_ding ();
-      return -1;
+      return 1;
     }
 
   if (count > 1 || rl_explicit_arg)
@@ -1303,7 +1303,7 @@ rl_change_case (count, op)
   if (op != UpCase && op != DownCase && op != CapCase)
     {
       rl_ding ();
-      return -1;
+      return 1;
     }
 
   if (count < 0)
@@ -1403,7 +1403,7 @@ rl_transpose_words (count, key)
     {
       rl_ding ();
       rl_point = orig_point;
-      return -1;
+      return 1;
     }
 
   /* Get the text of the words. */
@@ -1456,7 +1456,7 @@ rl_transpose_chars (count, key)
   if (!rl_point || rl_end < 2)
     {
       rl_ding ();
-      return -1;
+      return 1;
     }
 
   rl_begin_undo_group ();
@@ -1519,7 +1519,7 @@ _rl_char_search_internal (count, dir, schar)
 #endif
 
   if (dir == 0)
-    return -1;
+    return 1;
 
   pos = rl_point;
   inc = (dir < 0) ? -1 : 1;
@@ -1528,7 +1528,7 @@ _rl_char_search_internal (count, dir, schar)
       if ((dir < 0 && pos <= 0) || (dir > 0 && pos >= rl_end))
 	{
 	  rl_ding ();
-	  return -1;
+	  return 1;
 	}
 
 #if defined (HANDLE_MULTIBYTE)
@@ -1583,7 +1583,7 @@ _rl_char_search (count, fdir, bdir)
   mb_len = _rl_read_mbchar (mbchar, MB_LEN_MAX);
 
   if (mb_len <= 0)
-    return -1;
+    return 1;
 
   if (count < 0)
     return (_rl_char_search_internal (-count, bdir, mbchar, mb_len));
@@ -1602,7 +1602,7 @@ _rl_char_search (count, fdir, bdir)
   RL_UNSETSTATE(RL_STATE_MOREINPUT);
 
   if (c < 0)
-    return -1;
+    return 1;
 
   if (count < 0)
     return (_rl_char_search_internal (-count, bdir, c));
@@ -1671,7 +1671,7 @@ _rl_set_mark_at_pos (position)
      int position;
 {
   if (position > rl_end)
-    return -1;
+    return 1;
 
   rl_mark = position;
   return 0;
@@ -1696,7 +1696,7 @@ rl_exchange_point_and_mark (count, key)
   if (rl_mark == -1)
     {
       rl_ding ();
-      return -1;
+      return 1;
     }
   else
     SWAP (rl_point, rl_mark);

lib/readline/vi_mode.c

@@ -471,7 +471,7 @@ rl_vi_end_word (count, key)
   if (count < 0)
     {
       rl_ding ();
-      return -1;
+      return 1;
     }
 
   if (_rl_uppercase_p (key))
@@ -1541,7 +1541,7 @@ rl_vi_rubout (count, key)
   if (rl_point == 0)
     {
       rl_ding ();
-      return -1;
+      return 1;
     }
 
   opoint = rl_point;
@@ -1572,7 +1572,7 @@ rl_vi_delete (count, key)
   if (rl_end == 0)
     {
       rl_ding ();
-      return -1;
+      return 1;
     }
 
   if (MB_CUR_MAX > 1 && rl_byte_oriented == 0)
@@ -1657,13 +1657,13 @@ rl_vi_char_search (count, key)
   if (key == ';' || key == ',')
     {
       if (_rl_cs_orig_dir == 0)
-	return -1;
+	return 1;
 #if defined (HANDLE_MULTIBYTE)
       if (_rl_vi_last_search_mblen == 0)
-	return -1;
+	return 1;
 #else
       if (_rl_vi_last_search_char == 0)
-	return -1;
+	return 1;
 #endif
       _rl_cs_dir = (key == ';') ? _rl_cs_orig_dir : -_rl_cs_orig_dir;
     }
@@ -1762,7 +1762,7 @@ rl_vi_match (ignore, key)
 	{
 	  rl_point = pos;
 	  rl_ding ();
-	  return -1;
+	  return 1;
 	}
     }
 
@@ -1792,7 +1792,7 @@ rl_vi_match (ignore, key)
 	  else
 	    {
 	      rl_ding ();
-	      return -1;
+	      return 1;
 	    }
 	}
     }
@@ -1816,7 +1816,7 @@ rl_vi_match (ignore, key)
 	  else
 	    {
 	      rl_ding ();
-	      return -1;
+	      return 1;
 	    }
 	}
     }
@@ -2090,7 +2090,7 @@ _rl_vi_set_mark ()
   if (ch < 0 || ch < 'a' || ch > 'z')	/* make test against 0 explicit */
     {
       rl_ding ();
-      return -1;
+      return 1;
     }
   ch -= 'a';
   vi_mark_chars[ch] = rl_point;
@@ -2142,14 +2142,14 @@ _rl_vi_goto_mark ()
   else if (ch < 0 || ch < 'a' || ch > 'z')	/* make test against 0 explicit */
     {
       rl_ding ();
-      return -1;
+      return 1;
     }
 
   ch -= 'a';
   if (vi_mark_chars[ch] == -1)
     {
       rl_ding ();
-      return -1;
+      return 1;
     }
   rl_point = vi_mark_chars[ch];
   return 0;