(send_process): Major rewrite.

Don't put in a C-d unless a single line is too long.
Read process input whenever output gets stuck.
Relocate BUF if we read input.  New arg OBJECT.
Fprocess_send_region, Fprocess_send_string, process_send_signal)
(Fprocess_send_eof): Pass new arg OBJECT.

1 files changed, 111 insertions, 67 deletions

diff --git a/src/process.c b/src/process.c
index 66e21c1dc2e..9f740e4d026 100644
--- a/src/process.c
+++ b/src/process.c
@@ -2337,16 +2337,20 @@ send_process_trap ()
   longjmp (send_process_frame, 1);
 }
 
-send_process (proc, buf, len)
+/* Send some data to process PROC.
+   BUF is the beginning of the data; LEN is the number of characters.
+   OBJECT is the Lisp object that the data comes from.  */
+
+send_process (proc, buf, len, object)
      Lisp_Object proc;
      char *buf;
      int len;
+     Lisp_Object object;
 {
   /* Don't use register vars; longjmp can lose them.  */
   int rv;
   unsigned char *procname = XSTRING (XPROCESS (proc)->name)->data;
 
-
 #ifdef VMS
   struct Lisp_Process *p = XPROCESS (proc);
   VMS_PROC_STUFF *vs, *get_vms_process_pointer();
@@ -2364,6 +2368,21 @@ send_process (proc, buf, len)
   else if (write_to_vms_process (vs, buf, len))
     ;
 #else
+
+  if (pty_max_bytes == 0)
+    {
+#if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
+      pty_max_bytes = fpathconf (XFASTINT (XPROCESS (proc)->outfd),
+				 _PC_MAX_CANON);
+      if (pty_max_bytes < 0)
+	pty_max_bytes = 250;
+#else
+      pty_max_bytes = 250;
+#endif
+      /* Deduct one, to leave space for the eof.  */
+      pty_max_bytes--;
+    }
+
   if (!setjmp (send_process_frame))
     while (len > 0)
       {
@@ -2371,65 +2390,89 @@ send_process (proc, buf, len)
 	SIGTYPE (*old_sigpipe)();
 	int flush_pty = 0;
 
-	if (pty_max_bytes == 0)
+	/* Decide how much data we can send in one batch.
+	   Long lines need to be split into multiple batches.  */
+	if (!NILP (XPROCESS (proc)->pty_flag))
 	  {
-#if defined (HAVE_FPATHCONF) && defined (_PC_MAX_CANON)
-	    pty_max_bytes = fpathconf (XFASTINT (XPROCESS (proc)->outfd),
-				       _PC_MAX_CANON);
-	    if (pty_max_bytes < 0)
-	      pty_max_bytes = 250;
-#else
-	    pty_max_bytes = 250;
-#endif
+	    /* 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;
+	    char *ptr = buf;
+	    char *end = 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;
 	  }
 
-	/* Don't send more than pty_max_bytes bytes at a time.  */
-	/* Subtract 1 to leave room for the EOF.  */
-	if (this >= pty_max_bytes && !NILP (XPROCESS (proc)->pty_flag))
-	  this = pty_max_bytes - 1;
-
-	old_sigpipe = (SIGTYPE (*) ()) signal (SIGPIPE, send_process_trap);
-	rv = write (XINT (XPROCESS (proc)->outfd), buf, this);
-
-	/* If we sent just part of the string, put in an EOF
-	   to force it through, before we send the rest.  */
-	if (this < len)
-	  Fprocess_send_eof (proc);
-
-	signal (SIGPIPE, old_sigpipe);
-	if (rv < 0)
+	/* Send this batch, using one or more write calls.  */
+	while (this > 0)
 	  {
-	    if (0
+	    old_sigpipe = (SIGTYPE (*) ()) signal (SIGPIPE, send_process_trap);
+	    rv = write (XINT (XPROCESS (proc)->outfd), buf, this);
+	    signal (SIGPIPE, old_sigpipe);
+
+	    if (rv < 0)
+	      {
+		if (0
 #ifdef EWOULDBLOCK
-		|| errno == EWOULDBLOCK
+		    || errno == EWOULDBLOCK
 #endif
 #ifdef EAGAIN
-		|| errno == EAGAIN
-#endif
-		)
-	      {
-		/* It would be nice to accept process output here,
-		   but that is difficult.  For example, it could
-		   garbage what we are sending if that is from a buffer.  */
-		immediate_quit = 1;
-		QUIT;
-		sleep (1);
-		immediate_quit = 0;
-		continue;
+		    || errno == EAGAIN
+#endif
+		    )
+		  /* Buffer is full.  Wait, accepting input; 
+		     that may allow the program
+		     to finish doing output and read more.  */
+		  {
+		    Lisp_Object zero;
+		    int offset;
+
+		    /* Running filters might relocate buffers or strings.
+		       Arrange to relocate BUF.  */
+		    if (BUFFERP (object))
+		      offset = BUF_PTR_CHAR_POS (XBUFFER (object),
+						 (unsigned char *) buf);
+		    else if (STRINGP (object))
+		      offset = buf - (char *) XSTRING (object)->data;
+
+		    XFASTINT (zero) = 0;
+		    wait_reading_process_input (1, 0, zero, 0);
+
+		    if (BUFFERP (object))
+		      buf = (char *) BUF_CHAR_ADDRESS (XBUFFER (object), offset);
+		    else if (STRINGP (object))
+		      buf = offset + (char *) XSTRING (object)->data;
+
+		    rv = 0;
+		  }
+		else
+		  /* This is a real error.  */
+		  report_file_error ("writing to process", Fcons (proc, Qnil));
 	      }
-	    report_file_error ("writing to process", Fcons (proc, Qnil));
+	    buf += rv;
+	    len -= rv;
+	    this -= rv;
 	  }
-	buf += rv;
-	len -= rv;
-	/* Allow input from processes between bursts of sending.
-	   Otherwise things may get stopped up.  */
-	if (len > 0)
-	  {
-	    Lisp_Object zero;
 
-	    XFASTINT (zero) = 0;
-	    wait_reading_process_input (-1, 0, zero, 0);
-	  }
+	/* If we sent just part of the string, put in an EOF
+	   to force it through, before we send the rest.  */
+	if (len > 0)
+	  Fprocess_send_eof (proc);
       }
 #endif
   else
@@ -2469,7 +2512,8 @@ Output from processes can arrive in between bunches.")
     move_gap (start);
 
   start1 = XINT (start);
-  send_process (proc, &FETCH_CHAR (start1), XINT (end) - XINT (start));
+  send_process (proc, &FETCH_CHAR (start1), XINT (end) - XINT (start),
+		Fcurrent_buffer ());
 
   return Qnil;
 }
@@ -2488,7 +2532,7 @@ Output from processes can arrive in between bunches.")
   Lisp_Object proc;
   CHECK_STRING (string, 1);
   proc = get_process (process);
-  send_process (proc, XSTRING (string)->data, XSTRING (string)->size);
+  send_process (proc, XSTRING (string)->data, XSTRING (string)->size, string);
   return Qnil;
 }
 
@@ -2544,20 +2588,20 @@ process_send_signal (process, signo, current_group, nomsg)
 	{
 	case SIGINT:
 	  tcgetattr (XINT (p->infd), &t);
-	  send_process (proc, &t.c_cc[VINTR], 1);
+	  send_process (proc, &t.c_cc[VINTR], 1, Qnil);
 	  return;
 
 	case SIGQUIT:
 	  tcgetattr (XINT (p->infd), &t);
-  	  send_process (proc, &t.c_cc[VQUIT], 1);
+  	  send_process (proc, &t.c_cc[VQUIT], 1, Qnil);
   	  return;
 
   	case SIGTSTP:
 	  tcgetattr (XINT (p->infd), &t);
 #if defined (VSWTCH) && !defined (PREFER_VSUSP)
-  	  send_process (proc, &t.c_cc[VSWTCH], 1);
+  	  send_process (proc, &t.c_cc[VSWTCH], 1, Qnil);
 #else
-	  send_process (proc, &t.c_cc[VSUSP], 1);
+	  send_process (proc, &t.c_cc[VSUSP], 1, Qnil);
 #endif
   	  return;
 	}
@@ -2575,16 +2619,16 @@ process_send_signal (process, signo, current_group, nomsg)
 	{
 	case SIGINT:
 	  ioctl (XINT (p->infd), TIOCGETC, &c);
-	  send_process (proc, &c.t_intrc, 1);
+	  send_process (proc, &c.t_intrc, 1, Qnil);
 	  return;
 	case SIGQUIT:
 	  ioctl (XINT (p->infd), TIOCGETC, &c);
-	  send_process (proc, &c.t_quitc, 1);
+	  send_process (proc, &c.t_quitc, 1, Qnil);
 	  return;
 #ifdef SIGTSTP
 	case SIGTSTP:
 	  ioctl (XINT (p->infd), TIOCGLTC, &lc);
-	  send_process (proc, &lc.t_suspc, 1);
+	  send_process (proc, &lc.t_suspc, 1, Qnil);
 	  return;
 #endif /* ! defined (SIGTSTP) */
 	}
@@ -2599,16 +2643,16 @@ process_send_signal (process, signo, current_group, nomsg)
 	{
 	case SIGINT:
 	  ioctl (XINT (p->infd), TCGETA, &t);
-	  send_process (proc, &t.c_cc[VINTR], 1);
+	  send_process (proc, &t.c_cc[VINTR], 1, Qnil);
 	  return;
 	case SIGQUIT:
 	  ioctl (XINT (p->infd), TCGETA, &t);
-	  send_process (proc, &t.c_cc[VQUIT], 1);
+	  send_process (proc, &t.c_cc[VQUIT], 1, Qnil);
 	  return;
 #ifdef SIGTSTP
 	case SIGTSTP:
 	  ioctl (XINT (p->infd), TCGETA, &t);
-	  send_process (proc, &t.c_cc[VSWTCH], 1);
+	  send_process (proc, &t.c_cc[VSWTCH], 1, Qnil);
 	  return;
 #endif /* ! defined (SIGTSTP) */
 	}
@@ -2669,12 +2713,12 @@ process_send_signal (process, signo, current_group, nomsg)
 #endif /* ! defined (SIGCONT) */
     case SIGINT:
 #ifdef VMS
-      send_process (proc, "\003", 1);	/* ^C */
+      send_process (proc, "\003", 1, Qnil);	/* ^C */
       goto whoosh;
 #endif
     case SIGQUIT:
 #ifdef VMS
-      send_process (proc, "\031", 1);	/* ^Y */
+      send_process (proc, "\031", 1, Qnil);	/* ^Y */
       goto whoosh;
 #endif
     case SIGKILL:
@@ -2815,10 +2859,10 @@ text to PROCESS after you call this function.")
   }
 #else /* did not do TOICREMOTE */
 #ifdef VMS
-  send_process (proc, "\032", 1); 	/* ^z */
+  send_process (proc, "\032", 1, Qnil); 	/* ^z */
 #else
   if (!NILP (XPROCESS (proc)->pty_flag))
-    send_process (proc, "\004", 1);
+    send_process (proc, "\004", 1, Qnil);
   else
     {
       close (XINT (XPROCESS (proc)->outfd));