;;; comint.el --- general command interpreter in a window stuff
-;; Copyright (C) 1988, 1990, 1992, 1993, 1994 Free Software Foundation, Inc.
+;; Copyright (C) 1988, 90, 92, 93, 94, 95 Free Software Foundation, Inc.
;; Author: Olin Shivers <shivers@cs.cmu.edu>
-;; Adapted-by: Simon Marshall <s.marshall@dcs.hull.ac.uk>
+;; Adapted-by: Simon Marshall <simon@gnu.ai.mit.edu>
;; Keywords: processes
;; This file is part of GNU Emacs.
;;; Please send me bug reports, bug fixes, and extensions, so that I can
;;; merge them into the master source.
;;; - Olin Shivers (shivers@cs.cmu.edu)
-;;; - Simon Marshall (s.marshall@dcs.hull.ac.uk)
+;;; - Simon Marshall (simon@gnu.ai.mit.edu)
;;; This file defines a general command-interpreter-in-a-buffer package
;;; (comint mode). The idea is that you can build specific process-in-a-buffer
;;; m-s comint-next-matching-input Next input that matches
;;; m-c-l comint-show-output Show last batch of process output
;;; return comint-send-input
-;;; c-a comint-bol Beginning of line; skip prompt
;;; c-d comint-delchar-or-maybe-eof Delete char unless at end of buff
+;;; c-c c-a comint-bol Beginning of line; skip prompt
;;; c-c c-u comint-kill-input ^u
;;; c-c c-w backward-kill-word ^w
;;; c-c c-c comint-interrupt-subjob ^c
;;; c-c c-\ comint-quit-subjob ^\
;;; c-c c-o comint-kill-output Delete last batch of process output
;;; c-c c-r comint-show-output Show last batch of process output
-;;; c-c c-h comint-dynamic-list-input-ring List input history
+;;; c-c c-l comint-dynamic-list-input-ring List input history
;;;
;;; Not bound by default in comint-mode (some are in shell mode)
+;;; comint-run Run a program under comint-mode
;;; send-invisible Read a line w/o echo, and send to proc
;;; comint-dynamic-complete-filename Complete filename at point.
;;; comint-dynamic-complete-variable Complete variable name at point.
;;; comint-input-autoexpand - symbol ...
;;; comint-input-ignoredups - boolean ...
;;; comint-last-input-match - string ...
+;;; comint-dynamic-complete-functions - hook For the completion mechanism
+;;; comint-completion-fignore - list ...
+;;; comint-file-name-quote-list - list ...
;;; comint-get-old-input - function Hooks for specific
-;;; comint-get-current-command - function process-in-a-buffer
-;;; comint-dynamic-complete-command-command - function modes.
-;;; comint-after-partial-filename-command -
-;;; comint-input-sentinel - function ...
+;;; comint-input-filter-functions - hook process-in-a-buffer
+;;; comint-output-filter-functions - hook function modes.
;;; comint-input-filter - function ...
-;;; comint-input-send - function ...
+;;; comint-input-sender - function ...
;;; comint-eol-on-send - boolean ...
;;; comint-process-echoes - boolean ...
;;; comint-scroll-to-bottom-on-input - symbol For scroll behavior
-;;; comint-scroll-to-bottom-on-output - symbol ...
-;;; comint-scroll-show-maximum-output - boolean ...
+;;; comint-scroll-to-bottom-on-output - symbol ...
+;;; comint-scroll-show-maximum-output - boolean...
;;;
;;; Comint mode non-buffer local variables:
-;;; comint-completion-addsuffix - boolean For file name completion
-;;; comint-completion-autolist - boolean behavior
-;;; comint-completion-recexact - boolean ...
+;;; comint-completion-addsuffix - boolean/cons For file name completion
+;;; comint-completion-autolist - boolean behavior
+;;; comint-completion-recexact - boolean ...
(defvar comint-prompt-regexp "^"
"Regexp to recognise prompts in the inferior process.
See variable `comint-scroll-to-bottom-on-output' and function
`comint-postoutput-scroll-to-bottom'. This variable is buffer-local.")
+(defvar comint-buffer-maximum-size 1024
+ "*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'.")
+
(defvar comint-input-ring-size 32
"Size of input history ring.")
This variable is buffer-local.")
+(defvar comint-password-prompt-regexp
+ "\\(\\([Oo]ld \\|[Nn]ew \\|^\\)[Pp]assword\\|pass phrase\\):\\s *\\'"
+ "*Regexp matching prompts for passwords in the inferior process.
+This is used by `comint-watch-for-password-prompt'.")
+
;;; Here are the per-interpreter hooks.
(defvar comint-get-old-input (function comint-get-old-input-default)
"Function that returns old text in comint mode.
`comint-get-old-input-default', which grabs the current line, and strips off
leading text matching `comint-prompt-regexp'.")
-(defvar comint-after-partial-filename-command 'comint-after-partial-filename
- "Function that returns non-nil if point is after a file name.
-By default this is `comint-after-partial-filename'.
-
-This is a good thing to set in mode hooks.")
-
-(defvar comint-dynamic-complete-filename-command
- 'comint-dynamic-complete-filename
- "Function that dynamically completes the file name at point.
-By default this is `comint-dynamic-complete-filename', though an alternative is
-`comint-replace-by-expanded-filename'.
-
-This is a good thing to set in mode hooks.")
-
-(defvar comint-dynamic-complete-command-command
- 'comint-dynamic-complete-filename
- "Function that dynamically completes the command at point.
-By default this is `comint-dynamic-complete-filename'.
-
-This is a good thing to set in mode hooks.")
-
-(defvar comint-get-current-command 'comint-get-old-input-default
- "Function that returns the current command including arguments.
-By default this is `comint-get-old-input-default', meaning the whole line.
+(defvar comint-dynamic-complete-functions
+ '(comint-replace-by-expanded-history comint-dynamic-complete-filename)
+ "List of functions called to perform completion.
+Functions should return non-nil if completion was performed.
+See also `comint-dynamic-complete'.
This is a good thing to set in mode hooks.")
-(defvar comint-input-sentinel (function ignore)
- "Called on each input submitted to comint mode process by `comint-send-input'.
-Thus it can, for instance, track cd/pushd/popd commands issued to a shell.")
-
(defvar comint-input-filter
(function (lambda (str) (not (string-match "\\`\\s *\\'" str))))
"Predicate for filtering additions to input history.
Takes one argument, the input. If non-nil, the input may be saved on the input
history list. Default is to save anything that isn't all whitespace.")
+(defvar comint-input-filter-functions '()
+ "Functions to call before input is sent to the process.
+These functions get one argument, a string containing the text to send.
+
+This variable is buffer-local.")
+
(defvar comint-output-filter-functions '(comint-postoutput-scroll-to-bottom)
"Functions to call after output is inserted into the buffer.
One possible function is `comint-postoutput-scroll-to-bottom'.
"Index of last matched history element.")
(defvar comint-matching-input-from-input-string ""
"Input previously used to match input history.")
+
+(put 'comint-replace-by-expanded-history 'menu-enable 'comint-input-autoexpand)
(put 'comint-input-ring 'permanent-local t)
(put 'comint-input-ring-index 'permanent-local t)
(put 'comint-input-autoexpand 'permanent-local t)
+(put 'comint-input-filter-functions 'permanent-local t)
(put 'comint-output-filter-functions 'permanent-local t)
(put 'comint-scroll-to-bottom-on-input 'permanent-local t)
(put 'comint-scroll-to-bottom-on-output 'permanent-local t)
This mode is customised to create major modes such as Inferior Lisp
mode, Shell mode, etc. This can be done by setting the hooks
-`comint-input-sentinel', `comint-input-filter', `comint-input-sender'
+`comint-input-filter-functions', `comint-input-filter', `comint-input-sender'
and `comint-get-old-input' to appropriate functions, and the variable
`comint-prompt-regexp' to the appropriate regular expression.
and addition is controlled by the variable `comint-input-ignoredups'.
Commands with no default key bindings include `send-invisible',
-`comint-dynamic-complete', `comint-list-dynamic-completions', and
+`comint-dynamic-complete', `comint-dynamic-list-filename-completions', and
`comint-magic-space'.
Input to, and output from, the subprocess can cause the window to scroll to
(kill-all-local-variables)
(setq major-mode 'comint-mode)
(setq mode-name "Comint")
- (setq mode-line-process '(": %s"))
+ (setq mode-line-process '(":%s"))
(use-local-map comint-mode-map)
(make-local-variable 'comint-last-input-start)
(setq comint-last-input-start (make-marker))
+ (set-marker comint-last-input-start (point-min))
(make-local-variable 'comint-last-input-end)
(setq comint-last-input-end (make-marker))
+ (set-marker comint-last-input-end (point-min))
(make-local-variable 'comint-last-output-start)
(setq comint-last-output-start (make-marker))
(make-local-variable 'comint-prompt-regexp) ; Don't set; default
(make-local-variable 'comint-input-autoexpand)
(make-local-variable 'comint-input-ignoredups)
(make-local-variable 'comint-delimiter-argument-list)
- (make-local-variable 'comint-after-partial-filename-command)
- (make-local-variable 'comint-dynamic-complete-filename-command)
- (make-local-variable 'comint-dynamic-complete-command-command)
- (make-local-variable 'comint-get-current-command)
+ (make-local-hook 'comint-dynamic-complete-functions)
+ (make-local-variable 'comint-completion-fignore)
(make-local-variable 'comint-get-old-input)
- (make-local-variable 'comint-input-sentinel)
+ (make-local-hook 'comint-input-filter-functions)
(make-local-variable 'comint-input-filter)
(make-local-variable 'comint-input-sender)
(make-local-variable 'comint-eol-on-send)
(make-local-variable 'comint-scroll-show-maximum-output)
(make-local-variable 'pre-command-hook)
(add-hook 'pre-command-hook 'comint-preinput-scroll-to-bottom)
- (make-local-variable 'comint-output-filter-functions)
+ (make-local-hook 'comint-output-filter-functions)
(make-local-variable 'comint-ptyp)
(make-local-variable 'comint-exec-hook)
(make-local-variable 'comint-process-echoes)
+ (make-local-variable 'comint-file-name-quote-list)
(run-hooks 'comint-mode-hook))
(if comint-mode-map
(setq comint-mode-map (make-sparse-keymap))
(define-key comint-mode-map "\ep" 'comint-previous-input)
(define-key comint-mode-map "\en" 'comint-next-input)
+ (define-key comint-mode-map [C-up] 'comint-previous-input)
+ (define-key comint-mode-map [C-down] 'comint-next-input)
(define-key comint-mode-map "\er" 'comint-previous-matching-input)
(define-key comint-mode-map "\es" 'comint-next-matching-input)
(define-key comint-mode-map [?\A-\M-r] 'comint-previous-matching-input-from-input)
(define-key comint-mode-map "\e\C-l" 'comint-show-output)
(define-key comint-mode-map "\C-m" 'comint-send-input)
(define-key comint-mode-map "\C-d" 'comint-delchar-or-maybe-eof)
- (define-key comint-mode-map "\C-a" 'comint-bol)
+ (define-key comint-mode-map "\C-c\C-a" 'comint-bol)
(define-key comint-mode-map "\C-c\C-u" 'comint-kill-input)
(define-key comint-mode-map "\C-c\C-w" 'backward-kill-word)
(define-key comint-mode-map "\C-c\C-c" 'comint-interrupt-subjob)
(define-key comint-mode-map "\C-c\C-z" 'comint-stop-subjob)
(define-key comint-mode-map "\C-c\C-\\" 'comint-quit-subjob)
- ;; " ; Stops emacs-19.19's hilit getting confused.
(define-key comint-mode-map "\C-c\C-m" 'comint-copy-old-input)
(define-key comint-mode-map "\C-c\C-o" 'comint-kill-output)
(define-key comint-mode-map "\C-c\C-r" 'comint-show-output)
(define-key comint-mode-map "\C-c\C-e" 'comint-show-maximum-output)
- (define-key comint-mode-map "\C-c\C-h" 'comint-dynamic-list-input-ring)
+ (define-key comint-mode-map "\C-c\C-l" 'comint-dynamic-list-input-ring)
(define-key comint-mode-map "\C-c\C-n" 'comint-next-prompt)
(define-key comint-mode-map "\C-c\C-p" 'comint-previous-prompt)
(define-key comint-mode-map "\C-c\C-d" 'comint-send-eof)
'("Expand File Name" . comint-replace-by-expanded-filename))
(define-key comint-mode-map [menu-bar completion complete-listing]
'("File Completion Listing" . comint-dynamic-list-filename-completions))
- (define-key comint-mode-map [menu-bar completion complete-variable]
- '("Complete Variable Name" . comint-dynamic-complete-variable))
- (define-key comint-mode-map [menu-bar completion complete-command]
- '("Complete Command Name" . (lambda () (interactive)
- (funcall
- comint-dynamic-complete-command-command))))
(define-key comint-mode-map [menu-bar completion complete-file]
'("Complete File Name" . comint-dynamic-complete-filename))
(define-key comint-mode-map [menu-bar completion complete]
(defun comint-check-proc (buffer)
"Return t if there is a living process associated w/buffer BUFFER.
-Living means the status is `run' or `stop'.
+Living means the status is `open', `run', or `stop'.
BUFFER can be either a buffer or the name of one."
(let ((proc (get-buffer-process buffer)))
- (and proc (memq (process-status proc) '(run stop)))))
+ (and proc (memq (process-status proc) '(open run stop)))))
;;; Note that this guy, unlike shell.el's make-shell, barfs if you pass it ()
;;; for the second argument (program).
(defun make-comint (name program &optional startfile &rest switches)
"Make a comint process NAME in a buffer, running PROGRAM.
The name of the buffer is made by surrounding NAME with `*'s.
-If there is already a running process in that buffer, it is not restarted.
-Optional third arg STARTFILE is the name of a file to send the contents of to
-the process. Any more args are arguments to PROGRAM."
+PROGRAM should be either a string denoting an executable program to create
+via `start-process', or a cons pair of the form (HOST . SERVICE) denoting a TCP
+connection to be opened via `open-network-stream'. If there is already a
+running process in that buffer, it is not restarted. Optional third arg
+STARTFILE is the name of a file to send the contents of to the process.
+
+If PROGRAM is a string, any more args are arguments to PROGRAM."
+ (or (fboundp 'start-process)
+ (error "Multi-processing is not supported for this system"))
(let ((buffer (get-buffer-create (concat "*" name "*"))))
;; If no process, or nuked process, crank up a new one and put buffer in
;; comint mode. Otherwise, leave buffer and existing process alone.
(comint-exec buffer name program startfile switches)))
buffer))
+;;;###autoload
+(defun comint-run (program)
+ "Run PROGRAM in a comint buffer and switch to it.
+The buffer name is made by surrounding the file name of PROGRAM with `*'s.
+The file name is used to make a symbol name, such as `comint-sh-hook', and any
+hooks on this symbol are run in the buffer.
+See `make-comint' and `comint-exec'."
+ (interactive "sRun program: ")
+ (let ((name (file-name-nondirectory program)))
+ (switch-to-buffer (make-comint name program))
+ (run-hooks (intern-soft (concat "comint-" name "-hook")))))
+
(defun comint-exec (buffer name command startfile switches)
"Start up a process in buffer BUFFER for comint modes.
Blasts any old process running in the buffer. Doesn't set the buffer mode.
(let ((proc (get-buffer-process buffer))) ; Blast any old process.
(if proc (delete-process proc)))
;; Crank up a new process
- (let ((proc (comint-exec-1 name buffer command switches)))
+ (let ((proc
+ (if (consp command)
+ (open-network-stream name buffer (car command) (cdr command))
+ (comint-exec-1 name buffer command switches))))
(set-process-filter proc 'comint-output-filter)
(make-local-variable 'comint-ptyp)
(setq comint-ptyp process-connection-type) ; T if pty, NIL if pipe.
;;; the appropriate environment.
(defun comint-exec-1 (name buffer command switches)
- (let ((process-environment (copy-sequence process-environment)))
- (setenv "TERMCAP" (format "emacs:co#%d:tc=unknown" (frame-width)))
- (setenv "TERM" "emacs")
- (setenv "EMACS" "t")
+ (let ((process-environment
+ (nconc
+ ;; If using termcap, we specify `emacs' as the terminal type
+ ;; because that lets us specify a width.
+ ;; If using terminfo, we specify `unknown' because that is
+ ;; a defined terminal type. `emacs' is not a defined terminal type
+ ;; and there is no way for us to define it here.
+ ;; Some programs that use terminfo get very confused
+ ;; if TERM is not a valid terminal type.
+ (if (and (boundp 'system-uses-terminfo) system-uses-terminfo)
+ (list "TERM=unknown"
+ (format "COLUMNS=%d" (frame-width)))
+ (list "TERM=emacs"
+ (format "TERMCAP=emacs:co#%d:tc=unknown:" (frame-width))))
+ (if (getenv "EMACS") nil (list "EMACS=t"))
+ process-environment))
+ (default-directory
+ (if (file-directory-p default-directory)
+ default-directory
+ "/")))
(apply 'start-process name buffer command switches)))
\f
;;; Input history processing in a buffer
;;; replace with expanded history.
;;; comint-magic-space Expand history and insert space.
;;;
-;;; Two functions:
+;;; Three functions:
;;; comint-read-input-ring Read into comint-input-ring...
;;; comint-write-input-ring Write to comint-input-ring-file-name.
+;;; comint-replace-by-expanded-history-before-point Workhorse function.
(defun comint-read-input-ring (&optional silent)
"Sets the buffer's `comint-input-ring' from a history file.
(message "Cannot read history file %s"
comint-input-ring-file-name)))
(t
- (let ((history-buf (get-file-buffer comint-input-ring-file-name))
+ (let ((history-buf (get-buffer-create " *temp*"))
+ (file comint-input-ring-file-name)
+ (count 0)
(ring (make-ring comint-input-ring-size)))
- (save-excursion
- (set-buffer (or history-buf
- (find-file-noselect comint-input-ring-file-name)))
- ;; Save restriction in case file is already visited...
- ;; Watch for those date stamps in history files!
- (save-excursion
- (save-restriction
+ (unwind-protect
+ (save-excursion
+ (set-buffer history-buf)
(widen)
- (goto-char (point-min))
- (while (re-search-forward "^\\s *\\([^#].*\\)\\s *$" nil t)
+ (erase-buffer)
+ (insert-file-contents file)
+ ;; Save restriction in case file is already visited...
+ ;; Watch for those date stamps in history files!
+ (goto-char (point-max))
+ (while (and (< count comint-input-ring-size)
+ (re-search-backward "^[ \t]*\\([^#\n].*\\)[ \t]*$"
+ nil t))
(let ((history (buffer-substring (match-beginning 1)
(match-end 1))))
(if (or (null comint-input-ignoredups)
(ring-empty-p ring)
(not (string-equal (ring-ref ring 0) history)))
- (ring-insert ring history)))))
- ;; Kill buffer unless already visited.
- (if (null history-buf)
- (kill-buffer nil))))
+ (ring-insert-at-beginning ring history)))
+ (setq count (1+ count))))
+ (kill-buffer history-buf))
(setq comint-input-ring ring
comint-input-ring-index nil)))))
(defun comint-replace-by-expanded-history (&optional silent)
"Expand input command history references before point.
+Expansion is dependent on the value of `comint-input-autoexpand'.
+
This function depends on the buffer's idea of the input history, which may not
match the command interpreter's idea, assuming it has one.
If the optional argument SILENT is non-nil, never complain
even if history reference seems erroneous.
-See also `comint-magic-space'."
+See `comint-magic-space' and `comint-replace-by-expanded-history-before-point'.
+
+Returns t if successful."
(interactive)
+ (if (and comint-input-autoexpand
+ (string-match "[!^]" (funcall comint-get-old-input))
+ (save-excursion (beginning-of-line)
+ (looking-at comint-prompt-regexp)))
+ ;; Looks like there might be history references in the command.
+ (let ((previous-modified-tick (buffer-modified-tick)))
+ (message "Expanding history references...")
+ (comint-replace-by-expanded-history-before-point silent)
+ (/= previous-modified-tick (buffer-modified-tick)))))
+
+
+(defun comint-replace-by-expanded-history-before-point (silent)
+ "Expand directory stack reference before point.
+See `comint-replace-by-expanded-history'. Returns t if successful."
(save-excursion
(let ((toend (- (save-excursion (end-of-line nil) (point)) (point)))
(start (progn (comint-bol nil) (point))))
(progn
(replace-match
(comint-args (comint-previous-input-string number)
- (match-beginning 2) (match-end 2)) t t)
+ (match-beginning 2) (match-end 2))
+ t t)
(setq comint-input-ring-index number)
(message "History item: %d" (1+ number)))
(goto-char (match-end 0))
;; Just a number of args from the previous input line.
(replace-match
(comint-args (comint-previous-input-string 0)
- (match-beginning 1) (match-end 1)) t t))
+ (match-beginning 1) (match-end 1))
+ t t)
+ (message "History item: previous"))
((looking-at
"!\\??\\({\\(.+\\)}\\|\\(\\sw+\\)\\)\\(:?[0-9^$*-]+\\)?")
;; Most recent input starting with or containing (possibly
(comint-previous-matching-input-string-position
(concat pref (regexp-quote exp)) 1))))
(if (null pos)
- (or silent
- (progn (message "Not found")
- (goto-char (match-end 0))
- (ding)))
+ (progn
+ (goto-char (match-end 0))
+ (or silent
+ (progn (message "Not found")
+ (ding))))
(setq comint-input-ring-index pos)
- (message "History item: %d" (1+ pos))
(replace-match
(comint-args (ring-ref comint-input-ring pos)
(match-beginning 4) (match-end 4))
- t t))))
+ t t)
+ (message "History item: %d" (1+ pos)))))
((looking-at "\\^\\([^^]+\\)\\^?\\([^^]*\\)\\^?")
;; Quick substitution on the previous input line.
(let ((old (buffer-substring (match-beginning 1) (match-end 1)))
(replace-match (comint-previous-input-string 0) t t)
(setq pos (point))
(goto-char (match-beginning 0))
- (if (search-forward old pos t)
- (replace-match new t t)
- (or silent
- (progn
- (message "Not found")
- (ding))))))
+ (if (not (search-forward old pos t))
+ (or silent
+ (error "Not found"))
+ (replace-match new t t)
+ (message "History item: substituted"))))
(t
(goto-char (match-end 0))))))))
Also, a run of one or more of a single character
in `comint-delimiter-argument-list' is a separate argument.
Argument 0 is the command name."
- (let ((arg "\\(\\(\"[^\"]*\"\\|\'[^\']*\'\\|\`[^\`]*\`\\)\\|\\S \\)+")
- (args ()) (pos 0) (str nil))
- ;; We build a list of all the args. Unnecessary, but more efficient, when
- ;; ranges of args are required, than picking out one by one and recursing.
- (while (string-match arg string pos)
- (setq pos (match-end 0)
- str (substring string (match-beginning 0) pos)
- ;; (match-end 2) is non-nil if we found quotes.
- args (if (match-end 2) (cons str args)
- (nconc (comint-delim-arg str) args))))
- (let ((n (or nth (1- (length args))))
- (m (if mth (1- (- (length args) mth)) 0)))
+ (let ((argpart "[^ \n\t\"'`]+\\|\\(\"[^\"]*\"\\|'[^']*'\\|`[^`]*`\\)")
+ (args ()) (pos 0)
+ (count 0)
+ beg str value quotes)
+ ;; Build a list of all the args until we have as many as we want.
+ (while (and (or (null mth) (<= count mth))
+ (string-match argpart string pos))
+ (if (and beg (= pos (match-beginning 0)))
+ ;; It's contiguous, part of the same arg.
+ (setq pos (match-end 0)
+ quotes (or quotes (match-beginning 1)))
+ ;; It's a new separate arg.
+ (if beg
+ ;; Put the previous arg, if there was one, onto ARGS.
+ (setq str (substring string beg pos)
+ args (if quotes (cons str args)
+ (nconc (comint-delim-arg str) args))
+ count (1+ count)))
+ (setq quotes (match-beginning 1))
+ (setq beg (match-beginning 0))
+ (setq pos (match-end 0))))
+ (if beg
+ (setq str (substring string beg pos)
+ args (if quotes (cons str args)
+ (nconc (comint-delim-arg str) args))
+ count (1+ count)))
+ (let ((n (or nth (1- count)))
+ (m (if mth (1- (- count mth)) 0)))
(mapconcat
(function (lambda (a) a)) (nthcdr n (nreverse (nthcdr m args))) " "))))
\f
since it is assumed the remote process will re-echo it).
Any history reference may be expanded depending on the value of the variable
-`comint-input-autoexpand'. The value of variable `comint-input-sentinel' is
-called on the input before sending it. The input is entered into the input
-history ring, if the value of variable `comint-input-filter' returns non-nil
-when called on the input.
+`comint-input-autoexpand'. The list of function names contained in the value
+of `comint-input-filter-functions' is called on the input before sending it.
+The input is entered into the input history ring, if the value of variable
+`comint-input-filter' returns non-nil when called on the input.
If variable `comint-eol-on-send' is non-nil, then point is moved to the
end of line before sending the input.
-`comint-get-old-input', `comint-input-sentinel', and `comint-input-filter'
-are chosen according to the command interpreter running in the buffer. E.g.,
+The values of `comint-get-old-input', `comint-input-filter-functions', and
+`comint-input-filter' are chosen according to the command interpreter running
+in the buffer. E.g.,
+
If the interpreter is the csh,
comint-get-old-input is the default: take the current line, discard any
initial string matching regexp comint-prompt-regexp.
- comint-input-sentinel monitors input for \"cd\", \"pushd\", and \"popd\"
- commands. When it sees one, it cd's the buffer.
+ comint-input-filter-functions monitors input for \"cd\", \"pushd\", and
+ \"popd\" commands. When it sees one, it cd's the buffer.
comint-input-filter is the default: returns t if the input isn't all white
space.
If the comint is Lucid Common Lisp,
comint-get-old-input snarfs the sexp ending at point.
- comint-input-sentinel does nothing.
+ comint-input-filter-functions does nothing.
comint-input-filter returns nil if the input matches input-filter-regexp,
which matches (1) all whitespace (2) :a, :c, etc.
(not (string-equal (ring-ref comint-input-ring 0)
history))))
(ring-insert comint-input-ring history))
- (funcall comint-input-sentinel input)
- (funcall comint-input-sender proc input)
+ (run-hook-with-args 'comint-input-filter-functions
+ (concat input "\n"))
(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))
- ;; A kludge to prevent the delay between insert and process output
- ;; affecting the display. A case for a comint-send-input-hook?
- (if (eq (process-filter proc) 'comint-output-filter)
- (let ((functions comint-output-filter-functions))
- (while functions
- (funcall (car functions) (concat input "\n"))
- (setq functions (cdr functions)))))))))
+ (funcall comint-input-sender proc input)
+ (comint-output-filter proc "")))))
;; The purpose of using this filter for comint processes
;; is to keep comint-last-input-end from moving forward
(narrow-to-region obeg oend)
(goto-char opoint)
- (let ((functions comint-output-filter-functions))
- (while functions
- (funcall (car functions) string)
- (setq functions (cdr functions))))
+ (run-hook-with-args 'comint-output-filter-functions string)
(set-buffer obuf)))))
(defun comint-preinput-scroll-to-bottom ()
nil t))
(set-buffer current))))
+(defun comint-truncate-buffer (&optional string)
+ "Truncate the buffer to `comint-buffer-maximum-size'.
+This function could be on `comint-output-filter-functions' or bound to a key."
+ (interactive)
+ (save-excursion
+ (goto-char (point-max))
+ (forward-line (- comint-buffer-maximum-size))
+ (beginning-of-line)
+ (delete-region (point-min) (point))))
+
+(defun comint-strip-ctrl-m (&optional string)
+ "Strip trailing `^M' characters from the current output group.
+This function could be on `comint-output-filter-functions' or bound to a key."
+ (interactive)
+ (let ((pmark (process-mark (get-buffer-process (current-buffer)))))
+ (save-excursion
+ (goto-char
+ (if (interactive-p) comint-last-input-end comint-last-output-start))
+ (while (re-search-forward "\r+$" pmark t)
+ (replace-match "" t t)))))
+(defalias 'shell-strip-ctrl-m 'comint-strip-ctrl-m)
+
(defun comint-show-maximum-output ()
"Put the end of the buffer at the bottom of the window."
(interactive)
If prefix argument is given (\\[universal-argument]) the prompt is not skipped.
The prompt skip is done by skipping text matching the regular expression
-`comint-prompt-regexp', a buffer local variable.
-
-If you don't like this command, bind C-a to `beginning-of-line'
-in your hook, `comint-mode-hook'."
+`comint-prompt-regexp', a buffer local variable."
(interactive "P")
(beginning-of-line)
(if (null arg) (comint-skip-prompt)))
-;;; These two functions are for entering text you don't want echoed or
+;;; These three functions are for entering text you don't want echoed or
;;; saved -- typically passwords to ftp, telnet, or somesuch.
-;;; Just enter m-x send-invisible and type in your line.
+;;; Just enter m-x send-invisible and type in your line, or add
+;;; `comint-watch-for-password-prompt' to `comint-output-filter-functions'.
(defun comint-read-noecho (prompt &optional stars)
"Read a single line of text from user without echoing, and return it.
(c 0)
(echo-keystrokes 0)
(cursor-in-echo-area t)
- (done nil))
+ (message-log-max nil)
+ (done nil))
(while (not done)
(if stars
- (message "%s%s" prompt (make-string (length ans) ?*))
- (message prompt))
- (setq c (read-char))
+ (message "%s%s" prompt (make-string (length ans) ?*))
+ (message "%s" prompt))
+ ;; Use this instead of `read-char' to avoid "Non-character input-event".
+ (setq c (read-char-exclusive))
(cond ((= c ?\C-g)
- ;; This function may get called from a process filter, where
- ;; inhibit-quit is set. In later versions of emacs read-char
- ;; may clear quit-flag itself and return C-g. That would make
- ;; it impossible to quit this loop in a simple way, so
- ;; re-enable it here (for backward-compatibility the check for
- ;; quit-flag below would still be necessary, so this is seems
- ;; like the simplest way to do things).
- (setq quit-flag t
- done t))
- ((or (= c ?\r) (= c ?\n) (= c ?\e))
- (setq done t))
- ((= c ?\C-u)
- (setq ans ""))
- ((and (/= c ?\b) (/= c ?\177))
- (setq ans (concat ans (char-to-string c))))
- ((> (length ans) 0)
- (setq ans (substring ans 0 -1)))))
+ ;; This function may get called from a process filter, where
+ ;; inhibit-quit is set. In later versions of emacs read-char
+ ;; may clear quit-flag itself and return C-g. That would make
+ ;; it impossible to quit this loop in a simple way, so
+ ;; re-enable it here (for backward-compatibility the check for
+ ;; quit-flag below would still be necessary, so this seems
+ ;; like the simplest way to do things).
+ (setq quit-flag t
+ done t))
+ ((or (= c ?\r) (= c ?\n) (= c ?\e))
+ (setq done t))
+ ((= c ?\C-u)
+ (setq ans ""))
+ ((and (/= c ?\b) (/= c ?\177))
+ (setq ans (concat ans (char-to-string c))))
+ ((> (length ans) 0)
+ (setq ans (substring ans 0 -1)))))
(if quit-flag
;; Emulate a true quit, except that we have to return a value.
(prog1
\\[view-lossage]."
(interactive "P") ; Defeat snooping via C-x esc
(let ((proc (get-buffer-process (current-buffer))))
- (if (not proc) (error "Current buffer has no process")
- (comint-send-string proc
- (if (stringp str) str
- (comint-read-noecho "Non-echoed text: " t)))
- (comint-send-string proc "\n"))))
-
+ (if (not proc)
+ (error "Current buffer has no process")
+ (comint-send-string
+ proc (if (stringp str) str (comint-read-noecho "Non-echoed text: " t)))
+ (comint-send-string proc "\n"))))
+
+(defun comint-watch-for-password-prompt (string)
+ "Prompt in the minibuffer for password and send without echoing.
+This function uses `send-invisible' to read and send a password to the buffer's
+process if STRING contains a password prompt defined by
+`comint-password-prompt-regexp'.
+
+This function could be in the list `comint-output-filter-functions'."
+ (if (string-match comint-password-prompt-regexp string)
+ (send-invisible nil)))
\f
;;; Low-level process communication
-(defvar comint-input-chunk-size 512
- "*Long inputs are sent to comint processes in chunks of this size.
-If your process is choking on big inputs, try lowering the value.")
-
-(defun comint-send-string (proc str)
- "Send PROCESS the contents of STRING as input.
-This is equivalent to `process-send-string', except that long input strings
-are broken up into chunks of size `comint-input-chunk-size'. Processes
-are given a chance to output between chunks. This can help prevent processes
-from hanging when you send them long inputs on some OS's."
- (let* ((len (length str))
- (i (min len comint-input-chunk-size)))
- (process-send-string proc (substring str 0 i))
- (while (< i len)
- (let ((next-i (+ i comint-input-chunk-size)))
- (accept-process-output)
- (sit-for 0)
- (process-send-string proc (substring str i (min len next-i)))
- (setq i next-i)))))
-
-(defun comint-send-region (proc start end)
- "Sends to PROC the region delimited by START and END.
-This is a replacement for `process-send-region' that tries to keep
-your process from hanging on long inputs. See `comint-send-string'."
- (comint-send-string proc (buffer-substring start end)))
+(defalias 'comint-send-string 'process-send-string)
+(defalias 'comint-send-region 'process-send-region)
\f
;;; Random input hackage
"Kill all output from interpreter since last input.
Does not delete the prompt."
(interactive)
- (let ((pmark (progn (goto-char
- (process-mark (get-buffer-process (current-buffer))))
- (beginning-of-line nil)
- (point-marker))))
- (kill-region comint-last-input-end pmark)
- (insert "*** output flushed ***\n")
- (comint-skip-prompt)
- (set-marker pmark (point))))
+ (let ((proc (get-buffer-process (current-buffer)))
+ (replacement nil))
+ (save-excursion
+ (let ((pmark (progn (goto-char (process-mark proc))
+ (beginning-of-line nil)
+ (point-marker))))
+ (delete-region comint-last-input-end pmark)
+ (goto-char (process-mark proc))
+ (setq replacement (concat "*** output flushed ***\n"
+ (buffer-substring pmark (point))))
+ (delete-region pmark (point))))
+ ;; Output message and put back prompt
+ (comint-output-filter proc replacement)))
(defun comint-show-output ()
"Display start of this batch of interpreter output at top of window.
-Also put cursor there if the current position is not visible."
+Sets mark to the value of point when this command is run."
(interactive)
(push-mark)
(let ((pos (point)))
;;; ===========================================================================
;;; Useful completion functions, courtesy of the Ergo group.
-;;; Six functions:
+;;; Six commands:
;;; comint-dynamic-complete Complete or expand command, filename,
;;; history at point.
;;; comint-dynamic-complete-filename Complete filename at point.
-;;; comint-dynamic-complete-variable Complete variable at point.
;;; comint-dynamic-list-filename-completions List completions in help buffer.
;;; comint-replace-by-expanded-filename Expand and complete filename at point;
;;; replace with expanded/completed name.
;;; comint-dynamic-simple-complete Complete stub given candidates.
-;;; Four hooks (defined above):
-;;; comint-dynamic-complete-filename-command Complete file name at point.
-;;; comint-dynamic-complete-command-command Complete command at point.
-;;; comint-get-current-command Return command at point.
-;;; comint-after-partial-filename-command Return non-nil if after file.
-
;;; These are not installed in the comint-mode keymap. But they are
;;; available for people who want them. Shell-mode installs them:
;;; (define-key shell-mode-map "\t" 'comint-dynamic-complete)
(defvar comint-completion-addsuffix t
"*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.")
(defvar comint-completion-recexact nil
A non-nil value is useful if `comint-completion-autolist' is non-nil too.")
+(defvar comint-completion-fignore nil
+ "*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.")
+
(defvar comint-file-name-prefix ""
"Prefix prepended to absolute file names taken from process input.
This is used by comint's and shell's completion functions, and by shell's
directory tracking functions.")
+(defvar comint-file-name-quote-list nil
+ "List of characters to quote with `\' when in a file name.
+
+This is a good thing to set in mode hooks.")
+
(defun comint-directory (directory)
;; Return expanded DIRECTORY, with `comint-file-name-prefix' if absolute.
directory)))
-(defun comint-match-partial-filename ()
- "Return the filename at point, or signal an error.
-Environment variables are substituted."
+(defun comint-word (word-chars)
+ "Return the word of WORD-CHARS at point, or nil if non is found.
+Word constituents are considered to be those in WORD-CHARS, which is like the
+inside of a \"[...]\" (see `skip-chars-forward')."
(save-excursion
- (if (re-search-backward "[^~/A-Za-z0-9+@:_.$#,={}-]" nil 'move)
- (forward-char 1))
- ;; Anchor the search forwards.
- (if (not (looking-at "[~/A-Za-z0-9+@:_.$#,={}-]")) (error ""))
- (re-search-forward "[~/A-Za-z0-9+@:_.$#,={}-]+")
- (substitute-in-file-name
- (buffer-substring (match-beginning 0) (match-end 0)))))
-
+ (let ((non-word-chars (concat "[^\\\\" word-chars "]")) (here (point)))
+ (while (and (re-search-backward non-word-chars nil 'move)
+ ;(memq (char-after (point)) shell-file-name-quote-list)
+ (eq (preceding-char) ?\\))
+ (backward-char 1))
+ ;; Don't go forward over a word-char (this can happen if we're at bob).
+ (if (or (not (bobp)) (looking-at non-word-chars))
+ (forward-char 1))
+ ;; Set match-data to match the entire string.
+ (if (< (point) here)
+ (progn (store-match-data (list (point) here))
+ (match-string 0))))))
-(defun comint-match-partial-variable ()
- "Return the variable at point, or signal an error."
- (save-excursion
- (if (re-search-backward "[^A-Za-z0-9_${}]" nil 'move)
- (forward-char 1))
- ;; Anchor the search forwards.
- (if (not (looking-at "\\$")) (error ""))
- (re-search-forward "\\${?[A-Za-z0-9_]+}?")
- (buffer-substring (match-beginning 0) (match-end 0))))
+(defun comint-match-partial-filename ()
+ "Return the filename at point, or nil if non is found.
+Environment variables are substituted. See `comint-word'."
+ (let ((filename (comint-word "~/A-Za-z0-9+@:_.$#%,={}-")))
+ (and filename (substitute-in-file-name (comint-unquote-filename filename)))))
+
+
+(defun comint-quote-filename (filename)
+ "Return FILENAME with magic characters quoted.
+Magic characters are those in `comint-file-name-quote-list'."
+ (if (null comint-file-name-quote-list)
+ filename
+ (let ((regexp
+ (format "\\(^\\|[^\\]\\)\\([%s]\\)"
+ (mapconcat 'char-to-string comint-file-name-quote-list ""))))
+ (save-match-data
+ (while (string-match regexp filename)
+ (setq filename (replace-match "\\1\\\\\\2" nil nil filename)))
+ filename))))
-(defun comint-after-partial-filename ()
- "Returns t if point is after a file name.
-File names are assumed to contain `/'s or not be the first item in the input.
-
-See also `comint-bol'."
- (let ((filename (comint-match-partial-filename)))
- (or (save-match-data (string-match "/" filename))
- (not (eq (match-beginning 0)
- (save-excursion (comint-bol nil) (point)))))))
+(defun comint-unquote-filename (filename)
+ "Return FILENAME with quoted characters unquoted."
+ (if (null comint-file-name-quote-list)
+ filename
+ (save-match-data
+ (while (string-match "\\\\\\(.\\)" filename)
+ (setq filename (replace-match "\\1" nil nil filename)))
+ filename)))
(defun comint-dynamic-complete ()
- "Dynamically complete/expand the command/filename/history at point.
-If the text contains (a non-absolute line reference) `!' or `^' and
-`comint-input-autoexpand' is non-nil, then an attempt is made to complete the
-history. The value of the variable `comint-after-partial-filename-command' is
-used to match file names. Otherwise, an attempt is made to complete the
-command.
-
-See also the variables `comint-after-partial-filename-command',
-`comint-dynamic-complete-filename-command', and
-`comint-dynamic-complete-command-command', and functions
-`comint-replace-by-expanded-history' and `comint-magic-space'."
+ "Dynamically perform completion at point.
+Calls the functions in `comint-dynamic-complete-functions' to perform
+completion until a function returns non-nil, at which point completion is
+assumed to have occurred."
(interactive)
- (let ((previous-modified-tick (buffer-modified-tick)))
- (if (and comint-input-autoexpand
- (string-match "[!^]" (funcall comint-get-current-command)))
- ;; Looks like there might be history references in the command.
- (comint-replace-by-expanded-history))
- (if (= previous-modified-tick (buffer-modified-tick))
- ;; No references were expanded, so maybe they were none after all.
- (cond ((funcall comint-after-partial-filename-command)
- ;; It's a file name.
- (funcall comint-dynamic-complete-filename-command))
- (t
- ;; Assume it's a command.
- (funcall comint-dynamic-complete-command-command))))))
+ (run-hook-with-args-until-success 'comint-dynamic-complete-functions))
(defun comint-dynamic-complete-filename ()
"Dynamically complete the filename at point.
+Completes if after a filename. See `comint-match-partial-filename' and
+`comint-dynamic-complete-as-filename'.
This function is similar to `comint-replace-by-expanded-filename', except that
it won't change parts of the filename already entered in the buffer; it just
adds completion characters to the end of the filename. A completions listing
may be shown in a help buffer if completion is ambiguous.
-Completion is dependent on the value of `comint-completion-addsuffix' and
-`comint-completion-recexact', and the timing of completions listing is
-dependent on the value of `comint-completion-autolist'."
+Completion is dependent on the value of `comint-completion-addsuffix',
+`comint-completion-recexact' and `comint-completion-fignore', and the timing of
+completions listing is dependent on the value of `comint-completion-autolist'.
+
+Returns t if successful."
(interactive)
+ (if (comint-match-partial-filename)
+ (prog2 (or (window-minibuffer-p (selected-window))
+ (message "Completing file name..."))
+ (comint-dynamic-complete-as-filename))))
+
+
+(defun comint-dynamic-complete-as-filename ()
+ "Dynamically complete at point as a filename.
+See `comint-dynamic-complete-filename'. Returns t if successful."
(let* ((completion-ignore-case nil)
- ;; For shell completion, treat all files as equally interesting.
- (completion-ignored-extensions nil)
- (filename (comint-match-partial-filename))
- (pathdir (file-name-directory filename))
- (pathnondir (file-name-nondirectory filename))
- (directory (if pathdir (comint-directory pathdir) default-directory))
+ (completion-ignored-extensions comint-completion-fignore)
+ (file-name-handler-alist nil)
+ (minibuffer-p (window-minibuffer-p (selected-window)))
+ (success t)
+ (dirsuffix (cond ((not comint-completion-addsuffix) "")
+ ((not (consp comint-completion-addsuffix)) "/")
+ (t (car comint-completion-addsuffix))))
+ (filesuffix (cond ((not comint-completion-addsuffix) "")
+ ((not (consp comint-completion-addsuffix)) " ")
+ (t (cdr comint-completion-addsuffix))))
+ (filename (or (comint-match-partial-filename) ""))
+ (pathdir (file-name-directory filename))
+ (pathnondir (file-name-nondirectory filename))
+ (directory (if pathdir (comint-directory pathdir) default-directory))
(completion (file-name-completion pathnondir directory)))
(cond ((null completion)
(message "No completions of %s" filename)
- (ding))
+ (setq success nil))
((eq completion t) ; Means already completed "file".
- (if comint-completion-addsuffix (insert " "))
- (message "Sole completion"))
+ (insert filesuffix)
+ (or minibuffer-p (message "Sole completion")))
((string-equal completion "") ; Means completion on "directory/".
(comint-dynamic-list-filename-completions))
(t ; Completion string returned.
(let ((file (concat (file-name-as-directory directory) completion)))
- (goto-char (match-end 0))
- (insert (substring (directory-file-name completion)
- (length pathnondir)))
+ (insert (comint-quote-filename
+ (substring (directory-file-name completion)
+ (length pathnondir))))
(cond ((symbolp (file-name-completion completion directory))
;; We inserted a unique completion.
- (if comint-completion-addsuffix
- (insert (if (file-directory-p file) "/" " ")))
- (message "Completed"))
+ (insert (if (file-directory-p file) dirsuffix filesuffix))
+ (or minibuffer-p (message "Completed")))
((and comint-completion-recexact comint-completion-addsuffix
(string-equal pathnondir completion)
(file-exists-p file))
;; It's not unique, but user wants shortest match.
- (insert (if (file-directory-p file) "/" " "))
- (message "Completed shortest"))
+ (insert (if (file-directory-p file) dirsuffix filesuffix))
+ (or minibuffer-p (message "Completed shortest")))
((or comint-completion-autolist
(string-equal pathnondir completion))
;; It's not unique, list possible completions.
(comint-dynamic-list-filename-completions))
(t
- (message "Partially completed"))))))))
+ (or minibuffer-p (message "Partially completed")))))))
+ success))
(defun comint-replace-by-expanded-filename ()
(comint-dynamic-complete-filename))
-(defun comint-dynamic-complete-variable ()
- "Dynamically complete the environment variable at point.
-This function is similar to `comint-dynamic-complete-filename', except that it
-searches `process-environment' for completion candidates. Note that this may
-not be the same as the interpreter's idea of variable names. The main
-problem with this type of completion is that `process-environment' is the
-environment which Emacs started with. Emacs does not track changes to the
-environment made by the interpreter. Perhaps it would be more accurate if this
-function was called `comint-dynamic-complete-process-environment-variable'.
-
-See also `comint-dynamic-complete-filename'."
- (interactive)
- (let* ((completion-ignore-case nil)
- (variable (comint-match-partial-variable))
- (varname (substring variable (string-match "[^$({]" variable)))
- (protection (cond ((string-match "{" variable) "}")
- ((string-match "(" variable) ")")
- (t "")))
- (variables (mapcar (function (lambda (x)
- (list (substring x 0 (string-match "=" x)))))
- process-environment))
- (var-directory-p
- (function (lambda (var)
- (file-directory-p
- (comint-directory (substitute-in-file-name (concat "$" var)))))))
- (completions (all-completions varname variables)))
- ;; Complete variable as if its value were a filename (which it might be).
- (cond ((null completions)
- (message "No completions of %s" varname)
- (ding))
- ((= 1 (length completions)) ; Gotcha!
- (let ((completion (car completions)))
- (if (string-equal completion varname)
- (message "Sole completion")
- (insert (substring (directory-file-name completion)
- (length varname)))
- (message "Completed"))
- (insert protection)
- (if comint-completion-addsuffix
- (insert (if (funcall var-directory-p completion) "/" " ")))))
- (t ; There's no unique completion.
- (let ((completion (try-completion varname variables)))
- ;; Insert the longest substring.
- (insert (substring (directory-file-name completion)
- (length varname)))
- (cond ((and comint-completion-recexact comint-completion-addsuffix
- (string-equal varname completion)
- (member completion completions))
- ;; It's not unique, but user wants shortest match.
- (insert protection
- (if (funcall var-directory-p completion) "/" " "))
- (message "Completed shortest"))
- ((or comint-completion-autolist
- (string-equal varname completion))
- ;; It's not unique, list possible completions.
- (comint-dynamic-list-completions completions))
- (t
- (message "Partially completed"))))))))
-
-
(defun comint-dynamic-simple-complete (stub candidates)
"Dynamically complete STUB from CANDIDATES list.
This function inserts completion characters at point by completing STUB from
the strings in CANDIDATES. A completions listing may be shown in a help buffer
if completion is ambiguous.
+Returns nil if no completion was inserted.
+Returns `sole' if completed with the only completion match.
+Returns `shortest' if completed with the shortest of the completion matches.
+Returns `partial' if completed as far as possible with the completion matches.
+Returns `listed' if a completion listing was shown.
+
See also `comint-dynamic-complete-filename'."
(let* ((completion-ignore-case nil)
+ (suffix (cond ((not comint-completion-addsuffix) "")
+ ((not (consp comint-completion-addsuffix)) " ")
+ (t (cdr comint-completion-addsuffix))))
(candidates (mapcar (function (lambda (x) (list x))) candidates))
(completions (all-completions stub candidates)))
(cond ((null completions)
(message "No completions of %s" stub)
- (ding))
+ nil)
((= 1 (length completions)) ; Gotcha!
(let ((completion (car completions)))
(if (string-equal completion stub)
(message "Sole completion")
(insert (substring completion (length stub)))
(message "Completed"))
- (if comint-completion-addsuffix (insert " "))))
+ (insert suffix)
+ 'sole))
(t ; There's no unique completion.
(let ((completion (try-completion stub candidates)))
;; Insert the longest substring.
(string-equal stub completion)
(member completion completions))
;; It's not unique, but user wants shortest match.
- (insert " ")
- (message "Completed shortest"))
+ (insert suffix)
+ (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)
+ 'listed)
(t
- (message "Partially completed"))))))))
+ (message "Partially completed")
+ 'partial)))))))
(defun comint-dynamic-list-filename-completions ()
"List in help buffer possible completions of the filename at point."
(interactive)
(let* ((completion-ignore-case nil)
- ;; For shell completion, treat all files as equally interesting.
- (completion-ignored-extensions nil)
- (filename (comint-match-partial-filename))
+ (file-name-handler-alist nil)
+ (filename (or (comint-match-partial-filename) ""))
(pathdir (file-name-directory filename))
(pathnondir (file-name-nondirectory filename))
(directory (if pathdir (comint-directory pathdir) default-directory))
(completions (file-name-all-completions pathnondir directory)))
- (if completions
- (comint-dynamic-list-completions completions)
- (message "No completions of %s" filename)
- (ding))))
+ (if (not completions)
+ (message "No completions of %s" filename)
+ (comint-dynamic-list-completions
+ (mapcar 'comint-quote-filename completions)))))
(defun comint-dynamic-list-completions (completions)
"List in help buffer sorted COMPLETIONS.
Typing SPC flushes the help buffer."
(let ((conf (current-window-configuration)))
- (with-output-to-temp-buffer " *Completions*"
+ (with-output-to-temp-buffer "*Completions*"
(display-completion-list (sort completions 'string-lessp)))
(message "Hit space to flush")
(let (key first)
(if (save-excursion
- (set-buffer (get-buffer " *Completions*"))
+ (set-buffer (get-buffer "*Completions*"))
(setq key (read-key-sequence nil)
first (aref key 0))
- (and (consp first)
+ (and (consp first) (consp (event-start first))
(eq (window-buffer (posn-window (event-start first)))
- (get-buffer " *Completions*"))
+ (get-buffer "*Completions*"))
(eq (key-binding key) 'mouse-choose-completion)))
;; If the user does mouse-choose-completion with the mouse,
;; execute the command, then delete the completion window.
(set-window-configuration conf))
(if (eq first ?\ )
(set-window-configuration conf)
- (setq unread-command-events (append key nil)))))))
+ (setq unread-command-events (listify-key-sequence key)))))))
\f
;;; Converting process modes to use comint mode
;;; ===========================================================================
;;; copy-last-shell-input Use comint-previous-input/comint-next-input
;;;
;;; SHELL-SET-DIRECTORY is gone, its functionality taken over by
-;;; SHELL-DIRECTORY-TRACKER, the shell mode's comint-input-sentinel.
+;;; SHELL-DIRECTORY-TRACKER, the shell mode's comint-input-filter-functions.
;;; Comint mode does not provide functionality equivalent to
;;; shell-set-directory-error-hook; it is gone.
;;;
;;; necessary comint-specific local variables. Then create the
;;; foo-mode-specific local variables in foo-mode. Set the buffer's keymap to
;;; be foo-mode-map, and its mode to be foo-mode. Set the comint-mode hooks
-;;; (comint-prompt-regexp, comint-input-filter, comint-input-sentinel,
-;;; comint-get-old-input) that need to be different from the defaults. Call
+;;; (comint-{prompt-regexp, input-filter, input-filter-functions,
+;;; get-old-input) that need to be different from the defaults. Call
;;; foo-mode-hook, and you're done. Don't run the comint-mode hook yourself;
;;; comint-mode will take care of it. The following example, from shell.el,
;;; is typical:
;;;
;;; (defvar shell-mode-map '())
;;; (cond ((not shell-mode-map)
-;;; (setq shell-mode-map (full-copy-sparse-keymap comint-mode-map))
+;;; (setq shell-mode-map (copy-keymap comint-mode-map))
;;; (define-key shell-mode-map "\C-c\C-f" 'shell-forward-command)
;;; (define-key shell-mode-map "\C-c\C-b" 'shell-backward-command)
;;; (define-key shell-mode-map "\t" 'comint-dynamic-complete)
;;; (use-local-map shell-mode-map)
;;; (make-local-variable 'shell-directory-stack)
;;; (setq shell-directory-stack nil)
-;;; (setq comint-input-sentinel 'shell-directory-tracker)
+;;; (add-hook 'comint-input-filter-functions 'shell-directory-tracker)
;;; (run-hooks 'shell-mode-hook))
;;;
;;;
;;;
;;; Completion for comint-mode users
;;;
-;;; For modes that use comint-mode, comint-after-partial-filename-command
-;;; should be set to a function that returns t if the stub before point is to
-;;; be treated as a filename. By default, if the stub contains a `/', or does
-;;; not follow the prompt, comint-dynamic-complete-filename-command is called.
-;;; Otherwise, comint-dynamic-complete-command-command is called. This should
-;;; also be set to a function that completes whatever the mode calls commands.
+;;; For modes that use comint-mode, comint-dynamic-complete-functions is the
+;;; hook to add completion functions to. Functions on this list should return
+;;; non-nil if completion occurs (i.e., further completion should not occur).
;;; You could use comint-dynamic-simple-complete to do the bulk of the
;;; completion job.
\f
-;;; Do the user's customisation...
-;;;
-;;; Isn't this what eval-after-load is for?
-;;;(defvar comint-load-hook nil
-;;; "This hook is run when comint is loaded in.
-;;;This is a good place to put keybindings.")
-;;;
-;;;(run-hooks 'comint-load-hook)
-
(provide 'comint)
;;; comint.el ends here