Subject: bug#24047: closed (Re: bug#24047: Should 'signal' sometimes return?)

From: [email-masked] (GNU bug Tracking System)
Date: Sun, 24 Jul 2016 22:43:02 +0000

Your bug report

#24047: [PROPOSED PATCH] ‘signal’ no longer returns

which was filed against the emacs package, has been closed.

The explanation is attached below, along with your original report.
If you require more details, please reply to [email-masked].

-- 
24047: http://debbugs.gnu.org/cgi/bugreport.cgi?bug=24047
GNU Bug Tracking System
Contact [email-masked] with problems

Subject: Re: bug#24047: Should 'signal' sometimes return?
From: Paul Eggert <[email-masked]>
To: Stefan Monnier <[email-masked]>
Cc: [email-masked]
Date: Mon, 25 Jul 2016 00:42:27 +0200
List-Id: <debbugs-submit.debbugs.gnu.org>

On 07/23/2016 08:37 PM, Stefan Monnier wrote:
> Haven't looked in detail, but it looks OK.

Thanks, I installed it in 'master' and am marking this as done.

>
> A further patch could change the new `quit' function so it checks
> debug-on-quit, and either calls the debugger or calls Fsignal.  This way
> we don't need the intermediate signal_or_quit function.

I tried something along those lines (see attached), but wasn't convinced 
that the result was correct (there are a lot of flags flying around), 
and my patch would cause quits to traverse the handler list twice, which 
seems inelegant.

diff --git a/src/eval.c b/src/eval.c
index 33b82f7..74e1409 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -1431,10 +1431,9 @@ struct handler *
 }
 
 
-static Lisp_Object signal_or_quit (Lisp_Object, Lisp_Object, bool);
-static Lisp_Object find_handler_clause (Lisp_Object, Lisp_Object);
-static bool maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig,
-				 Lisp_Object data);
+static struct handler const return_nil_handler = { 0, };
+static struct handler *find_condition_handler (Lisp_Object, Lisp_Object,
+					       Lisp_Object);
 
 void
 process_quit_flag (void)
@@ -1465,25 +1464,6 @@ static bool maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig,
        attributes: noreturn)
   (Lisp_Object error_symbol, Lisp_Object data)
 {
-  signal_or_quit (error_symbol, data, false);
-  eassume (false);
-}
-
-/* Quit, in response to a keyboard quit request.  */
-Lisp_Object
-quit (void)
-{
-  return signal_or_quit (Qquit, Qnil, true);
-}
-
-/* Signal an error, or quit.  ERROR_SYMBOL and DATA are as with Fsignal.
-   If KEYBOARD_QUIT, this is a quit; ERROR_SYMBOL should be
-   Qquit and DATA should be Qnil, and this function may return.
-   Otherwise this function is like Fsignal and does not return.  */
-
-static Lisp_Object
-signal_or_quit (Lisp_Object error_symbol, Lisp_Object data, bool keyboard_quit)
-{
   /* When memory is full, ERROR-SYMBOL is nil,
      and DATA is (REAL-ERROR-SYMBOL . REAL-DATA).
      That is a special case--don't do this in other situations.  */
@@ -1491,8 +1471,6 @@ static bool maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig,
   Lisp_Object string;
   Lisp_Object real_error_symbol
     = (NILP (error_symbol) ? Fcar (data) : error_symbol);
-  register Lisp_Object clause = Qnil;
-  struct handler *h;
 
   immediate_quit = 0;
   abort_on_gc = 0;
@@ -1537,37 +1515,8 @@ static bool maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig,
 	Vsignaling_function = backtrace_function (pdl);
     }
 
-  for (h = handlerlist; h; h = h->next)
-    {
-      if (h->type != CONDITION_CASE)
-	continue;
-      clause = find_handler_clause (h->tag_or_ch, conditions);
-      if (!NILP (clause))
-	break;
-    }
-
-  if (/* Don't run the debugger for a memory-full error.
-	 (There is no room in memory to do that!)  */
-      !NILP (error_symbol)
-      && (!NILP (Vdebug_on_signal)
-	  /* If no handler is present now, try to run the debugger.  */
-	  || NILP (clause)
-	  /* A `debug' symbol in the handler list disables the normal
-	     suppression of the debugger.  */
-	  || (CONSP (clause) && !NILP (Fmemq (Qdebug, clause)))
-	  /* Special handler that means "print a message and run debugger
-	     if requested".  */
-	  || EQ (h->tag_or_ch, Qerror)))
-    {
-      bool debugger_called
-	= maybe_call_debugger (conditions, error_symbol, data);
-      /* We can't return values to code which signaled an error, but we
-	 can continue code which has signaled a quit.  */
-      if (keyboard_quit && debugger_called && EQ (real_error_symbol, Qquit))
-	return Qnil;
-    }
-
-  if (!NILP (clause))
+  struct handler *h = find_condition_handler (conditions, error_symbol, data);
+  if (h)
     {
       Lisp_Object unwind_data
 	= (NILP (error_symbol) ? data : Fcons (error_symbol, data));
@@ -1762,6 +1711,57 @@ static bool maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig,
   return Qnil;
 }
 
