;;; 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 <simon@gnu.ai.mit.edu>
;; 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, 675 Mass Ave, Cambridge, MA 02139, USA.
+;; along with GNU Emacs; see the file COPYING. If not, write to the
+;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+;; Boston, MA 02111-1307, USA.
;;; Commentary:
-;;; 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 (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
-;;; modes on top of comint mode -- e.g., lisp, shell, scheme, T, soar, ....
-;;; This way, all these specific packages share a common base functionality,
-;;; and a common set of bindings, which makes them easier to use (and
-;;; saves code, implementation time, etc., etc.).
-
-;;; Several packages are already defined using comint mode:
-;;; - shell.el defines a shell-in-a-buffer mode.
-;;; - cmulisp.el defines a simple lisp-in-a-buffer mode.
-;;;
-;;; - The file cmuscheme.el defines a scheme-in-a-buffer mode.
-;;; - The file tea.el tunes scheme and inferior-scheme modes for T.
-;;; - The file soar.el tunes lisp and inferior-lisp modes for Soar.
-;;; - cmutex.el defines tex and latex modes that invoke tex, latex, bibtex,
-;;; previewers, and printers from within emacs.
-;;; - background.el allows csh-like job control inside emacs.
-;;; It is pretty easy to make new derived modes for other processes.
-
-;;; For documentation on the functionality provided by comint mode, and
-;;; the hooks available for customising it, see the comments below.
-;;; For further information on the standard derived modes (shell,
-;;; inferior-lisp, inferior-scheme, ...), see the relevant source files.
-
-;;; For hints on converting existing process modes (e.g., tex-mode,
-;;; background, dbx, gdb, kermit, prolog, telnet) to use comint-mode
-;;; instead of shell-mode, see the notes at the end of this file.
+;; 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 (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
+;; modes on top of comint mode -- e.g., lisp, shell, scheme, T, soar, ....
+;; This way, all these specific packages share a common base functionality,
+;; and a common set of bindings, which makes them easier to use (and
+;; saves code, implementation time, etc., etc.).
+
+;; Several packages are already defined using comint mode:
+;; - shell.el defines a shell-in-a-buffer mode.
+;; - cmulisp.el defines a simple lisp-in-a-buffer mode.
+;;
+;; - The file cmuscheme.el defines a scheme-in-a-buffer mode.
+;; - The file tea.el tunes scheme and inferior-scheme modes for T.
+;; - The file soar.el tunes lisp and inferior-lisp modes for Soar.
+;; - cmutex.el defines tex and latex modes that invoke tex, latex, bibtex,
+;; previewers, and printers from within emacs.
+;; - background.el allows csh-like job control inside emacs.
+;; It is pretty easy to make new derived modes for other processes.
+
+;; For documentation on the functionality provided by comint mode, and
+;; the hooks available for customising it, see the comments below.
+;; For further information on the standard derived modes (shell,
+;; inferior-lisp, inferior-scheme, ...), see the relevant source files.
+
+;; For hints on converting existing process modes (e.g., tex-mode,
+;; background, dbx, gdb, kermit, prolog, telnet) to use comint-mode
+;; instead of shell-mode, see the notes at the end of this file.
\f
-;;; Brief Command Documentation:
-;;;============================================================================
-;;; Comint Mode Commands: (common to all derived modes, like shell & cmulisp
-;;; mode)
-;;;
-;;; m-p comint-previous-input Cycle backwards in input history
-;;; m-n comint-next-input Cycle forwards
-;;; m-r comint-previous-matching-input Previous input matching a regexp
-;;; 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-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-z comint-stop-subjob ^z
-;;; 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-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-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-replace-by-expanded-history Expand history at point;
-;;; replace with expanded name.
-;;; comint-magic-space Expand history and add (a) space(s).
-;;; comint-kill-subjob No mercy.
-;;; comint-show-maximum-output Show as much output as possible.
-;;; comint-continue-subjob Send CONT signal to buffer's process
-;;; group. Useful if you accidentally
-;;; suspend your process (with C-c C-z).
-
-;;; comint-mode-hook is the comint mode hook. Basically for your keybindings.
+;; Brief Command Documentation:
+;;============================================================================
+;; Comint Mode Commands: (common to all derived modes, like shell & cmulisp
+;; mode)
+;;
+;; m-p comint-previous-input Cycle backwards in input history
+;; m-n comint-next-input Cycle forwards
+;; m-r comint-previous-matching-input Previous input matching a regexp
+;; 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-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-z comint-stop-subjob ^z
+;; 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-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-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-replace-by-expanded-history Expand history at point;
+;; replace with expanded name.
+;; comint-magic-space Expand history and add (a) space(s).
+;; comint-kill-subjob No mercy.
+;; comint-show-maximum-output Show as much output as possible.
+;; comint-continue-subjob Send CONT signal to buffer's process
+;; group. Useful if you accidentally
+;; suspend your process (with C-c C-z).
+
+;; comint-mode-hook is the comint mode hook. Basically for your keybindings.
;;; Code:
(require 'ring)
\f
-;;; Buffer Local Variables:
-;;;============================================================================
-;;; Comint mode buffer local variables:
-;;; comint-prompt-regexp - string comint-bol uses to match prompt
-;;; comint-delimiter-argument-list - list For delimiters and arguments
-;;; comint-last-input-start - marker Handy if inferior always echoes
-;;; comint-last-input-end - marker For comint-kill-output command
-;;; comint-input-ring-size - integer For the input history
-;;; comint-input-ring - ring mechanism
-;;; comint-input-ring-index - number ...
-;;; 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-get-old-input - function Hooks for specific
-;;; 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-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 mode non-buffer local variables:
-;;; comint-completion-addsuffix - boolean For file name completion
-;;; comint-completion-autolist - boolean behavior
-;;; comint-completion-recexact - boolean ...
+;; Buffer Local Variables:
+;;============================================================================
+;; Comint mode buffer local variables:
+;; comint-prompt-regexp - string comint-bol uses to match prompt
+;; comint-delimiter-argument-list - list For delimiters and arguments
+;; comint-last-input-start - marker Handy if inferior always echoes
+;; comint-last-input-end - marker For comint-kill-output command
+;; comint-input-ring-size - integer For the input history
+;; comint-input-ring - ring mechanism
+;; comint-input-ring-index - number ...
+;; 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-input-filter-functions - hook process-in-a-buffer
+;; comint-output-filter-functions - hook function modes.
+;; comint-input-filter - 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 mode non-buffer local variables:
+;; 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.
This variable is buffer-local.")
(defvar comint-password-prompt-regexp
- "\\(^[Pp]assword\\|pass phrase\\):\\s *\\'"
+ "\\(\\([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.
+;; 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.
This function is called when return is typed while the point is in old text.
(defvar comint-ptyp t
"Non-nil if communications via pty; false if by pipe. Buffer local.
-This is to work around a bug in Emacs process signalling.")
+This is to work around a bug in Emacs process signaling.")
(defvar comint-input-ring nil)
(defvar comint-last-input-start)
(make-local-variable 'comint-input-autoexpand)
(make-local-variable 'comint-input-ignoredups)
(make-local-variable 'comint-delimiter-argument-list)
- (make-local-variable 'comint-dynamic-complete-functions)
+ (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-filter-functions)
+ (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
(let ((proc (get-buffer-process buffer)))
(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).
+;; Note that this guy, unlike shell.el's make-shell, barfs if you pass it ()
+;; for the second argument (program).
;;;###autoload
(defun make-comint (name program &optional startfile &rest switches)
"Make a comint process NAME in a buffer, running PROGRAM.
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.
(run-hooks 'comint-exec-hook)
buffer)))
-;;; This auxiliary function cranks up the process for comint-exec in
-;;; the appropriate environment.
+;; This auxiliary function cranks up the process for comint-exec in
+;; the appropriate environment.
(defun comint-exec-1 (name buffer command switches)
(let ((process-environment
;; 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 "EMACS=t" "TERM=unknown"
+ (list "TERM=unknown"
(format "COLUMNS=%d" (frame-width)))
- (list "EMACS=t" "TERM=emacs"
+ (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)
"/")))
(apply 'start-process name buffer command switches)))
\f
-;;; Input history processing in a buffer
-;;; ===========================================================================
-;;; Useful input history functions, courtesy of the Ergo group.
-
-;;; Eleven commands:
-;;; comint-dynamic-list-input-ring List history in help buffer.
-;;; comint-previous-input Previous input...
-;;; comint-previous-matching-input ...matching a string.
-;;; comint-previous-matching-input-from-input ... matching the current input.
-;;; comint-next-input Next input...
-;;; comint-next-matching-input ...matching a string.
-;;; comint-next-matching-input-from-input ... matching the current input.
-;;; comint-backward-matching-input Backwards input...
-;;; comint-forward-matching-input ...matching a string.
-;;; comint-replace-by-expanded-history Expand history at point;
-;;; replace with expanded history.
-;;; comint-magic-space Expand history and insert space.
-;;;
-;;; 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.
+;; Input history processing in a buffer
+;; ===========================================================================
+;; Useful input history functions, courtesy of the Ergo group.
+
+;; Eleven commands:
+;; comint-dynamic-list-input-ring List history in help buffer.
+;; comint-previous-input Previous input...
+;; comint-previous-matching-input ...matching a string.
+;; comint-previous-matching-input-from-input ... matching the current input.
+;; comint-next-input Next input...
+;; comint-next-matching-input ...matching a string.
+;; comint-next-matching-input-from-input ... matching the current input.
+;; comint-backward-matching-input Backwards input...
+;; comint-forward-matching-input ...matching a string.
+;; comint-replace-by-expanded-history Expand history at point;
+;; replace with expanded history.
+;; comint-magic-space Expand history and insert space.
+;;
+;; 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.
(mapconcat
(function (lambda (a) a)) (nthcdr n (nreverse (nthcdr m args))) " "))))
\f
-;;;
-;;; Input processing stuff
-;;;
+;;
+;; Input processing stuff
+;;
(defun comint-send-input ()
"Send input to process.
(not (string-equal (ring-ref comint-input-ring 0)
history))))
(ring-insert comint-input-ring history))
- (let ((functions comint-input-filter-functions))
- (while functions
- (funcall (car functions) (concat input "\n"))
- (setq functions (cdr functions))))
+ (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.
(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 ()
(beginning-of-line)
(if (null arg) (comint-skip-prompt)))
-;;; 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, or add
-;;; `comint-watch-for-password-prompt' to `comint-output-filter-functions'.
+;; 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, 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.
;; 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 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
(defun send-invisible (str)
"Read a string without echoing.
-Then send it to the process running in the current buffer. A new-line
-is additionally sent. String is not saved on comint input history list.
+Then send it to the process running in the current buffer.
+The string is sent using `comint-input-sender'.
Security bug: your string can still be temporarily recovered with
\\[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"))))
+ (funcall comint-input-sender proc
+ (if (stringp str) str (comint-read-noecho "Non-echoed text: " t))))))
(defun comint-watch-for-password-prompt (string)
"Prompt in the minibuffer for password and send without echoing.
(if (string-match comint-password-prompt-regexp string)
(send-invisible nil)))
\f
-;;; Low-level process communication
+;; Low-level process communication
(defalias 'comint-send-string 'process-send-string)
(defalias 'comint-send-region 'process-send-region)
\f
-;;; Random input hackage
+;; Random input hackage
(defun comint-kill-output ()
"Kill all output from interpreter since last input.
(beginning-of-line nil)
(point-marker))))
(delete-region comint-last-input-end pmark)
- (comint-skip-prompt)
+ (goto-char (process-mark proc))
(setq replacement (concat "*** output flushed ***\n"
(buffer-substring pmark (point))))
(delete-region pmark (point))))
(interactive "p")
(comint-next-prompt (- n)))
\f
-;;; Support for source-file processing commands.
-;;;============================================================================
-;;; Many command-interpreters (e.g., Lisp, Scheme, Soar) have
-;;; commands that process files of source text (e.g. loading or compiling
-;;; files). So the corresponding process-in-a-buffer modes have commands
-;;; for doing this (e.g., lisp-load-file). The functions below are useful
-;;; for defining these commands.
-;;;
-;;; Alas, these guys don't do exactly the right thing for Lisp, Scheme
-;;; and Soar, in that they don't know anything about file extensions.
-;;; So the compile/load interface gets the wrong default occasionally.
-;;; The load-file/compile-file default mechanism could be smarter -- it
-;;; doesn't know about the relationship between filename extensions and
-;;; whether the file is source or executable. If you compile foo.lisp
-;;; with compile-file, then the next load-file should use foo.bin for
-;;; the default, not foo.lisp. This is tricky to do right, particularly
-;;; because the extension for executable files varies so much (.o, .bin,
-;;; .lbin, .mo, .vo, .ao, ...).
-
-
-;;; COMINT-SOURCE-DEFAULT -- determines defaults for source-file processing
-;;; commands.
-;;;
-;;; COMINT-CHECK-SOURCE -- if FNAME is in a modified buffer, asks you if you
-;;; want to save the buffer before issuing any process requests to the command
-;;; interpreter.
-;;;
-;;; COMINT-GET-SOURCE -- used by the source-file processing commands to prompt
-;;; for the file to process.
-
-;;; (COMINT-SOURCE-DEFAULT previous-dir/file source-modes)
-;;;============================================================================
-;;; This function computes the defaults for the load-file and compile-file
-;;; commands for tea, soar, cmulisp, and cmuscheme modes.
-;;;
-;;; - PREVIOUS-DIR/FILE is a pair (directory . filename) from the last
-;;; source-file processing command. NIL if there hasn't been one yet.
-;;; - SOURCE-MODES is a list used to determine what buffers contain source
-;;; files: if the major mode of the buffer is in SOURCE-MODES, it's source.
-;;; Typically, (lisp-mode) or (scheme-mode).
-;;;
-;;; If the command is given while the cursor is inside a string, *and*
-;;; the string is an existing filename, *and* the filename is not a directory,
-;;; then the string is taken as default. This allows you to just position
-;;; your cursor over a string that's a filename and have it taken as default.
-;;;
-;;; If the command is given in a file buffer whose major mode is in
-;;; SOURCE-MODES, then the the filename is the default file, and the
-;;; file's directory is the default directory.
-;;;
-;;; If the buffer isn't a source file buffer (e.g., it's the process buffer),
-;;; then the default directory & file are what was used in the last source-file
-;;; processing command (i.e., PREVIOUS-DIR/FILE). If this is the first time
-;;; the command has been run (PREVIOUS-DIR/FILE is nil), the default directory
-;;; is the cwd, with no default file. (\"no default file\" = nil)
-;;;
-;;; SOURCE-REGEXP is typically going to be something like (tea-mode)
-;;; for T programs, (lisp-mode) for Lisp programs, (soar-mode lisp-mode)
-;;; for Soar programs, etc.
-;;;
-;;; The function returns a pair: (default-directory . default-file).
+;; Support for source-file processing commands.
+;;============================================================================
+;; Many command-interpreters (e.g., Lisp, Scheme, Soar) have
+;; commands that process files of source text (e.g. loading or compiling
+;; files). So the corresponding process-in-a-buffer modes have commands
+;; for doing this (e.g., lisp-load-file). The functions below are useful
+;; for defining these commands.
+;;
+;; Alas, these guys don't do exactly the right thing for Lisp, Scheme
+;; and Soar, in that they don't know anything about file extensions.
+;; So the compile/load interface gets the wrong default occasionally.
+;; The load-file/compile-file default mechanism could be smarter -- it
+;; doesn't know about the relationship between filename extensions and
+;; whether the file is source or executable. If you compile foo.lisp
+;; with compile-file, then the next load-file should use foo.bin for
+;; the default, not foo.lisp. This is tricky to do right, particularly
+;; because the extension for executable files varies so much (.o, .bin,
+;; .lbin, .mo, .vo, .ao, ...).
+
+
+;; COMINT-SOURCE-DEFAULT -- determines defaults for source-file processing
+;; commands.
+;;
+;; COMINT-CHECK-SOURCE -- if FNAME is in a modified buffer, asks you if you
+;; want to save the buffer before issuing any process requests to the command
+;; interpreter.
+;;
+;; COMINT-GET-SOURCE -- used by the source-file processing commands to prompt
+;; for the file to process.
+
+;; (COMINT-SOURCE-DEFAULT previous-dir/file source-modes)
+;;============================================================================
+;; This function computes the defaults for the load-file and compile-file
+;; commands for tea, soar, cmulisp, and cmuscheme modes.
+;;
+;; - PREVIOUS-DIR/FILE is a pair (directory . filename) from the last
+;; source-file processing command. NIL if there hasn't been one yet.
+;; - SOURCE-MODES is a list used to determine what buffers contain source
+;; files: if the major mode of the buffer is in SOURCE-MODES, it's source.
+;; Typically, (lisp-mode) or (scheme-mode).
+;;
+;; If the command is given while the cursor is inside a string, *and*
+;; the string is an existing filename, *and* the filename is not a directory,
+;; then the string is taken as default. This allows you to just position
+;; your cursor over a string that's a filename and have it taken as default.
+;;
+;; If the command is given in a file buffer whose major mode is in
+;; SOURCE-MODES, then the the filename is the default file, and the
+;; file's directory is the default directory.
+;;
+;; If the buffer isn't a source file buffer (e.g., it's the process buffer),
+;; then the default directory & file are what was used in the last source-file
+;; processing command (i.e., PREVIOUS-DIR/FILE). If this is the first time
+;; the command has been run (PREVIOUS-DIR/FILE is nil), the default directory
+;; is the cwd, with no default file. (\"no default file\" = nil)
+;;
+;; SOURCE-REGEXP is typically going to be something like (tea-mode)
+;; for T programs, (lisp-mode) for Lisp programs, (soar-mode lisp-mode)
+;; for Soar programs, etc.
+;;
+;; The function returns a pair: (default-directory . default-file).
(defun comint-source-default (previous-dir/file source-modes)
(cond ((and buffer-file-name (memq major-mode source-modes))
(cons default-directory nil))))
-;;; (COMINT-CHECK-SOURCE fname)
-;;;============================================================================
-;;; Prior to loading or compiling (or otherwise processing) a file (in the CMU
-;;; process-in-a-buffer modes), this function can be called on the filename.
-;;; If the file is loaded into a buffer, and the buffer is modified, the user
-;;; is queried to see if he wants to save the buffer before proceeding with
-;;; the load or compile.
+;; (COMINT-CHECK-SOURCE fname)
+;;============================================================================
+;; Prior to loading or compiling (or otherwise processing) a file (in the CMU
+;; process-in-a-buffer modes), this function can be called on the filename.
+;; If the file is loaded into a buffer, and the buffer is modified, the user
+;; is queried to see if he wants to save the buffer before proceeding with
+;; the load or compile.
(defun comint-check-source (fname)
(let ((buff (get-file-buffer fname)))
(set-buffer old-buffer)))))
-;;; (COMINT-GET-SOURCE prompt prev-dir/file source-modes mustmatch-p)
-;;;============================================================================
-;;; COMINT-GET-SOURCE is used to prompt for filenames in command-interpreter
-;;; commands that process source files (like loading or compiling a file).
-;;; It prompts for the filename, provides a default, if there is one,
-;;; and returns the result filename.
-;;;
-;;; See COMINT-SOURCE-DEFAULT for more on determining defaults.
-;;;
-;;; PROMPT is the prompt string. PREV-DIR/FILE is the (directory . file) pair
-;;; from the last source processing command. SOURCE-MODES is a list of major
-;;; modes used to determine what file buffers contain source files. (These
-;;; two arguments are used for determining defaults). If MUSTMATCH-P is true,
-;;; then the filename reader will only accept a file that exists.
-;;;
-;;; A typical use:
-;;; (interactive (comint-get-source "Compile file: " prev-lisp-dir/file
-;;; '(lisp-mode) t))
-
-;;; This is pretty stupid about strings. It decides we're in a string
-;;; if there's a quote on both sides of point on the current line.
+;; (COMINT-GET-SOURCE prompt prev-dir/file source-modes mustmatch-p)
+;;============================================================================
+;; COMINT-GET-SOURCE is used to prompt for filenames in command-interpreter
+;; commands that process source files (like loading or compiling a file).
+;; It prompts for the filename, provides a default, if there is one,
+;; and returns the result filename.
+;;
+;; See COMINT-SOURCE-DEFAULT for more on determining defaults.
+;;
+;; PROMPT is the prompt string. PREV-DIR/FILE is the (directory . file) pair
+;; from the last source processing command. SOURCE-MODES is a list of major
+;; modes used to determine what file buffers contain source files. (These
+;; two arguments are used for determining defaults). If MUSTMATCH-P is true,
+;; then the filename reader will only accept a file that exists.
+;;
+;; A typical use:
+;; (interactive (comint-get-source "Compile file: " prev-lisp-dir/file
+;; '(lisp-mode) t))
+
+;; This is pretty stupid about strings. It decides we're in a string
+;; if there's a quote on both sides of point on the current line.
(defun comint-extract-string ()
"Return string around POINT that starts the current line, or nil."
(save-excursion
mustmatch-p)))
(list (expand-file-name (substitute-in-file-name ans)))))
-;;; I am somewhat divided on this string-default feature. It seems
-;;; to violate the principle-of-least-astonishment, in that it makes
-;;; the default harder to predict, so you actually have to look and see
-;;; what the default really is before choosing it. This can trip you up.
-;;; On the other hand, it can be useful, I guess. I would appreciate feedback
-;;; on this.
-;;; -Olin
+;; I am somewhat divided on this string-default feature. It seems
+;; to violate the principle-of-least-astonishment, in that it makes
+;; the default harder to predict, so you actually have to look and see
+;; what the default really is before choosing it. This can trip you up.
+;; On the other hand, it can be useful, I guess. I would appreciate feedback
+;; on this.
+;; -Olin
\f
-;;; Simple process query facility.
-;;; ===========================================================================
-;;; This function is for commands that want to send a query to the process
-;;; and show the response to the user. For example, a command to get the
-;;; arglist for a Common Lisp function might send a "(arglist 'foo)" query
-;;; to an inferior Common Lisp process.
-;;;
-;;; This simple facility just sends strings to the inferior process and pops
-;;; up a window for the process buffer so you can see what the process
-;;; responds with. We don't do anything fancy like try to intercept what the
-;;; process responds with and put it in a pop-up window or on the message
-;;; line. We just display the buffer. Low tech. Simple. Works good.
-
-;;; Send to the inferior process PROC the string STR. Pop-up but do not select
-;;; a window for the inferior process so that its response can be seen.
+;; Simple process query facility.
+;; ===========================================================================
+;; This function is for commands that want to send a query to the process
+;; and show the response to the user. For example, a command to get the
+;; arglist for a Common Lisp function might send a "(arglist 'foo)" query
+;; to an inferior Common Lisp process.
+;;
+;; This simple facility just sends strings to the inferior process and pops
+;; up a window for the process buffer so you can see what the process
+;; responds with. We don't do anything fancy like try to intercept what the
+;; process responds with and put it in a pop-up window or on the message
+;; line. We just display the buffer. Low tech. Simple. Works good.
+
+;; Send to the inferior process PROC the string STR. Pop-up but do not select
+;; a window for the inferior process so that its response can be seen.
(defun comint-proc-query (proc str)
(let* ((proc-buf (process-buffer proc))
(proc-mark (process-mark proc)))
(set-window-point proc-win opoint)))))))
\f
-;;; Filename/command/history completion in a buffer
-;;; ===========================================================================
-;;; Useful completion functions, courtesy of the Ergo group.
-
-;;; Six commands:
-;;; comint-dynamic-complete Complete or expand command, filename,
-;;; history at point.
-;;; comint-dynamic-complete-filename Complete filename 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.
-
-;;; 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)
-;;; (define-key shell-mode-map "\M-?"
-;;; 'comint-dynamic-list-filename-completions)))
-;;;
-;;; Commands like this are fine things to put in load hooks if you
-;;; want them present in specific modes.
+;; Filename/command/history completion in a buffer
+;; ===========================================================================
+;; Useful completion functions, courtesy of the Ergo group.
+
+;; Six commands:
+;; comint-dynamic-complete Complete or expand command, filename,
+;; history at point.
+;; comint-dynamic-complete-filename Complete filename 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.
+
+;; 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)
+;; (define-key shell-mode-map "\M-?"
+;; 'comint-dynamic-list-filename-completions)))
+;;
+;; Commands like this are fine things to put in load hooks if you
+;; want them present in specific modes.
(defvar comint-completion-autolist nil
- "*If non-nil, automatically list possiblities on partial completion.
+ "*If non-nil, automatically list possibilities on partial completion.
This mirrors the optional behavior of tcsh.")
(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
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.
Word constituents are considered to be those in WORD-CHARS, which is like the
inside of a \"[...]\" (see `skip-chars-forward')."
(save-excursion
- (let ((limit (point))
- (word (concat "[" word-chars "]"))
- (non-word (concat "[^" word-chars "]")))
- (if (re-search-backward non-word nil 'move)
+ (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))
- ;; Anchor the search forwards.
- (if (or (eolp) (looking-at non-word))
- nil
- (re-search-forward (concat word "+") limit)
- (buffer-substring (match-beginning 0) (match-end 0))))))
+ ;; 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-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 filename))))
+ (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-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 ()
completion until a function returns non-nil, at which point completion is
assumed to have occurred."
(interactive)
- (let ((functions comint-dynamic-complete-functions))
- (while (and functions (null (funcall (car functions))))
- (setq functions (cdr functions)))))
+ (run-hook-with-args-until-success 'comint-dynamic-complete-functions))
(defun comint-dynamic-complete-filename ()
(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))
(message "No completions of %s" filename)
(setq success nil))
((eq completion t) ; Means already completed "file".
- (if comint-completion-addsuffix (insert " "))
+ (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)))
- (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) "/" " ")))
+ (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) "/" " "))
+ (insert (if (file-directory-p file) dirsuffix filesuffix))
(or minibuffer-p (message "Completed shortest")))
((or comint-completion-autolist
(string-equal pathnondir completion))
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 "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)))
(string-equal stub completion)
(member completion completions))
;; It's not unique, but user wants shortest match.
- (insert " ")
+ (insert suffix)
(message "Completed shortest")
'shortest)
((or comint-completion-autolist
(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))))
+ (if (not completions)
+ (message "No completions of %s" filename)
+ (comint-dynamic-list-completions
+ (mapcar 'comint-quote-filename completions)))))
(defun comint-dynamic-list-completions (completions)
(set-window-configuration conf)
(setq unread-command-events (listify-key-sequence key)))))))
\f
-;;; Converting process modes to use comint mode
-;;; ===========================================================================
-;;; The code in the Emacs 19 distribution has all been modified to use comint
-;;; where needed. However, there are `third-party' packages out there that
-;;; still use the old shell mode. Here's a guide to conversion.
-;;;
-;;; Renaming variables
-;;; Most of the work is renaming variables and functions. These are the common
-;;; ones:
-;;; Local variables:
-;;; last-input-start comint-last-input-start
-;;; last-input-end comint-last-input-end
-;;; shell-prompt-pattern comint-prompt-regexp
-;;; shell-set-directory-error-hook <no equivalent>
-;;; Miscellaneous:
-;;; shell-set-directory <unnecessary>
-;;; shell-mode-map comint-mode-map
-;;; Commands:
-;;; shell-send-input comint-send-input
-;;; shell-send-eof comint-delchar-or-maybe-eof
-;;; kill-shell-input comint-kill-input
-;;; interrupt-shell-subjob comint-interrupt-subjob
-;;; stop-shell-subjob comint-stop-subjob
-;;; quit-shell-subjob comint-quit-subjob
-;;; kill-shell-subjob comint-kill-subjob
-;;; kill-output-from-shell comint-kill-output
-;;; show-output-from-shell comint-show-output
-;;; 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-filter-functions.
-;;; Comint mode does not provide functionality equivalent to
-;;; shell-set-directory-error-hook; it is gone.
-;;;
-;;; comint-last-input-start is provided for modes which want to munge
-;;; the buffer after input is sent, perhaps because the inferior
-;;; insists on echoing the input. The LAST-INPUT-START variable in
-;;; the old shell package was used to implement a history mechanism,
-;;; but you should think twice before using comint-last-input-start
-;;; for this; the input history ring often does the job better.
-;;;
-;;; If you are implementing some process-in-a-buffer mode, called foo-mode, do
-;;; *not* create the comint-mode local variables in your foo-mode function.
-;;; This is not modular. Instead, call comint-mode, and let *it* create the
-;;; 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, 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 (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)
-;;; (define-key shell-mode-map "\M-?"
-;;; 'comint-dynamic-list-filename-completions)))
-;;;
-;;; (defun shell-mode ()
-;;; (interactive)
-;;; (comint-mode)
-;;; (setq comint-prompt-regexp shell-prompt-pattern)
-;;; (setq major-mode 'shell-mode)
-;;; (setq mode-name "Shell")
-;;; (use-local-map shell-mode-map)
-;;; (make-local-variable 'shell-directory-stack)
-;;; (setq shell-directory-stack nil)
-;;; (add-hook 'comint-input-filter-functions 'shell-directory-tracker)
-;;; (run-hooks 'shell-mode-hook))
-;;;
-;;;
-;;; Note that make-comint is different from make-shell in that it
-;;; doesn't have a default program argument. If you give make-shell
-;;; a program name of NIL, it cleverly chooses one of explicit-shell-name,
-;;; $ESHELL, $SHELL, or /bin/sh. If you give make-comint a program argument
-;;; of NIL, it barfs. Adjust your code accordingly...
-;;;
-;;; Completion for comint-mode users
-;;;
-;;; 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.
+;; Converting process modes to use comint mode
+;; ===========================================================================
+;; The code in the Emacs 19 distribution has all been modified to use comint
+;; where needed. However, there are `third-party' packages out there that
+;; still use the old shell mode. Here's a guide to conversion.
+;;
+;; Renaming variables
+;; Most of the work is renaming variables and functions. These are the common
+;; ones:
+;; Local variables:
+;; last-input-start comint-last-input-start
+;; last-input-end comint-last-input-end
+;; shell-prompt-pattern comint-prompt-regexp
+;; shell-set-directory-error-hook <no equivalent>
+;; Miscellaneous:
+;; shell-set-directory <unnecessary>
+;; shell-mode-map comint-mode-map
+;; Commands:
+;; shell-send-input comint-send-input
+;; shell-send-eof comint-delchar-or-maybe-eof
+;; kill-shell-input comint-kill-input
+;; interrupt-shell-subjob comint-interrupt-subjob
+;; stop-shell-subjob comint-stop-subjob
+;; quit-shell-subjob comint-quit-subjob
+;; kill-shell-subjob comint-kill-subjob
+;; kill-output-from-shell comint-kill-output
+;; show-output-from-shell comint-show-output
+;; 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-filter-functions.
+;; Comint mode does not provide functionality equivalent to
+;; shell-set-directory-error-hook; it is gone.
+;;
+;; comint-last-input-start is provided for modes which want to munge
+;; the buffer after input is sent, perhaps because the inferior
+;; insists on echoing the input. The LAST-INPUT-START variable in
+;; the old shell package was used to implement a history mechanism,
+;; but you should think twice before using comint-last-input-start
+;; for this; the input history ring often does the job better.
+;;
+;; If you are implementing some process-in-a-buffer mode, called foo-mode, do
+;; *not* create the comint-mode local variables in your foo-mode function.
+;; This is not modular. Instead, call comint-mode, and let *it* create the
+;; 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, 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 (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)
+;; (define-key shell-mode-map "\M-?"
+;; 'comint-dynamic-list-filename-completions)))
+;;
+;; (defun shell-mode ()
+;; (interactive)
+;; (comint-mode)
+;; (setq comint-prompt-regexp shell-prompt-pattern)
+;; (setq major-mode 'shell-mode)
+;; (setq mode-name "Shell")
+;; (use-local-map shell-mode-map)
+;; (make-local-variable 'shell-directory-stack)
+;; (setq shell-directory-stack nil)
+;; (add-hook 'comint-input-filter-functions 'shell-directory-tracker)
+;; (run-hooks 'shell-mode-hook))
+;;
+;;
+;; Note that make-comint is different from make-shell in that it
+;; doesn't have a default program argument. If you give make-shell
+;; a program name of NIL, it cleverly chooses one of explicit-shell-name,
+;; $ESHELL, $SHELL, or /bin/sh. If you give make-comint a program argument
+;; of NIL, it barfs. Adjust your code accordingly...
+;;
+;; Completion for comint-mode users
+;;
+;; 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
(provide 'comint)
-;;; comint.el ends here
+;; comint.el ends here
HCoop / bpt / emacs.git / blobdiff