Sync readline/ to version 7.0 alpha

This patch syncs our upstream copy of readline from version 6.2 to the
latest version, 7.0 alpha (released July 10 2015).

I essentially copied what was done the last time readline was synced,
when Jan updated to readline 6.2 in 2011:
http://sourceware.org/ml/gdb-patches/2011-05/msg00003.html

Procedure:

1. I extracted the readline-7.0-alpha tarball on top of readline/.
2. I deleted all the new files under doc/ that were deliberately omitted
   before.
3. I regenerated readline/configure and readline/examples/rlfe/configure
   using autoconf 2.64.  No other configure files need regenerating.
4. I updated the function gdb_printable_part in completer.c with a
   trivial change made to the readline function it is based off of,
   printable_part in readline/complete.c.  There is more work to be done in
   completer.c to sync it with readline/complete.c, but it is non-trivial
   and should probably be done separately anyway.

Local patches that had to be reapplied:

    None.  readline 7.0 alpha contains all of our local readline
    patches.

New files in readline/:

    colors.{c,h}
    examples/{hist_erasedups,hist_purgecmd,rl-callbacktest,rlbasic}.c
    parse-colors.{c,h}
    readline.pc.in
    configure.ac

Deleted files in readline/:

    configure.in

Regressions:

After the sync there is one testsuite regression, the test
"signal SIGINT" in gdb.gdb/selftest.exp which now FAILs.  Previously,
the readline 6.2 SIGINT handler would temporarily reinstall the
underlying application's SIGINT handler and immediately re-raise SIGINT
so that the orginal handler gets invoked.  But now (since readline 6.3)
its SIGINT handler does not re-raise SIGINT or directly invoke the
original handler; it now sets a flag marking that SIGINT was raised, and
waits until readline explicitly has control to call the application's
SIGINT handler.  Anyway, because SIGINT is no longer re-raised from
within readline's SIGINT handler, doing "signal SIGINT" with a stopped
inferior gdb process will no longer resume and then immediately stop the
process (since there is no 2nd SIGINT to immediately catch).  Instead,
the inferior gdb process will now just print "Quit" and continue to run.
So with this commit, this particular test case is adjusted to reflect
this change in behavior (we now have to send a 2nd SIGINT manually to
stop it).

Aside from this one testsuite regression, I personally noticed no
regression in user-visible behavior.  Though I only tested on x86_64
and on i686 Debian Stretch.

Getting this kind of change in at the start of the GDB 7.11 development
cycle will allow us to get a lot of passive testing from developers and
from bleeding-edge users.

readline/ChangeLog.gdb:

	Import readline 7.0 alpha
	* configure: Regenerate.
	* examples/rlfe/configure: Regenerate.

gdb/ChangeLog:

	* completer.c (gdb_printable_part): Sync with readline function
	it is based off of.

gdb/testsuite/ChangeLog:

	* gdb.gdb/selftest.exp (test_with_self): Update test to now
	expect the GDB inferior to no longer immediately stop after
	being resumed with "signal SIGINT".

1 files changed, 99 insertions, 45 deletions

diff --git a/readline/signals.c b/readline/signals.c
index f119691..6143045 100644
--- a/readline/signals.c
+++ b/readline/signals.c
@@ -1,6 +1,6 @@
 /* signals.c -- signal handling support for readline. */
 
-/* Copyright (C) 1987-2009 Free Software Foundation, Inc.
+/* Copyright (C) 1987-2011 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.      
@@ -80,6 +80,7 @@ typedef struct { SigHandler *sa_handler; int sa_mask, sa_flags; } sighandler_cxt
 
 static SigHandler *rl_set_sighandler PARAMS((int, SigHandler *, sighandler_cxt *));
 static void rl_maybe_set_sighandler PARAMS((int, SigHandler *, sighandler_cxt *));
+static void rl_maybe_restore_sighandler PARAMS((int, sighandler_cxt *));
 
 static RETSIGTYPE rl_signal_handler PARAMS((int));
 static RETSIGTYPE _rl_handle_signal PARAMS((int));
@@ -87,7 +88,7 @@ static RETSIGTYPE _rl_handle_signal PARAMS((int));
 /* Exported variables for use by applications. */
 
 /* If non-zero, readline will install its own signal handlers for
-   SIGINT, SIGTERM, SIGQUIT, SIGALRM, SIGTSTP, SIGTTIN, and SIGTTOU. */
+   SIGINT, SIGTERM, SIGHUP, SIGQUIT, SIGALRM, SIGTSTP, SIGTTIN, and SIGTTOU. */
 int rl_catch_signals = 1;
 
 /* If non-zero, readline will install a signal handler for SIGWINCH. */