+struct handler *
+find_condition_handler (Lisp_Object conditions, Lisp_Object error_symbol,
+			Lisp_Object data)
+{
+  Lisp_Object clause = Qnil;
+  struct handler *h;
+
+  for (h = handlerlist; h; h = h->next)
+    {
+      if (h->type != CONDITION_CASE)
+	continue;
+      clause = find_handler_clause (h->tag_or_ch, conditions);
+      if (!NILP (clause))
+	break;
+    }
+
+  if (/* Don't run the debugger for a memory-full error.
+	 (There is no room in memory to do that!)  */
+      !NILP (error_symbol)
+      && (!NILP (Vdebug_on_signal)
+	  /* If no handler is present now, try to run the debugger.  */
+	  || NILP (clause)
+	  /* A `debug' symbol in the handler list disables the normal
+	     suppression of the debugger.  */
+	  || (CONSP (clause) && !NILP (Fmemq (Qdebug, clause)))
+	  /* Special handler that means "print a message and run debugger
+	     if requested".  */
+	  || EQ (h->tag_or_ch, Qerror)))
+    {
+      /* We can't return values to code which signaled an error, but we
+	 can continue code which has signaled a quit.  */
+      if (maybe_call_debugger (conditions, error_symbol, data)
+	  && EQ (NILP (error_symbol) ? Fcar (data) : error_symbol, Qquit))
+	return (struct handler *) &return_nil_handler;
+    }
+
+  return h;
+}
+
+/* Quit, in response to a keyboard quit request.
+   Normally this is like (signal 'quit nil) and does not return.
+   However, the debugger can cause this to return.  */
+
+Lisp_Object
+quit (void)
+{
+  AUTO_LIST1 (conditions, Qquit);
+  if (find_condition_handler (conditions, Qquit, Qnil) != &return_nil_handler)
+    Fsignal (Qquit, Qnil);
+  return Qnil;
+}
 
 /* Format and return a string; called like vprintf.  */
 Lisp_Object

Subject: [PROPOSED PATCH]‘signal’ no longer returns
From: Paul Eggert <[email-masked]>
To: [email-masked]
Cc: Paul Eggert <[email-masked]>
Date: Thu, 21 Jul 2016 16:20:27 +0200
List-Id: <debbugs-submit.debbugs.gnu.org>

Although for decades ‘signal’ has been documented to not return,
a corner case in the Lisp debugger causes ‘signal’ to return.
Remove the corner case and adjust Emacs internals accordingly.
An alternative would be to document the corner case, but this
would complicate the Lisp API unnecessarily.
* src/eval.c (maybe_call_debugger): Now returns void, not bool.
Caller changed.
(Fsignal): Now _Noreturn.  Callers adjusted accordingly.
(xsignal): Move to lisp.h.
* src/lisp.h (process_quit_flag): Now _Noreturn.
(xsignal): Now an inline function, as it's now simply an alias
for Fsignal.
---
 src/charset.c  |    6 +++---
 src/coding.c   |    6 +++---
 src/eval.c     |   33 ++++++---------------------------
 src/keyboard.c |    4 ----
 src/lisp.h     |    8 ++++++--
 5 files changed, 18 insertions(+), 39 deletions(-)

diff --git a/src/charset.c b/src/charset.c
index 95a9c57..05469aa 100644
--- a/src/charset.c
+++ b/src/charset.c
@@ -843,9 +843,9 @@ range of code points (in CHARSET) of target characters.  */)
   int nchars;
 
   if (nargs != charset_arg_max)
-    return Fsignal (Qwrong_number_of_arguments,
-		    Fcons (intern ("define-charset-internal"),
-			   make_number (nargs)));
+    Fsignal (Qwrong_number_of_arguments,
+	     Fcons (intern ("define-charset-internal"),
+		    make_number (nargs)));
 
   attrs = Fmake_vector (make_number (charset_attr_max), Qnil);
 
