Multi-line input (was: Losing minibuffer input)

[Juri Linkov <juri@linkov.net>]

> S-RET is a good idea; I've seen this keybinding used in lots of other
> programs for "insert a newline without executing an action".

Other problematic place where S-RET could help to insert a newline
is shell input.  What is worse in shell than in the minibuffer
typing RET accidentally in the middle of multi-line shell input
causes a mess: it sends the part before point, and leaves
the remaining lines dangling at the end of the shell buffer.

This patch gets the input until the end of the possibly multi-line
input field instead of only the end of the line:

diff --git a/lisp/comint.el b/lisp/comint.el
index da37827..da21d66 100644
--- a/lisp/comint.el
+++ b/lisp/comint.el
@@ -457,6 +457,7 @@ (defvar comint-mode-map
     (define-key map [?\C-c ?\M-s] 'comint-next-matching-input-from-input)
     (define-key map "\e\C-l" 	  'comint-show-output)
     (define-key map "\C-m" 	  'comint-send-input)
+    (define-key map [S-return]    'newline)
     (define-key map "\C-d" 	  'comint-delchar-or-maybe-eof)
     ;; The following two are standardly bound to delete-forward-char,
     ;; but they should never do EOF, just delete.
@@ -1781,7 +1782,7 @@ (defun comint-send-input (&optional no-newline artificial)
       (widen)
       (let* ((pmark (process-mark proc))
              (intxt (if (>= (point) (marker-position pmark))
-                        (progn (if comint-eol-on-send (end-of-line))
+                        (progn (if comint-eol-on-send (goto-char (field-end)))
                                (buffer-substring pmark (point)))
                       (let ((copy (funcall comint-get-old-input)))
                         (goto-char pmark)

While checking this, I also noticed a problem in searching the history of
multi-line entries.  `comint-line-beginning-position' operates only
on the current line, so it too should be replaced with `field-beginning':

diff --git a/lisp/comint.el b/lisp/comint.el
index da37827..da21d66 100644
--- a/lisp/comint.el
+++ b/lisp/comint.el
@@ -1475,7 +1476,7 @@ (defun comint-history-isearch-search ()
       (or
        ;; 1. First try searching in the initial comint text
        (funcall search-fun string
-		(if isearch-forward bound (comint-line-beginning-position))
+		(if isearch-forward bound (field-beginning))
 		noerror)
        ;; 2. If the above search fails, start putting next/prev history
        ;; elements in the comint successively, and search the string
@@ -1491,7 +1492,7 @@ (defun comint-history-isearch-search ()
 			(when (null comint-input-ring-index)
 			  (error "End of history; no next item"))
 			(comint-next-input 1)
-			(goto-char (comint-line-beginning-position)))
+			(goto-char (field-beginning)))
 		       (t
 			;; Signal an error here explicitly, because
 			;; `comint-previous-input' doesn't signal an error.
@@ -1509,7 +1510,7 @@ (defun comint-history-isearch-search ()
 				      (unless isearch-forward
 					;; For backward search, don't search
 					;; in the comint prompt
-					(comint-line-beginning-position))
+					(field-beginning))
 				      noerror)))
 	       ;; Return point of the new search result
 	       (point))