@@ -118,7 +119,7 @@ static int sigwinch_set_flag;
 /*								    */
 /* **************************************************************** */
 
-static sighandler_cxt old_int, old_term, old_alrm, old_quit;
+static sighandler_cxt old_int, old_term, old_hup, old_alrm, old_quit;
 #if defined (SIGTSTP)
 static sighandler_cxt old_tstp, old_ttou, old_ttin;
 #endif
@@ -126,6 +127,9 @@ static sighandler_cxt old_tstp, old_ttou, old_ttin;
 static sighandler_cxt old_winch;
 #endif
 
+_rl_sigcleanup_func_t *_rl_sigcleanup;
+void *_rl_sigcleanarg;
+
 /* Readline signal handler functions. */
 
 /* Called from RL_CHECK_SIGNALS() macro */
@@ -135,7 +139,21 @@ _rl_signal_handler (sig)
 {
   _rl_caught_signal = 0;	/* XXX */
 
-  _rl_handle_signal (sig);
+#if defined (SIGWINCH)
+  if (sig == SIGWINCH)
+    {
+      rl_resize_terminal ();
+      /* XXX - experimental for now */
+      /* Call a signal hook because though we called the original signal handler
+	 in rl_sigwinch_handler below, we will not resend the signal to
+	 ourselves. */
+      if (rl_signal_event_hook)
+	(*rl_signal_event_hook) ();
+    }
+  else
+#endif
+    _rl_handle_signal (sig);
+
   SIGHANDLER_RETURN;
 }
 
