;;; comint.el --- general command interpreter in a window stuff
;; Copyright (C) 1988, 1990, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
-;; 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
+;; 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008
+;; Free Software Foundation, Inc.
;; Author: Olin Shivers <shivers@cs.cmu.edu>
;; Simon Marshall <simon@gnu.org>
;; This file is part of GNU Emacs.
-;; GNU Emacs is free software; you can redistribute it and/or modify
+;; GNU Emacs is free software: you can redistribute it and/or modify
;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 3, or (at your option)
-;; any later version.
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
;; GNU Emacs is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; GNU General Public License for more details.
;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING. If not, write to the
-;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
-;; Boston, MA 02110-1301, USA.
+;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
;;; Commentary:
This is a good thing to set in mode hooks.")
(defcustom comint-input-autoexpand nil
- "*If non-nil, expand input command history references on completion.
+ "If non-nil, expand input command history references on completion.
This mirrors the optional behavior of tcsh (its autoexpand and histlist).
If the value is `input', then the expansion is seen on input.
:group 'comint)
(defcustom comint-input-ignoredups nil
- "*If non-nil, don't add input matching the last on the input ring.
+ "If non-nil, don't add input matching the last on the input ring.
This mirrors the optional behavior of bash.
This variable is buffer-local."
:group 'comint)
(defcustom comint-input-ring-file-name nil
- "*If non-nil, name of the file to read/write input history.
+ "If non-nil, name of the file to read/write input history.
See also `comint-read-input-ring' and `comint-write-input-ring'.
This variable is buffer-local, and is a good thing to set in mode hooks."
:group 'comint)
(defcustom comint-scroll-to-bottom-on-input nil
- "*Controls whether input to interpreter causes window to scroll.
+ "Controls whether input to interpreter causes window to scroll.
If nil, then do not scroll. If t or `all', scroll all windows showing buffer.
If `this', scroll only the selected window.
:group 'comint)
(defcustom comint-move-point-for-output nil
- "*Controls whether interpreter output moves point to the end of the output.
+ "Controls whether interpreter output moves point to the end of the output.
If nil, then output never moves point to the output.
(If the output occurs at point, it is inserted before point.)
If t or `all', move point in all windows showing the buffer.
(defvaralias 'comint-scroll-to-bottom-on-output 'comint-move-point-for-output)
(defcustom comint-scroll-show-maximum-output t
- "*Controls how to scroll due to interpreter output.
+ "Controls how to scroll due to interpreter output.
This variable applies when point is at the end of the buffer
\(either because it was originally there, or because
`comint-move-point-for-output' said to move it there)
:group 'comint)
(defcustom comint-buffer-maximum-size 1024
- "*The maximum size in lines for Comint buffers.
+ "The maximum size in lines for Comint buffers.
Comint buffers are truncated from the top to be no greater than this number, if
the function `comint-truncate-buffer' is on `comint-output-filter-functions'."
:type 'integer
"Regexp for history entries that should be ignored when Comint initializes.")
(defcustom comint-process-echoes nil
- "*If non-nil, assume that the subprocess echoes any input.
+ "If non-nil, assume that the subprocess echoes any input.
If so, delete one copy of the input so that only one copy eventually
appears in the buffer.
\[Pp]assword\\( (again)\\)?\\|\
pass phrase\\|\\(Enter \\|Repeat \\|Bad \\)?[Pp]assphrase\\)\
\\(?:, try again\\)?\\(?: for [^:]+\\)?:\\s *\\'"
- "*Regexp matching prompts for passwords in the inferior process.
+ "Regexp matching prompts for passwords in the inferior process.
This is used by `comint-watch-for-password-prompt'."
:type 'regexp
:group 'comint)
This is called from the user command `comint-send-input'.")
(defcustom comint-eol-on-send t
- "*Non-nil means go to the end of the line before sending input.
+ "Non-nil means go to the end of the line before sending input.
See `comint-send-input'."
:type 'boolean
:group 'comint)
;; entirely, searching for uses of this variable will help to identify
;; places that need attention.
(defcustom comint-use-prompt-regexp nil
- "*If non-nil, use `comint-prompt-regexp' to recognize prompts.
+ "If non-nil, use `comint-prompt-regexp' to recognize prompts.
If nil, then program output and user-input are given different `field'
properties, which Emacs commands can use to distinguish them (in
particular, common movement commands such as `beginning-of-line'
;; Autoload is necessary for Custom to recognize old alias.
;;;###autoload
(define-obsolete-variable-alias 'comint-use-prompt-regexp-instead-of-fields
- 'comint-use-prompt-regexp "22.1")
+ 'comint-use-prompt-regexp "22.1")
(defcustom comint-mode-hook nil
"Hook run upon entry to `comint-mode'.
"Index of last matched history element.")
(defvar comint-matching-input-from-input-string ""
"Input previously used to match input history.")
-(defvar comint-save-input-ring-index
+(defvar comint-save-input-ring-index nil
"Last input ring index which you copied.
This is to support the command \\[comint-get-next-from-history].")
Entry to this mode runs the hooks on `comint-mode-hook'."
(setq mode-line-process '(":%s"))
+ (set (make-local-variable 'window-point-insertion-type) t)
(set (make-local-variable 'comint-last-input-start) (point-min-marker))
(set (make-local-variable 'comint-last-input-end) (point-min-marker))
(set (make-local-variable 'comint-last-output-start) (make-marker))
;; http://lists.gnu.org/archive/html/emacs-devel/2007-08/msg00827.html
;;
;; This makes it really work to keep point at the bottom.
-;;; (make-local-variable 'scroll-conservatively)
-;;; (setq scroll-conservatively 10000)
+ ;; (make-local-variable 'scroll-conservatively)
+ ;; (setq scroll-conservatively 10000)
(add-hook 'pre-command-hook 'comint-preinput-scroll-to-bottom t t)
(make-local-variable 'comint-ptyp)
(make-local-variable 'comint-process-echoes)
(setq startfile (buffer-substring (point) (point-max)))
(delete-region (point) (point-max))
(comint-send-string proc startfile)))
- (run-hooks 'comint-exec-hook)
- buffer)))
+ (run-hooks 'comint-exec-hook)
+ buffer)))
;; This auxiliary function cranks up the process for comint-exec in
;; the appropriate environment.
(defun comint-dynamic-list-input-ring-select ()
"Choose the input history entry that point is in or next to."
(interactive)
- (let (beg end completion (buffer completion-reference-buffer)
- (base-size completion-base-size))
+ (let ((buffer completion-reference-buffer)
+ (base-size completion-base-size)
+ beg end completion)
(if (and (not (eobp)) (get-text-property (point) 'mouse-face))
(setq end (point) beg (1+ (point))))
(if (and (not (bobp)) (get-text-property (1- (point)) 'mouse-face))
;; Note that the input string does not include its terminal newline.
(let ((proc (get-buffer-process (current-buffer))))
(if (not proc) (error "Current buffer has no process")
- (widen)
- (let* ((pmark (process-mark proc))
- (intxt (if (>= (point) (marker-position pmark))
- (progn (if comint-eol-on-send (end-of-line))
- (buffer-substring pmark (point)))
- (let ((copy (funcall comint-get-old-input)))
- (goto-char pmark)
- (insert copy)
- copy)))
- (input (if (not (eq comint-input-autoexpand 'input))
- ;; Just whatever's already there
- intxt
- ;; Expand and leave it visible in buffer
- (comint-replace-by-expanded-history t pmark)
- (buffer-substring pmark (point))))
- (history (if (not (eq comint-input-autoexpand 'history))
- input
- ;; This is messy 'cos ultimately the original
- ;; functions used do insertion, rather than return
- ;; strings. We have to expand, then insert back.
- (comint-replace-by-expanded-history t pmark)
- (let ((copy (buffer-substring pmark (point)))
- (start (point)))
- (insert input)
- (delete-region pmark start)
- copy))))
-
- (unless no-newline
- (insert ?\n))
-
- (comint-add-to-input-history history)
-
- (run-hook-with-args 'comint-input-filter-functions
- (if no-newline input
- (concat input "\n")))
-
- (let ((beg (marker-position pmark))
- (end (if no-newline (point) (1- (point))))
- (inhibit-modification-hooks t))
- (when (> end beg)
- (add-text-properties beg end
- '(front-sticky t
- font-lock-face comint-highlight-input))
- (unless comint-use-prompt-regexp
- ;; Give old user input a field property of `input', to
- ;; distinguish it from both process output and unsent
- ;; input. The terminating newline is put into a special
- ;; `boundary' field to make cursor movement between input
- ;; and output fields smoother.
- (add-text-properties
- beg end
- '(mouse-face highlight
- help-echo "mouse-2: insert after prompt as new input"
- field input))))
- (unless (or no-newline comint-use-prompt-regexp)
- ;; Cover the terminating newline
- (add-text-properties end (1+ end)
- '(rear-nonsticky t
- field boundary
- inhibit-line-move-field-capture t))))
-
- (comint-snapshot-last-prompt)
-
- (setq comint-save-input-ring-index comint-input-ring-index)
- (setq comint-input-ring-index nil)
- ;; Update the markers before we send the input
- ;; in case we get output amidst sending the input.
- (set-marker comint-last-input-start pmark)
- (set-marker comint-last-input-end (point))
- (set-marker (process-mark proc) (point))
- ;; clear the "accumulation" marker
- (set-marker comint-accum-marker nil)
- (let ((comint-input-sender-no-newline no-newline))
- (funcall comint-input-sender proc input))
-
- ;; Optionally delete echoed input (after checking it).
- (when (and comint-process-echoes (not artificial))
- (let ((echo-len (- comint-last-input-end
- comint-last-input-start)))
- ;; Wait for all input to be echoed:
- (while (and (accept-process-output proc)
- (> (+ comint-last-input-end echo-len)
- (point-max))
- (zerop
- (compare-buffer-substrings
- nil comint-last-input-start
- (- (point-max) echo-len)
- ;; Above difference is equivalent to
- ;; (+ comint-last-input-start
- ;; (- (point-max) comint-last-input-end))
- nil comint-last-input-end (point-max)))))
- (if (and
- (<= (+ comint-last-input-end echo-len)
- (point-max))
- (zerop
- (compare-buffer-substrings
- nil comint-last-input-start comint-last-input-end
- nil comint-last-input-end
- (+ comint-last-input-end echo-len))))
- ;; Certain parts of the text to be deleted may have
- ;; been mistaken for prompts. We have to prevent
- ;; problems when `comint-prompt-read-only' is non-nil.
- (let ((inhibit-read-only t))
- (delete-region comint-last-input-end
- (+ comint-last-input-end echo-len))
- (when comint-prompt-read-only
- (save-excursion
- (goto-char comint-last-input-end)
- (comint-update-fence)))))))
-
- ;; This used to call comint-output-filter-functions,
- ;; but that scrolled the buffer in undesirable ways.
- (run-hook-with-args 'comint-output-filter-functions "")))))
+ (widen)
+ (let* ((pmark (process-mark proc))
+ (intxt (if (>= (point) (marker-position pmark))
+ (progn (if comint-eol-on-send (end-of-line))
+ (buffer-substring pmark (point)))
+ (let ((copy (funcall comint-get-old-input)))
+ (goto-char pmark)
+ (insert copy)
+ copy)))
+ (input (if (not (eq comint-input-autoexpand 'input))
+ ;; Just whatever's already there
+ intxt
+ ;; Expand and leave it visible in buffer
+ (comint-replace-by-expanded-history t pmark)
+ (buffer-substring pmark (point))))
+ (history (if (not (eq comint-input-autoexpand 'history))
+ input
+ ;; This is messy 'cos ultimately the original
+ ;; functions used do insertion, rather than return
+ ;; strings. We have to expand, then insert back.
+ (comint-replace-by-expanded-history t pmark)
+ (let ((copy (buffer-substring pmark (point)))
+ (start (point)))
+ (insert input)
+ (delete-region pmark start)
+ copy))))
+
+ (unless no-newline
+ (insert ?\n))
+
+ (comint-add-to-input-history history)
+
+ (run-hook-with-args 'comint-input-filter-functions
+ (if no-newline input
+ (concat input "\n")))
+
+ (let ((beg (marker-position pmark))
+ (end (if no-newline (point) (1- (point))))
+ (inhibit-modification-hooks t))
+ (when (> end beg)
+ (add-text-properties beg end
+ '(front-sticky t
+ font-lock-face comint-highlight-input))
+ (unless comint-use-prompt-regexp
+ ;; Give old user input a field property of `input', to
+ ;; distinguish it from both process output and unsent
+ ;; input. The terminating newline is put into a special
+ ;; `boundary' field to make cursor movement between input
+ ;; and output fields smoother.
+ (add-text-properties
+ beg end
+ '(mouse-face highlight
+ help-echo "mouse-2: insert after prompt as new input"
+ field input))))
+ (unless (or no-newline comint-use-prompt-regexp)
+ ;; Cover the terminating newline
+ (add-text-properties end (1+ end)
+ '(rear-nonsticky t
+ field boundary
+ inhibit-line-move-field-capture t))))
+
+ (comint-snapshot-last-prompt)
+
+ (setq comint-save-input-ring-index comint-input-ring-index)
+ (setq comint-input-ring-index nil)
+ ;; Update the markers before we send the input
+ ;; in case we get output amidst sending the input.
+ (set-marker comint-last-input-start pmark)
+ (set-marker comint-last-input-end (point))
+ (set-marker (process-mark proc) (point))
+ ;; clear the "accumulation" marker
+ (set-marker comint-accum-marker nil)
+ (let ((comint-input-sender-no-newline no-newline))
+ (funcall comint-input-sender proc input))
+
+ ;; Optionally delete echoed input (after checking it).
+ (when (and comint-process-echoes (not artificial))
+ (let ((echo-len (- comint-last-input-end
+ comint-last-input-start)))
+ ;; Wait for all input to be echoed:
+ (while (and (accept-process-output proc)
+ (> (+ comint-last-input-end echo-len)
+ (point-max))
+ (zerop
+ (compare-buffer-substrings
+ nil comint-last-input-start
+ (- (point-max) echo-len)
+ ;; Above difference is equivalent to
+ ;; (+ comint-last-input-start
+ ;; (- (point-max) comint-last-input-end))
+ nil comint-last-input-end (point-max)))))
+ (if (and
+ (<= (+ comint-last-input-end echo-len)
+ (point-max))
+ (zerop
+ (compare-buffer-substrings
+ nil comint-last-input-start comint-last-input-end
+ nil comint-last-input-end
+ (+ comint-last-input-end echo-len))))
+ ;; Certain parts of the text to be deleted may have
+ ;; been mistaken for prompts. We have to prevent
+ ;; problems when `comint-prompt-read-only' is non-nil.
+ (let ((inhibit-read-only t))
+ (delete-region comint-last-input-end
+ (+ comint-last-input-end echo-len))
+ (when comint-prompt-read-only
+ (save-excursion
+ (goto-char comint-last-input-end)
+ (comint-update-fence)))))))
+
+ ;; This used to call comint-output-filter-functions,
+ ;; but that scrolled the buffer in undesirable ways.
+ (run-hook-with-args 'comint-output-filter-functions "")))))
(defvar comint-preoutput-filter-functions nil
"List of functions to call before inserting Comint output into the buffer.
;; Insert STRING
(let ((inhibit-read-only t)
- ;; Avoid the overhead of save-excursion, since we just
- ;; fiddle with the point
- (saved-point (point-marker)))
-
- ;; The point should float after any insertion we do
- (set-marker-insertion-type saved-point t)
+ ;; The point should float after any insertion we do.
+ (saved-point (copy-marker (point) t)))
;; We temporarly remove any buffer narrowing, in case the
;; process mark is outside of the restriction
(set-marker comint-last-output-start (point))
;; insert-before-markers is a bad thing. XXX
- ;;
- ;; It is used here to force window-point markers (used to
- ;; store the value of point in non-selected windows) to
- ;; advance, but it also screws up any other markers that we
- ;; don't _want_ to advance, such as the start-marker of some
- ;; of the overlays we create.
- ;;
- ;; We work around the problem with the overlays by
- ;; explicitly adjusting them after we do the insertion, but
- ;; in the future this problem should be solved correctly, by
- ;; using `insert', and making the insertion-type of
- ;; window-point markers settable (via a buffer-local
- ;; variable). In comint buffers, this variable would be set
- ;; to `t', to cause point in non-select windows to advance.
- (insert-before-markers string)
- ;; Fixup markers and overlays that got screwed up because we
- ;; used `insert-before-markers'.
- (let ((old-point (- (point) (length string))))
- ;; comint-last-output-start
- (set-marker comint-last-output-start old-point)
- ;; comint-last-input-end
- (when (and comint-last-input-end
- (equal (marker-position comint-last-input-end)
- (point)))
- (set-marker comint-last-input-end old-point))
- ;; No overlays we create are set to advance upon insertion
- ;; (at the start/end), so we assume that any overlay which
- ;; is at the current point was incorrectly advanced by
- ;; insert-before-markers. First fixup overlays that might
- ;; start at point:
- (dolist (over (overlays-at (point)))
- (when (= (overlay-start over) (point))
- (let ((end (overlay-end over)))
- (move-overlay over
- old-point
- (if (= end (point)) old-point end)))))
- ;; Then do overlays that might end at point:
- (dolist (over (overlays-at (1- (point))))
- (when (= (overlay-end over) (point))
- (move-overlay over
- (min (overlay-start over) old-point)
- old-point))))
+ ;; Luckily we don't have to use it any more, we use
+ ;; window-point-insertion-type instead.
+ (insert string)
;; Advance process-mark
(set-marker (process-mark process) (point))
(let ((inhibit-read-only t)
(inhibit-modification-hooks t))
(add-text-properties comint-last-output-start (point)
- '(rear-nonsticky t
+ '(front-sticky
+ (field inhibit-line-move-field-capture)
+ rear-nonsticky t
field output
inhibit-line-move-field-capture t))))
(if (eq scroll 'this)
(goto-char (point-max))
(walk-windows
- (function (lambda (window)
- (if (and (eq (window-buffer window) current)
- (or (eq scroll t) (eq scroll 'all)))
- (progn
- (select-window window)
- (goto-char (point-max))
- (select-window selected)))))
+ (lambda (window)
+ (if (and (eq (window-buffer window) current)
+ (or (eq scroll t) (eq scroll 'all)))
+ (progn
+ (select-window window)
+ (goto-char (point-max))
+ (select-window selected))))
nil t))))))
(defun comint-postoutput-scroll-to-bottom (string)
(unwind-protect
(if process
(walk-windows
- (function (lambda (window)
- (if (eq (window-buffer window) current)
- (progn
- (select-window window)
- (if (and (< (point) (process-mark process))
- (or (eq scroll t) (eq scroll 'all)
- ;; Maybe user wants point to jump to end.
- (and (eq scroll 'this) (eq selected window))
- (and (eq scroll 'others) (not (eq selected window)))
- ;; If point was at the end, keep it at end.
- (and (marker-position comint-last-output-start)
- (>= (point) comint-last-output-start))))
- (goto-char (process-mark process)))
- ;; Optionally scroll so that the text
- ;; ends at the bottom of the window.
- (if (and comint-scroll-show-maximum-output
- (= (point) (point-max)))
- (save-excursion
- (goto-char (point-max))
- (recenter (- -1 scroll-margin))))
- (select-window selected)))))
+ (lambda (window)
+ (when (eq (window-buffer window) current)
+ (select-window window)
+ (if (and (< (point) (process-mark process))
+ (or (eq scroll t) (eq scroll 'all)
+ ;; Maybe user wants point to jump to end.
+ (and (eq scroll 'this) (eq selected window))
+ (and (eq scroll 'others) (not (eq selected window)))
+ ;; If point was at the end, keep it at end.
+ (and (marker-position comint-last-output-start)
+ (>= (point) comint-last-output-start))))
+ (goto-char (process-mark process)))
+ ;; Optionally scroll so that the text
+ ;; ends at the bottom of the window.
+ (if (and comint-scroll-show-maximum-output
+ (= (point) (point-max)))
+ (save-excursion
+ (goto-char (point-max))
+ (recenter (- -1 scroll-margin))))
+ (select-window selected)))
nil t))
(set-buffer current))))
;; Output message and put back prompt
(comint-output-filter proc replacement)))
(define-obsolete-function-alias 'comint-kill-output
- 'comint-delete-output "21.1")
+ 'comint-delete-output "21.1")
(defun comint-write-output (filename &optional append mustbenew)
"Write output from interpreter since last input to FILENAME.
(set-window-start (selected-window) (point))
(comint-skip-prompt))
(t
- (let* ((beg (field-beginning pos))
- (pt (if (= (point-min) beg)
- (point-min)
- (1+ beg))))
- (goto-char pt))
+ (goto-char (field-beginning pos))
(set-window-start (selected-window) (point))))))
(interactive)
(comint-skip-input)
(interrupt-process nil comint-ptyp)
-;; (process-send-string nil "\n")
-)
+ ;; (process-send-string nil "\n")
+ )
(defun comint-kill-subjob ()
"Send kill signal to the current subjob.
(error nil))
(not (file-directory-p stringfile))))
(defdir (if sfile-p (file-name-directory stringfile)
- (car def)))
+ (car def)))
(deffile (if sfile-p (file-name-nondirectory stringfile)
- (cdr def)))
+ (cdr def)))
(ans (read-file-name (if deffile (format "%s(default %s) "
prompt deffile)
- prompt)
+ prompt)
defdir
(concat defdir deffile)
mustmatch-p)))
;; want them present in specific modes.
(defcustom comint-completion-autolist nil
- "*If non-nil, automatically list possibilities on partial completion.
+ "If non-nil, automatically list possibilities on partial completion.
This mirrors the optional behavior of tcsh."
:type 'boolean
:group 'comint-completion)
(defcustom comint-completion-addsuffix t
- "*If non-nil, add a `/' to completed directories, ` ' to file names.
+ "If non-nil, add a `/' to completed directories, ` ' to file names.
If a cons pair, it should be of the form (DIRSUFFIX . FILESUFFIX) where
DIRSUFFIX and FILESUFFIX are strings added on unambiguous or exact completion.
This mirrors the optional behavior of tcsh."
:group 'comint-completion)
(defcustom comint-completion-recexact nil
- "*If non-nil, use shortest completion if characters cannot be added.
+ "If non-nil, use shortest completion if characters cannot be added.
This mirrors the optional behavior of tcsh.
A non-nil value is useful if `comint-completion-autolist' is non-nil too."
:group 'comint-completion)
(defcustom comint-completion-fignore nil
- "*List of suffixes to be disregarded during file completion.
+ "List of suffixes to be disregarded during file completion.
This mirrors the optional behavior of bash and tcsh.
Note that this applies to `comint-dynamic-complete-filename' only."
filename
(let ((regexp
(format "[%s]"
- (mapconcat 'char-to-string comint-file-name-quote-list ""))))
+ (mapconcat 'char-to-string comint-file-name-quote-list ""))))
(save-match-data
(let ((i 0))
(while (string-match regexp filename i)
" ")
(t
(cdr comint-completion-addsuffix))))
- (filename (or (comint-match-partial-filename) ""))
+ (filename (comint-match-partial-filename))
+ (filename-beg (if filename (match-beginning 0) (point)))
+ (filename-end (if filename (match-end 0) (point)))
+ (filename (or filename ""))
(filedir (file-name-directory filename))
(filenondir (file-name-nondirectory filename))
(directory (if filedir (comint-directory filedir) default-directory))
(completion (file-name-completion filenondir directory)))
(cond ((null completion)
- (message "No completions of %s" filename)
+ (if minibuffer-p
+ (minibuffer-message (format " [No completions of %s]" filename))
+ (message "No completions of %s" filename))
(setq success nil))
((eq completion t) ; Means already completed "file".
(insert filesuffix)
(comint-dynamic-list-filename-completions))
(t ; Completion string returned.
(let ((file (concat (file-name-as-directory directory) completion)))
- (insert (comint-quote-filename
- (substring (directory-file-name completion)
- (length filenondir))))
+ ;; Insert completion. Note that the completion string
+ ;; may have a different case than what's in the prompt,
+ ;; if read-file-name-completion-ignore-case is non-nil,
+ (delete-region filename-beg filename-end)
+ (if filedir (insert (comint-quote-filename filedir)))
+ (insert (comint-quote-filename (directory-file-name completion)))
(cond ((symbolp (file-name-completion completion directory))
;; We inserted a unique completion.
(insert (if (file-directory-p file) dirsuffix filesuffix))
See also `comint-dynamic-complete-filename'."
(let* ((completion-ignore-case (memq system-type '(ms-dos windows-nt cygwin)))
+ (minibuffer-p (window-minibuffer-p (selected-window)))
(suffix (cond ((not comint-completion-addsuffix) "")
((not (consp comint-completion-addsuffix)) " ")
(t (cdr comint-completion-addsuffix))))
(completions (all-completions stub candidates)))
(cond ((null completions)
- (message "No completions of %s" stub)
+ (if minibuffer-p
+ (minibuffer-message (format " [No completions of %s]" stub))
+ (message "No completions of %s" stub))
nil)
((= 1 (length completions)) ; Gotcha!
(let ((completion (car completions)))
(if (string-equal completion stub)
- (message "Sole completion")
+ (unless minibuffer-p
+ (message "Sole completion"))
(insert (substring completion (length stub)))
- (message "Completed"))
+ (unless minibuffer-p
+ (message "Completed")))
(insert suffix)
'sole))
(t ; There's no unique completion.
(member completion completions))
;; It's not unique, but user wants shortest match.
(insert suffix)
- (message "Completed shortest")
+ (unless minibuffer-p
+ (message "Completed shortest"))
'shortest)
((or comint-completion-autolist
(string-equal stub completion))
;; It's not unique, list possible completions.
- (comint-dynamic-list-completions completions)
+ (comint-dynamic-list-completions completions stub)
'listed)
(t
- (message "Partially completed")
+ (unless minibuffer-p
+ (message "Partially completed"))
'partial)))))))
(directory (if filedir (comint-directory filedir) default-directory))
(completions (file-name-all-completions filenondir directory)))
(if (not completions)
- (message "No completions of %s" filename)
+ (if (window-minibuffer-p (selected-window))
+ (minibuffer-message (format " [No completions of %s]" filename))
+ (message "No completions of %s" filename))
(comint-dynamic-list-completions
- (mapcar 'comint-quote-filename completions)))))
+ (mapcar 'comint-quote-filename completions)
+ (comint-quote-filename filenondir)))))
;; This is bound locally in a *Completions* buffer to the list of
(defvar comint-dynamic-list-completions-config nil)
-(defun comint-dynamic-list-completions (completions)
+(defun comint-dynamic-list-completions (completions &optional common-substring)
"List in help buffer sorted COMPLETIONS.
+The meaning of COMMON-SUBSTRING is the same as in `display-completion-list'.
Typing SPC flushes the help buffer."
(let ((window (get-buffer-window "*Completions*" 0)))
(setq completions (sort completions 'string-lessp))
(setq comint-dynamic-list-completions-config
(current-window-configuration))
(with-output-to-temp-buffer "*Completions*"
- (display-completion-list completions))
- (message "Type space to flush; repeat completion command to scroll"))
+ (display-completion-list completions common-substring))
+ (if (window-minibuffer-p (selected-window))
+ (minibuffer-message " [Type space to flush; repeat completion command to scroll]")
+ (message "Type space to flush; repeat completion command to scroll")))
;; Read the next key, to process SPC.
(let (key first)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defcustom comint-redirect-verbose nil
- "*If non-nil, print messages each time the redirection filter is invoked.
+ "If non-nil, print messages each time the redirection filter is invoked.
Also print a message when redirection is completed."
:group 'comint
:type 'boolean)
This function does not need to be invoked by the end user."
(let ((output-buffer-list
(if (listp comint-redirect-output-buffer)
- comint-redirect-output-buffer
+ comint-redirect-output-buffer
(list comint-redirect-output-buffer)))
(filtered-input-string input-string))
(or (re-search-backward comint-prompt-regexp nil t)
(error "No prompt found or `comint-prompt-regexp' not set properly"))))
- ;;;;;;;;;;;;;;;;;;;;;
;; Set up for redirection
- ;;;;;;;;;;;;;;;;;;;;;
(comint-redirect-setup
- ;; Output Buffer
output-buffer
- ;; Comint Buffer
- (current-buffer)
- ;; Finished Regexp
- comint-prompt-regexp
- ;; Echo input
- echo)
-
- ;;;;;;;;;;;;;;;;;;;;;
+ (current-buffer) ; Comint Buffer
+ comint-prompt-regexp ; Finished Regexp
+ echo) ; Echo input
+
;; Set the filter
- ;;;;;;;;;;;;;;;;;;;;;
- ;; Save the old filter
- (setq comint-redirect-original-filter-function
+ (setq comint-redirect-original-filter-function ; Save the old filter
(process-filter proc))
(set-process-filter proc 'comint-redirect-filter)
- ;;;;;;;;;;;;;;;;;;;;;
;; Send the command
- ;;;;;;;;;;;;;;;;;;;;;
- (process-send-string
- (current-buffer)
- (concat command "\n"))
+ (process-send-string (current-buffer) (concat command "\n"))
- ;;;;;;;;;;;;;;;;;;;;;
;; Show the output
- ;;;;;;;;;;;;;;;;;;;;;
(or no-display
(display-buffer
(get-buffer-create
results)))
results)))
-(mapc (lambda (x)
- (add-to-list 'debug-ignored-errors x))
- '("^Not at command line$"
- "^Empty input ring$"
- "^No history$"
- "^Not found$" ; Too common?
- "^Current buffer has no process$"))
+(dolist (x '("^Not at command line$"
+ "^Empty input ring$"
+ "^No history$"
+ "^Not found$" ; Too common?
+ "^Current buffer has no process$"))
+ (add-to-list 'debug-ignored-errors x))
\f
;; Converting process modes to use comint mode