1 files changed, 26 insertions, 57 deletions

diff --git a/src/process.c b/src/process.c
index 3c539024b0a..7e8f4cc57bc 100644
--- a/src/process.c
+++ b/src/process.c
@@ -4643,6 +4643,10 @@ wait_reading_process_output (time_limit, microsecs, read_kbd, do_display,
   FD_ZERO (&Connecting);
 #endif
 
+  if (time_limit == 0 && wait_proc && !NILP (Vinhibit_quit)
+      && !(CONSP (wait_proc->status) && EQ (XCAR (wait_proc->status), Qexit)))
+    message ("Blocking call to accept-process-output with quit inhibited!!");
+
   /* If wait_proc is a process to watch, set wait_channel accordingly.  */
   if (wait_proc != NULL)
     wait_channel = wait_proc->infd;
@@ -5314,6 +5318,8 @@ read_process_output (proc, channel)
   struct coding_system *coding = proc_decode_coding_system[channel];
   int carryover = p->decoding_carryover;
   int readmax = 4096;
+  int count = SPECPDL_INDEX ();
+  Lisp_Object odeactivate;
 
   chars = (char *) alloca (carryover + readmax);
   if (carryover)
@@ -5386,15 +5392,16 @@ read_process_output (proc, channel)
   /* Now set NBYTES how many bytes we must decode.  */
   nbytes += carryover;
 
+  odeactivate = Vdeactivate_mark;
+  /* There's no good reason to let process filters change the current
+     buffer, and many callers of accept-process-output, sit-for, and
+     friends don't expect current-buffer to be changed from under them.  */
+  record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+
   /* Read and dispose of the process output.  */
   outstream = p->filter;
   if (!NILP (outstream))
     {
-      /* We inhibit quit here instead of just catching it so that
-         hitting ^G when a filter happens to be running won't screw
-         it up.  */
-      int count = SPECPDL_INDEX ();
-      Lisp_Object odeactivate;
       Lisp_Object obuffer, okeymap;
       Lisp_Object text;
       int outer_running_asynch_code = running_asynch_code;
@@ -5402,10 +5409,12 @@ read_process_output (proc, channel)
 
       /* 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.  */
-      odeactivate = Vdeactivate_mark;
       XSETBUFFER (obuffer, current_buffer);
       okeymap = current_buffer->keymap;
 
+      /* We inhibit quit here instead of just catching it so that
+         hitting ^G when a filter happens to be running won't screw
+         it up.  */
       specbind (Qinhibit_quit, Qt);
       specbind (Qlast_nonmenu_event, Qt);
 
@@ -5474,9 +5483,6 @@ read_process_output (proc, channel)
       restore_search_regs ();
       running_asynch_code = outer_running_asynch_code;
 
-      /* Handling the process output should not deactivate the mark.  */
-      Vdeactivate_mark = odeactivate;
-
       /* Restore waiting_for_user_input_p as it was
          when we were called, in case the filter clobbered it.  */
       waiting_for_user_input_p = waiting;
@@ -5492,27 +5498,19 @@ read_process_output (proc, channel)
            cause trouble (for example it would make sit_for return).  */
         if (waiting_for_user_input_p == -1)
           record_asynch_buffer_change ();
-
-      unbind_to (count, Qnil);
-      return nbytes;
     }
 
   /* If no filter, write into buffer if it isn't dead.  */
-  if (!NILP (p->buffer) && !NILP (XBUFFER (p->buffer)->name))
+  else if (!NILP (p->buffer) && !NILP (XBUFFER (p->buffer)->name))
     {
       Lisp_Object old_read_only;
       int old_begv, old_zv;
       int old_begv_byte, old_zv_byte;
-      Lisp_Object odeactivate;
       int before, before_byte;
       int opoint_byte;
       Lisp_Object text;
       struct buffer *b;
-      int count = SPECPDL_INDEX ();
-
-      odeactivate = Vdeactivate_mark;
 
-      record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
       Fset_buffer (p->buffer);
       opoint = PT;
       opoint_byte = PT_BYTE;
@@ -5610,13 +5608,14 @@ read_process_output (proc, channel)
       if (old_begv != BEGV || old_zv != ZV)
         Fnarrow_to_region (make_number (old_begv), make_number (old_zv));
 
-      /* Handling the process output should not deactivate the mark.  */
-      Vdeactivate_mark = odeactivate;
 
       current_buffer->read_only = old_read_only;
       SET_PT_BOTH (opoint, opoint_byte);
-      unbind_to (count, Qnil);
     }
+  /* Handling the process output should not deactivate the mark.  */
+  Vdeactivate_mark = odeactivate;
+
+  unbind_to (count, Qnil);
   return nbytes;
 }
 
@@ -5773,34 +5772,6 @@ send_process (proc, buf, len, object)
         {
           int this = len;
 
-          /* Decide how much data we can send in one batch.
-             Long lines need to be split into multiple batches.  */
-          if (p->pty_flag)
-            {
-              /* Starting this at zero is always correct when not the first
-                 iteration because the previous iteration ended by sending C-d.
-                 It may not be correct for the first iteration
-                 if a partial line was sent in a separate send_process call.
-                 If that proves worth handling, we need to save linepos
-                 in the process object.  */
-              int linepos = 0;
-              unsigned char *ptr = (unsigned char *) buf;
-              unsigned char *end = (unsigned char *) buf + len;
-
-              /* Scan through this text for a line that is too long.  */
-              while (ptr != end && linepos < pty_max_bytes)
-                {
-                  if (*ptr == '\n')
-                    linepos = 0;
-                  else
-                    linepos++;
-                  ptr++;
-                }
-              /* If we found one, break the line there
-                 and put in a C-d to force the buffer through.  */
-              this = ptr - buf;
-            }
-
           /* Send this batch, using one or more write calls.  */
           while (this > 0)
             {
@@ -5904,11 +5875,6 @@ send_process (proc, buf, len, object)
               len -= rv;
               this -= rv;
             }
-
-          /* If we sent just part of the string, put in an EOF (C-d)
-             to force it through, before we send the rest.  */
-          if (len > 0)
-            Fprocess_send_eof (proc);
         }
     }
   else
@@ -6845,6 +6811,11 @@ exec_sentinel (proc, reason)
   XSETBUFFER (obuffer, current_buffer);
   okeymap = current_buffer->keymap;
 
+  /* There's no good reason to let sentinels change the current
+     buffer, and many callers of accept-process-output, sit-for, and
+     friends don't expect current-buffer to be changed from under them.  */
+  record_unwind_protect (Fset_buffer, Fcurrent_buffer ());
+
   sentinel = p->sentinel;
   if (NILP (sentinel))
     return;
@@ -6982,13 +6953,11 @@ status_notify (deleting_process)
              when a process becomes runnable.  */
           else if (!EQ (symbol, Qrun) && !NILP (buffer))
             {
-              Lisp_Object ro, tem;
+              Lisp_Object tem;
               struct buffer *old = current_buffer;
               int opoint, opoint_byte;
               int before, before_byte;
 
-              ro = XBUFFER (buffer)->read_only;
-
               /* Avoid error if buffer is deleted
                  (probably that's why the process is dead, too) */
               if (NILP (XBUFFER (buffer)->name))