@@ -143,7 +161,7 @@ static RETSIGTYPE
 rl_signal_handler (sig)
      int sig;
 {
-  if (_rl_interrupt_immediately || RL_ISSTATE(RL_STATE_CALLBACK))
+  if (_rl_interrupt_immediately)
     {
       _rl_interrupt_immediately = 0;
       _rl_handle_signal (sig);
@@ -181,19 +199,43 @@ _rl_handle_signal (sig)
     rl_set_sighandler (sig, SIG_IGN, &dummy_cxt);
 #endif /* !HAVE_BSD_SIGNALS && !HAVE_POSIX_SIGNALS */
 
+  /* If there's a sig cleanup function registered, call it and `deregister'
+     the cleanup function to avoid multiple calls */
+  if (_rl_sigcleanup)
+    {
+      (*_rl_sigcleanup) (sig, _rl_sigcleanarg);
+      _rl_sigcleanup = 0;
+      _rl_sigcleanarg = 0;
+    }
+    
   switch (sig)
     {
     case SIGINT:
       _rl_reset_completion_state ();
       rl_free_line_state ();
+#if defined (READLINE_CALLBACKS)
+      rl_callback_sigcleanup ();
+#endif
+
       /* FALLTHROUGH */
 
-    case SIGTERM:
 #if defined (SIGTSTP)
     case SIGTSTP:
-    case SIGTTOU:
     case SIGTTIN:
+#  if defined (HAVE_POSIX_SIGNALS)
+      /* Block SIGTTOU so we can restore the terminal settings to something
+	 sane without stopping on SIGTTOU if we have been placed into the
+	 background.  Even trying to get the current terminal pgrp with
+	 tcgetpgrp() will generate SIGTTOU, so we don't bother.  Don't bother
+	 doing this if we've been stopped on SIGTTOU; it's aready too late. */
+      sigemptyset (&set);
+      sigaddset (&set, SIGTTOU);
+      sigprocmask (SIG_BLOCK, &set, (sigset_t *)NULL);
+#  endif
+    case SIGTTOU:
 #endif /* SIGTSTP */
+    case SIGTERM:
+    case SIGHUP:
 #if defined (SIGALRM)
     case SIGALRM:
 #endif
@@ -204,6 +246,10 @@ _rl_handle_signal (sig)
       rl_cleanup_after_signal ();
 
 #if defined (HAVE_POSIX_SIGNALS)
+      /* Unblock SIGTTOU blocked above */
+      if (sig == SIGTTIN || sig == SIGTSTP)
+	sigprocmask (SIG_UNBLOCK, &set, (sigset_t *)NULL);
+
       sigemptyset (&set);
       sigprocmask (SIG_BLOCK, (sigset_t *)NULL, &set);
       sigdelset (&set, sig);
@@ -232,7 +278,7 @@ _rl_handle_signal (sig)
 #  endif /* HAVE_BSD_SIGNALS */
 #endif /* !HAVE_POSIX_SIGNALS */
 
-      rl_reset_after_signal ();
+      rl_reset_after_signal ();      
     }
 
   RL_UNSETSTATE(RL_STATE_SIGHANDLER);
@@ -257,7 +303,7 @@ rl_sigwinch_handler (sig)
 #endif
 
   RL_SETSTATE(RL_STATE_SIGHANDLER);
-  rl_resize_terminal ();
+  _rl_caught_signal = sig;
 
   /* If another sigwinch handler has been installed, call it. */
   oh = (SigHandler *)old_winch.sa_handler;
@@ -317,6 +363,8 @@ rl_set_sighandler (sig, handler, ohandler)
   return (ohandler->sa_handler);
 }
 
+/* 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;
@@ -327,11 +375,29 @@ rl_maybe_set_sighandler (sig, handler, ohandler)
   SigHandler *oh;
 
   sigemptyset (&dummy.sa_mask);
+  dummy.sa_flags = 0;
   oh = rl_set_sighandler (sig, handler, ohandler);
   if (oh == (SigHandler *)SIG_IGN)
     rl_sigaction (sig, ohandler, &dummy);
 }
 
+/* Set the disposition of SIG to HANDLER, if HANDLER->sa_handler indicates the
+   signal was not being ignored.  MUST only be called for signals whose
+   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;
+{
+  sighandler_cxt dummy;
+
+  sigemptyset (&dummy.sa_mask);
+  dummy.sa_flags = 0;
+  if (handler->sa_handler != SIG_IGN)
+    rl_sigaction (sig, handler, &dummy);
+}
+
 int
 rl_set_signals ()
 {
@@ -349,6 +415,7 @@ rl_set_signals ()
 
       sigaddset (&bset, SIGINT);
       sigaddset (&bset, SIGTERM);
+      sigaddset (&bset, SIGHUP);
 #if defined (SIGQUIT)
       sigaddset (&bset, SIGQUIT);
 #endif
@@ -377,6 +444,7 @@ rl_set_signals ()
 
       rl_maybe_set_sighandler (SIGINT, rl_signal_handler, &old_int);
       rl_maybe_set_sighandler (SIGTERM, rl_signal_handler, &old_term);
+      rl_maybe_set_sighandler (SIGHUP, rl_signal_handler, &old_hup);
 #if defined (SIGQUIT)
       rl_maybe_set_sighandler (SIGQUIT, rl_signal_handler, &old_quit);
 #endif
@@ -434,25 +502,31 @@ rl_clear_signals ()
     {
       sigemptyset (&dummy.sa_mask);
 
-      rl_sigaction (SIGINT, &old_int, &dummy);
-      rl_sigaction (SIGTERM, &old_term, &dummy);
+      /* Since rl_maybe_set_sighandler doesn't override a SIG_IGN handler,
+	 we should in theory not have to restore a handler where
+	 old_xxx.sa_handler == SIG_IGN.  That's what rl_maybe_restore_sighandler
+	 does.  Fewer system calls should reduce readline's per-line
+	 overhead */
+      rl_maybe_restore_sighandler (SIGINT, &old_int);
+      rl_maybe_restore_sighandler (SIGTERM, &old_term);
+      rl_maybe_restore_sighandler (SIGHUP, &old_hup);
 #if defined (SIGQUIT)
-      rl_sigaction (SIGQUIT, &old_quit, &dummy);
+      rl_maybe_restore_sighandler (SIGQUIT, &old_quit);
 #endif
 #if defined (SIGALRM)
-      rl_sigaction (SIGALRM, &old_alrm, &dummy);
+      rl_maybe_restore_sighandler (SIGALRM, &old_alrm);
 #endif
 
 #if defined (SIGTSTP)
-      rl_sigaction (SIGTSTP, &old_tstp, &dummy);
+      rl_maybe_restore_sighandler (SIGTSTP, &old_tstp);
 #endif /* SIGTSTP */
 
 #if defined (SIGTTOU)
-      rl_sigaction (SIGTTOU, &old_ttou, &dummy);
+      rl_maybe_restore_sighandler (SIGTTOU, &old_ttou);
 #endif /* SIGTTOU */
 
 #if defined (SIGTTIN)
-      rl_sigaction (SIGTTIN, &old_ttin, &dummy);
+      rl_maybe_restore_sighandler (SIGTTIN, &old_ttin);
 #endif /* SIGTTIN */
 
       signals_set_flag = 0;
@@ -540,21 +614,6 @@ _rl_block_sigint ()
   if (sigint_blocked)
     return;
 
-#if defined (HAVE_POSIX_SIGNALS)
-  sigemptyset (&sigint_set);
-  sigemptyset (&sigint_oset);
-  sigaddset (&sigint_set, SIGINT);
-  sigprocmask (SIG_BLOCK, &sigint_set, &sigint_oset);
-#else /* !HAVE_POSIX_SIGNALS */
-#  if defined (HAVE_BSD_SIGNALS)
-  sigint_oldmask = sigblock (sigmask (SIGINT));
-#  else /* !HAVE_BSD_SIGNALS */
-#    if defined (HAVE_USG_SIGHOLD)
-  sighold (SIGINT);
-#    endif /* HAVE_USG_SIGHOLD */
-#  endif /* !HAVE_BSD_SIGNALS */
-#endif /* !HAVE_POSIX_SIGNALS */
-
   sigint_blocked = 1;
 }
 
