# HG changeset patch
# User Richard M. Stallman <rms@gnu.org>
# Date 850081002 0
# Node ID 3a93437adce1ddd53724ee3f9e3d67f77090ef1b
# Parent  734b72203ac533ee0303fdf57c47f2d16352dc9e
(status_notify): Test p->infd > 0
before each call to read_process_output.
(read_process_output): Handle match data properly in recursive calls.
(exec_sentinel): Likewise.

diff -r 734b72203ac5 -r 3a93437adce1 src/process.c
--- a/src/process.c	Sun Dec 08 08:24:03 1996 +0000
+++ b/src/process.c	Sun Dec 08 21:36:42 1996 +0000
@@ -2512,6 +2512,7 @@
       int count = specpdl_ptr - specpdl;
       Lisp_Object odeactivate;
       Lisp_Object obuffer, okeymap;
+      int outer_running_asynch_code = running_asynch_code;
 
       /* No need to gcpro these, because all we do with them later
 	 is test them for EQness, and none of them should be a string.  */
@@ -2522,7 +2523,24 @@
       specbind (Qinhibit_quit, Qt);
       specbind (Qlast_nonmenu_event, Qt);
 
+      /* In case we get recursively called,
+	 and we already saved the match data nonrecursively,
+	 save the same match data in safely recursive fashion.  */
+      if (outer_running_asynch_code)
+	{
+	  Lisp_Object tem;
+	  /* Don't clobber the CURRENT match data, either!  */
+	  tem = Fmatch_data ();
+	  restore_match_data ();
+	  record_unwind_protect (Fstore_match_data, Fmatch_data ());
+	  Fstore_match_data (tem);
+	}
+
+      /* For speed, if a search happens within this code,
+	 save the match data in a special nonrecursive fashion.  */
       running_asynch_code = 1;
+
+      /* Read and dispose of the process output.  */
       internal_condition_case_1 (read_process_output_call,
 				 Fcons (outstream,
 					Fcons (proc,
@@ -2531,8 +2549,10 @@
 						      Qnil))),
 				 !NILP (Vdebug_on_error) ? Qnil : Qerror,
 				 read_process_output_error_handler);
-      running_asynch_code = 0;
+
+      /* If we saved the match data nonrecursively, restore it now.  */
       restore_match_data ();
+      running_asynch_code = outer_running_asynch_code;
 
       /* Handling the process output should not deactivate the mark.  */
       Vdeactivate_mark = odeactivate;
@@ -3512,6 +3532,7 @@
   Lisp_Object sentinel, obuffer, odeactivate, okeymap;
   register struct Lisp_Process *p = XPROCESS (proc);
   int count = specpdl_ptr - specpdl;
+  int outer_running_asynch_code = running_asynch_code;
 
   /* No need to gcpro these, because all we do with them later
      is test them for EQness, and none of them should be a string.  */
@@ -3531,14 +3552,31 @@
   specbind (Qinhibit_quit, Qt);
   specbind (Qlast_nonmenu_event, Qt);
 
+  /* In case we get recursively called,
+     and we already saved the match data nonrecursively,
+     save the same match data in safely recursive fashion.  */
+  if (outer_running_asynch_code)
+    {
+      Lisp_Object tem;
+      tem = Fmatch_data ();
+      restore_match_data ();
+      record_unwind_protect (Fstore_match_data, Fmatch_data ());
+      Fstore_match_data (tem);
+    }
+
+  /* For speed, if a search happens within this code,
+     save the match data in a special nonrecursive fashion.  */
   running_asynch_code = 1;
+
   internal_condition_case_1 (read_process_output_call,
 			     Fcons (sentinel,
 				    Fcons (proc, Fcons (reason, Qnil))),
 			     !NILP (Vdebug_on_error) ? Qnil : Qerror,
 			     exec_sentinel_error_handler);
-  running_asynch_code = 0;
+
+  /* If we saved the match data nonrecursively, restore it now.  */
   restore_match_data ();
+  running_asynch_code = outer_running_asynch_code;
 
   Vdeactivate_mark = odeactivate;
 #if 0
@@ -3589,9 +3627,9 @@
 	  XSETINT (p->update_tick, XINT (p->tick));
 
 	  /* If process is still active, read any output that remains.  */
-	  if (XINT (p->infd) >= 0)
-	    while (! EQ (p->filter, Qt)
-		   && read_process_output (proc, XINT (p->infd)) > 0);
+	  while (! EQ (p->filter, Qt)
+		 && XINT (p->infd) >= 0
+		 && read_process_output (proc, XINT (p->infd)) > 0);
 
 	  buffer = p->buffer;