diff --git a/src/coding.c b/src/coding.c
index 29c90f0..a8ddc81 100644
--- a/src/coding.c
+++ b/src/coding.c
@@ -10546,9 +10546,9 @@ assigned to each coding category (see `coding-category-list').
   return Qnil;
 
  short_args:
-  return Fsignal (Qwrong_number_of_arguments,
-		  Fcons (intern ("define-coding-system-internal"),
-			 make_number (nargs)));
+  Fsignal (Qwrong_number_of_arguments,
+	   Fcons (intern ("define-coding-system-internal"),
+		  make_number (nargs)));
 }

diff --git a/src/eval.c b/src/eval.c
index 72facd5..a850446 100644
--- a/src/eval.c
+++ b/src/eval.c
@@ -1432,7 +1432,7 @@ struct handler *
 
 
 static Lisp_Object find_handler_clause (Lisp_Object, Lisp_Object);
-static bool maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig,
+static void maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig,
 				 Lisp_Object data);
 
 void
@@ -1460,7 +1460,8 @@ static bool maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig,
 See Info anchor `(elisp)Definition of signal' for some details on how this
 error message is constructed.
 If the signal is handled, DATA is made available to the handler.
-See also the function `condition-case'.  */)
+See also the function `condition-case'.  */
+       attributes: noreturn)
   (Lisp_Object error_symbol, Lisp_Object data)
 {
   /* When memory is full, ERROR-SYMBOL is nil,
@@ -1537,14 +1538,7 @@ static bool maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig,
 	  /* Special handler that means "print a message and run debugger
 	     if requested".  */
 	  || EQ (h->tag_or_ch, Qerror)))
-    {
-      bool debugger_called
-	= maybe_call_debugger (conditions, error_symbol, data);
-      /* We can't return values to code which signaled an error, but we
-	 can continue code which has signaled a quit.  */
-      if (debugger_called && EQ (real_error_symbol, Qquit))
-	return Qnil;
-    }
+    maybe_call_debugger (conditions, error_symbol, data);
 
   if (!NILP (clause))
     {
@@ -1569,16 +1563,6 @@ static bool maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig,
   fatal ("%s", SDATA (string));
 }
 
-/* Internal version of Fsignal that never returns.
-   Used for anything but Qquit (which can return from Fsignal).  */
-
-void
-xsignal (Lisp_Object error_symbol, Lisp_Object data)
-{
-  Fsignal (error_symbol, data);
-  emacs_abort ();
-}
-
 /* Like xsignal, but takes 0, 1, 2, or 3 args instead of a list.  */
 
 void
@@ -1700,7 +1684,7 @@ static bool maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig,
     = SIG is the error symbol, and DATA is the rest of the data.
     = SIG is nil, and DATA is (SYMBOL . REST-OF-DATA).
       This is for memory-full errors only.  */
-static bool
+static void
 maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig, Lisp_Object data)
 {
   Lisp_Object combined_data;
@@ -1719,12 +1703,7 @@ static bool maybe_call_debugger (Lisp_Object conditions, Lisp_Object sig,
       && ! skip_debugger (conditions, combined_data)
       /* RMS: What's this for?  */
       && when_entered_debugger < num_nonmacro_input_events)
-    {
-      call_debugger (list2 (Qerror, combined_data));
-      return 1;
-    }
-
-  return 0;
+    call_debugger (list2 (Qerror, combined_data));
 }
 
 static Lisp_Object
diff --git a/src/keyboard.c b/src/keyboard.c
index 8901ff0..6b5528d 100644
--- a/src/keyboard.c
+++ b/src/keyboard.c
@@ -10402,13 +10402,9 @@ shows the events before all translations (except for input methods).
 	 then quit right away.  */
       if (immediate_quit && NILP (Vinhibit_quit))
 	{
-	  struct gl_state_s saved;
-
 	  immediate_quit = false;
 	  pthread_sigmask (SIG_SETMASK, &empty_mask, 0);
-	  saved = gl_state;
 	  Fsignal (Qquit, Qnil);
-	  gl_state = saved;
 	}
       else
         { /* Else request quit when it's safe.  */
diff --git a/src/lisp.h b/src/lisp.h
index 39877d7..50ee8ea 100644
--- a/src/lisp.h
+++ b/src/lisp.h
@@ -3230,7 +3230,7 @@ struct handler
 extern void process_pending_signals (void);
 extern bool volatile pending_signals;
 
-extern void process_quit_flag (void);
+extern _Noreturn void process_quit_flag (void);
 #define QUIT						\
   do {							\
     if (!NILP (Vquit_flag) && NILP (Vinhibit_quit))	\
@@ -3879,7 +3879,11 @@ extern void map_obarray (Lisp_Object, void (*) (Lisp_Object, Lisp_Object),
 extern Lisp_Object run_hook_with_args (ptrdiff_t nargs, Lisp_Object *args,
 				       Lisp_Object (*funcall)
 				       (ptrdiff_t nargs, Lisp_Object *args));
-extern _Noreturn void xsignal (Lisp_Object, Lisp_Object);
+INLINE _Noreturn void
+xsignal (Lisp_Object error_symbol, Lisp_Object data)
+{
+  Fsignal (error_symbol, data);
+}
 extern _Noreturn void xsignal0 (Lisp_Object);
 extern _Noreturn void xsignal1 (Lisp_Object, Lisp_Object);
 extern _Noreturn void xsignal2 (Lisp_Object, Lisp_Object, Lisp_Object);
-- 
1.7.9.5