@@ -565,22 +624,10 @@ _rl_release_sigint ()
   if (sigint_blocked == 0)
     return;
 
-#if defined (HAVE_POSIX_SIGNALS)
-  sigprocmask (SIG_SETMASK, &sigint_oset, (sigset_t *)NULL);
-#else
-#  if defined (HAVE_BSD_SIGNALS)
-  sigsetmask (sigint_oldmask);
-#  else /* !HAVE_BSD_SIGNALS */
-#    if defined (HAVE_USG_SIGHOLD)
-  sigrelse (SIGINT);
-#    endif /* HAVE_USG_SIGHOLD */
-#  endif /* !HAVE_BSD_SIGNALS */
-#endif /* !HAVE_POSIX_SIGNALS */
-
   sigint_blocked = 0;
+  RL_CHECK_SIGNALS ();
 }
 
-#ifdef SIGWINCH
 /* Cause SIGWINCH to not be delivered until the corresponding call to
    release_sigwinch(). */
 void
@@ -589,6 +636,8 @@ _rl_block_sigwinch ()
   if (sigwinch_blocked)
     return;
 
+#if defined (SIGWINCH)
+
 #if defined (HAVE_POSIX_SIGNALS)
   sigemptyset (&sigwinch_set);
   sigemptyset (&sigwinch_oset);
@@ -604,6 +653,8 @@ _rl_block_sigwinch ()
 #  endif /* !HAVE_BSD_SIGNALS */
 #endif /* !HAVE_POSIX_SIGNALS */
 
+#endif /* SIGWINCH */
+
   sigwinch_blocked = 1;
 }
 
@@ -614,6 +665,8 @@ _rl_release_sigwinch ()
   if (sigwinch_blocked == 0)
     return;
 
+#if defined (SIGWINCH)
+
 #if defined (HAVE_POSIX_SIGNALS)
   sigprocmask (SIG_SETMASK, &sigwinch_oset, (sigset_t *)NULL);
 #else
@@ -626,9 +679,10 @@ _rl_release_sigwinch ()
 #  endif /* !HAVE_BSD_SIGNALS */
 #endif /* !HAVE_POSIX_SIGNALS */
 
+#endif /* SIGWINCH */
+
   sigwinch_blocked = 0;
 }
-#endif /* SIGWINCH */
 
 /* **************************************************************** */
 /*								    */