| blob | de887926f046943ad7d3eb04e2ec942dcd375b74 |
1 ;;; comint.el --- general command interpreter in a window stuff
3 ;; Copyright (C) 1988, 1990, 1992, 1993 Free Software Foundation, Inc.
5 ;; Author: Olin Shivers <shivers@cs.cmu.edu>
6 ;; Keywords: processes
8 ;; This file is part of GNU Emacs.
10 ;; GNU Emacs is free software; you can redistribute it and/or modify
11 ;; it under the terms of the GNU General Public License as published by
12 ;; the Free Software Foundation; either version 2, or (at your option)
13 ;; any later version.
15 ;; GNU Emacs is distributed in the hope that it will be useful,
16 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
17 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 ;; GNU General Public License for more details.
20 ;; You should have received a copy of the GNU General Public License
21 ;; along with GNU Emacs; see the file COPYING. If not, write to
22 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
24 ;;; Commentary:
26 ;;; The changelog is at the end of this file.
28 ;;; Please send me bug reports, bug fixes, and extensions, so that I can
29 ;;; merge them into the master source.
30 ;;; - Olin Shivers (shivers@cs.cmu.edu)
32 ;;; This file defines a general command-interpreter-in-a-buffer package
33 ;;; (comint mode). The idea is that you can build specific process-in-a-buffer
34 ;;; modes on top of comint mode -- e.g., lisp, shell, scheme, T, soar, ....
35 ;;; This way, all these specific packages share a common base functionality,
36 ;;; and a common set of bindings, which makes them easier to use (and
37 ;;; saves code, implementation time, etc., etc.).
39 ;;; Several packages are already defined using comint mode:
40 ;;; - cmushell.el defines a shell-in-a-buffer mode.
41 ;;; - cmulisp.el defines a simple lisp-in-a-buffer mode.
42 ;;; Cmushell and cmulisp mode are similar to, and intended to replace,
43 ;;; their counterparts in the standard gnu emacs release (in shell.el).
44 ;;; These replacements are more featureful, robust, and uniform than the
45 ;;; released versions. The key bindings in lisp mode are also more compatible
46 ;;; with the bindings of Hemlock and Zwei (the Lisp Machine emacs).
47 ;;;
48 ;;; - The file cmuscheme.el defines a scheme-in-a-buffer mode.
49 ;;; - The file tea.el tunes scheme and inferior-scheme modes for T.
50 ;;; - The file soar.el tunes lisp and inferior-lisp modes for Soar.
51 ;;; - cmutex.el defines tex and latex modes that invoke tex, latex, bibtex,
52 ;;; previewers, and printers from within emacs.
53 ;;; - background.el allows csh-like job control inside emacs.
54 ;;; It is pretty easy to make new derived modes for other processes.
56 ;;; For documentation on the functionality provided by comint mode, and
57 ;;; the hooks available for customising it, see the comments below.
58 ;;; For further information on the standard derived modes (shell,
59 ;;; inferior-lisp, inferior-scheme, ...), see the relevant source files.
61 ;;; For hints on converting existing process modes (e.g., tex-mode,
62 ;;; background, dbx, gdb, kermit, prolog, telnet) to use comint-mode
63 ;;; instead of shell-mode, see the notes at the end of this file.
65 \f
66 ;;; Brief Command Documentation:
67 ;;;============================================================================
68 ;;; Comint Mode Commands: (common to all derived modes, like cmushell & cmulisp
69 ;;; mode)
70 ;;;
71 ;;; m-p comint-previous-input Cycle backwards in input history
72 ;;; m-n comint-next-input Cycle forwards
73 ;;; m-r comint-previous-similar-input Previous similar input
74 ;;; m-s comint-next-similar-input Next similar input
75 ;;; c-m-r comint-previous-input-matching Search backwards in input history
76 ;;; return comint-send-input
77 ;;; c-a comint-bol Beginning of line; skip prompt.
78 ;;; c-d comint-delchar-or-maybe-eof Delete char unless at end of buff.
79 ;;; c-c c-u comint-kill-input ^u
80 ;;; c-c c-w backward-kill-word ^w
81 ;;; c-c c-c comint-interrupt-subjob ^c
82 ;;; c-c c-z comint-stop-subjob ^z
83 ;;; c-c c-\ comint-quit-subjob ^\
84 ;;; c-c c-o comint-kill-output Delete last batch of process output
85 ;;; c-c c-r comint-show-output Show last batch of process output
86 ;;;
87 ;;; Not bound by default in comint-mode
88 ;;; send-invisible Read a line w/o echo, and send to proc
89 ;;; (These are bound in shell-mode)
90 ;;; comint-dynamic-complete Complete filename at point.
91 ;;; comint-dynamic-list-completions List completions in help buffer.
92 ;;; comint-replace-by-expanded-filename Expand and complete filename at point;
93 ;;; replace with expanded/completed name.
94 ;;; comint-kill-subjob No mercy.
95 ;;; comint-continue-subjob Send CONT signal to buffer's process
96 ;;; group. Useful if you accidentally
97 ;;; suspend your process (with C-c C-z).
98 ;;;
99 ;;; These used to be bound for RMS -- I prefer the input history stuff,
100 ;;; but you might like 'em.
101 ;;; m-P comint-msearch-input Search backwards for prompt
102 ;;; m-N comint-psearch-input Search forwards for prompt
103 ;;; C-cR comint-msearch-input-matching Search backwards for prompt & string
105 ;;; comint-mode-hook is the comint mode hook. Basically for your keybindings.
106 ;;; comint-load-hook is run after loading in this package.
108 ;;; Code:
113 \f
114 ;;; Buffer Local Variables:
115 ;;;============================================================================
116 ;;; Comint mode buffer local variables:
117 ;;; comint-prompt-regexp - string comint-bol uses to match prompt.
118 ;;; comint-last-input-start - marker Handy if inferior always echos
119 ;;; comint-last-input-end - marker For comint-kill-output command
120 ;;; comint-input-ring-size - integer For the input history
121 ;;; comint-input-ring - ring mechanism
122 ;;; comint-input-ring-index - marker ...
123 ;;; comint-last-input-match - string ...
124 ;;; comint-get-old-input - function Hooks for specific
125 ;;; comint-input-sentinel - function process-in-a-buffer
126 ;;; comint-input-filter - function modes.
127 ;;; comint-input-send - function
128 ;;; comint-eol-on-send - boolean
131 "Regexp to recognise prompts in the inferior process.
134 Good choices:
147 ;;; Here are the per-interpreter hooks.
149 "Function that submits old text in comint mode.
150 This function is called when return is typed while the point is in old text.
151 It returns the text to be submitted as process input. The default is
152 comint-get-old-input-default, which grabs the current line, and strips off
156 "Called on each input submitted to comint mode process by comint-send-input.
161 "Predicate for filtering additions to input history.
162 Only inputs answering true to this function are saved on the input
166 "Function to actually send to PROCESS the STRING submitted by user.
167 Usually this is just 'comint-simple-send, but if your mode needs to
168 massage the input string, this is your hook. This is called from
169 the user command comint-send-input. comint-simple-send just sends
173 "If non-nil, then jump to the end of the line before sending input to process.
177 "Called upon entry into comint-mode
181 "Called each time a process is exec'd by comint-exec.
182 This is called after the process is cranked up. It is useful for things that
183 must be done each time a process is executed in a comint-mode buffer (e.g.,
184 (process-kill-without-query)). In contrast, the comint-mode-hook is only
190 "True if communications via pty; false if by pipe. Buffer local.
194 "Last string searched for by comint input history search, for defaulting.
205 "Major mode for interacting with an inferior interpreter.
206 Interpreter name is same as buffer name, sans the asterisks.
207 Return at end of buffer sends line as input.
208 Return not at end copies rest of line to end and sends it.
209 Setting mode variable comint-eol-on-send means jump to the end of the line
210 before submitting new input.
212 This mode is typically customised to create inferior-lisp-mode,
213 shell-mode, etc.. This can be done by setting the hooks
214 comint-input-sentinel, comint-input-filter, comint-input-sender and
215 comint-get-old-input to appropriate functions, and the variable
216 comint-prompt-regexp to the appropriate regular expression.
218 An input history is maintained of size comint-input-ring-size, and
221 default are send-invisible, comint-dynamic-complete, and
222 comint-list-dynamic-completions.
225 to continue it.
229 Entry to this mode runs the hooks on comint-mode-hook"
231 ;; Do not remove this. All major modes must do this.
260 nil
277 ;;; prompt-search commands commented out 3/90 -Olin
278 ; (define-key comint-mode-map "\eP" 'comint-msearch-input)
279 ; (define-key comint-mode-map "\eN" 'comint-psearch-input)
280 ; (define-key comint-mode-map "\C-cR" 'comint-msearch-input-matching)
281 )
284 ;;; This function is used to make a full copy of the comint mode map,
285 ;;; so that client modes won't interfere with each other. This function
286 ;;; isn't necessary in emacs 18.5x, but we keep it around for 18.4x versions.
288 "Recursively copy the sparse keymap KM"
295 "True if there is a process associated w/buffer BUFFER, and
296 it is alive (status RUN or STOP). BUFFER can be either a buffer or the
297 name of one"
301 ;;; Note that this guy, unlike shell.el's make-shell, barfs if you pass it ()
302 ;;; for the second argument (program).
303 ;;;###autoload
305 "Make a comint process NAME in a buffer, running PROGRAM.
306 The name of the buffer is made by surrounding NAME with `*'s.
307 If there is already a running process in that buffer, it is not restarted.
308 Optional third arg STARTFILE is the name of a file to send the contents of to
309 the process. Any more args are arguments to PROGRAM."
311 ;; If no process, or nuked process, crank up a new one and put buffer in
312 ;; comint mode. Otherwise, leave buffer and existing process alone.
318 buffer))
321 "Fires up a process in buffer for comint modes.
322 Blasts any old process running in the buffer. Doesn't set the buffer mode.
323 You can use this to cheaply run a series of processes in the same comint
324 buffer. The hook comint-exec-hook is run after each exec."
329 ;; Crank up a new process
333 ;; Jump to the end, and set the process mark.
336 ;; Feed it the startfile.
338 ;;This is guaranteed to wait long enough
339 ;;but has bad results if the comint does not prompt at all
340 ;; (while (= size (buffer-size))
341 ;; (sleep-for 1))
342 ;;I hope 1 second is enough!
350 buffer)))
352 ;;; This auxiliary function cranks up the process for comint-exec in
353 ;;; the appropriate environment.
360 "TERM=emacs"
366 ;; This is just (append new old-env) that compresses out shadowed entries.
367 ;; It's also pretty ugly, mostly due to lisp's horrible iteration structures.
373 new)))
384 ;;; This should be in emacs, but it isn't.
386 "Test to see if ITEM is equal to an item in LIST.
387 Option comparison function ELT= defaults to equal."
394 done))
396 \f
397 ;;; Input history retrieval commands
398 ;;; M-p -- previous input M-n -- next input
399 ;;; M-C-r -- previous input matching
400 ;;; ===========================================================================
403 "Cycle backwards through input history."
415 ;; Initialize the index on the first use of this command
416 ;; so that the first M-p gets index 0, and the first M-n gets
417 ;; index -1.
428 "Returns N mod M. M is positive.
429 Answer is guaranteed to be non-negative, and less than m."
432 (+ n
436 "Cycle forwards through input history."
441 "Searches backwards through input history for substring match."
445 comint-last-input-match))))
447 ; (interactive "sCommand substring: ")
461 ;;; These next three commands are alternatives to the input history commands
462 ;;; -- comint-next-input, comint-previous-input and
463 ;;; comint-previous-input-matching. They search through the process buffer
464 ;;; text looking for occurrences of the prompt. Bound to M-P, M-N, and C-c R
465 ;;; (uppercase P, N, and R) for now. Try'em out. Go with what you like...
467 ;;; comint-msearch-input-matching prompts for a string, not a regexp.
468 ;;; This could be considered to be the wrong thing. I decided to keep it
469 ;;; simple, and not make the user worry about regexps. This, of course,
470 ;;; limits functionality.
472 ;;; These commands were deemed non-winning and have been commented out.
473 ;;; Feel free to re-enable them if you like. -Olin 3/91
475 ;(defun comint-psearch-input ()
476 ; "Search forwards for next occurrence of prompt and skip to end of line.
477 ;\(prompt is anything matching regexp comint-prompt-regexp)"
478 ; (interactive)
479 ; (if (re-search-forward comint-prompt-regexp (point-max) t)
480 ; (end-of-line)
481 ; (error "No occurrence of prompt found")))
482 ;
483 ;(defun comint-msearch-input ()
484 ; "Search backwards for previous occurrence of prompt and skip to end of line.
485 ;Search starts from beginning of current line."
486 ; (interactive)
487 ; (let ((p (save-excursion
488 ; (beginning-of-line)
489 ; (cond ((re-search-backward comint-prompt-regexp (point-min) t)
490 ; (end-of-line)
491 ; (point))
492 ; (t nil)))))
493 ; (if p (goto-char p)
494 ; (error "No occurrence of prompt found"))))
495 ;
496 ;(defun comint-msearch-input-matching (str)
497 ; "Search backwards for occurrence of prompt followed by STRING.
498 ;STRING is prompted for, and is NOT a regular expression."
499 ; (interactive (let ((s (read-from-minibuffer
500 ; (format "Command (default %s): "
501 ; comint-last-input-match))))
502 ; (list (if (string= s "") comint-last-input-match s))))
503 ;; (interactive "sCommand: ")
504 ; (setq comint-last-input-match str) ; update default
505 ; (let* ((r (concat comint-prompt-regexp (regexp-quote str)))
506 ; (p (save-excursion
507 ; (beginning-of-line)
508 ; (cond ((re-search-backward r (point-min) t)
509 ; (end-of-line)
510 ; (point))
511 ; (t nil)))))
512 ; (if p (goto-char p)
513 ; (error "No match"))))
515 ;;;
516 ;;; Similar input -- contributed by ccm and highly winning.
517 ;;;
518 ;;; Reenter input, removing back to the last insert point if it exists.
519 ;;;
523 "Fetch the previous (older) input that matches the string typed so far.
524 Successive repetitions find successively older matching inputs.
525 A prefix argument serves as a repeat count; a negative argument
526 fetches following (more recent) inputs."
543 entry)
560 "Fetch the next (newer) input that matches the string typed so far.
561 Successive repetitions find successively newer matching inputs.
562 A prefix argument serves as a repeat count; a negative argument
563 fetches previous (older) inputs."
566 \f
568 "Send input to process.
569 After the process output mark, sends all text from the process mark to
570 point as input to the process. Before the process output mark, calls value
571 of variable comint-get-old-input to retrieve old input, copies it to the
572 process mark, and sends it. A terminal newline is also inserted into the
573 buffer and sent to the process. In either case, value of variable
574 comint-input-sentinel is called on the input before sending it. The input
575 is entered into the input history ring, if the value of variable
576 comint-input-filter returns non-nil when called on the input.
578 If variable comint-eol-on-send is non-nil, then point is moved to the end of
579 line before sending the input.
581 comint-get-old-input, comint-input-sentinel, and comint-input-filter are chosen
582 according to the command interpreter running in the buffer. E.g.,
583 If the interpreter is the csh,
584 comint-get-old-input is the default: take the current line, discard any
585 initial string matching regexp comint-prompt-regexp.
587 commands. When it sees one, it cd's the buffer.
588 comint-input-filter is the default: returns T if the input isn't all white
589 space.
591 If the comint is Lucid Common Lisp,
592 comint-get-old-input snarfs the sexp ending at point.
593 comint-input-sentinel does nothing.
594 comint-input-filter returns NIL if the input matches input-filter-regexp,
595 which matches (1) all whitespace (2) :a, :c, etc.
597 Similarly for Soar, Scheme, etc."
599 ;; Note that the input string does not include its terminal newline.
610 copy))))
622 "Default for comint-get-old-input.
623 Take the current line, and discard any initial text matching
624 comint-prompt-regexp."
633 "Skip past the text matching regexp comint-prompt-regexp.
634 If this takes us past the end of the current line, don't skip at all."
642 "Is point after the process output marker?"
643 ;; Since output could come into the buffer after we looked at the point
644 ;; but before we looked at the process marker's value, we explicitly
645 ;; serialise. This is just because I don't know whether or not emacs
646 ;; services input during execution of lisp commands.
652 "Default function for sending to PROC input STRING.
653 This just sends STRING plus a newline. To override this,
654 set the hook COMINT-INPUT-SENDER."
659 "Goes to the beginning of line, then skips past the prompt, if any.
661 -- go straight to column 0.
663 The prompt skip is done by skipping text matching the regular expression
664 comint-prompt-regexp, a buffer local variable.
666 If you don't like this command, reset c-a to beginning-of-line
667 in your hook, comint-mode-hook."
672 ;;; These two functions are for entering text you don't want echoed or
673 ;;; saved -- typically passwords to ftp, telnet, or somesuch.
674 ;;; Just enter m-x send-invisible and type in your line.
677 "Read a single line of text from user without echoing, and return it.
678 Prompt with argument PROMPT, a string. Optional argument STARS causes
679 input to be echoed with '*' characters on the prompt line. Input ends with
680 RET, LFD, or ESC. DEL or C-h rubs out. C-u kills line. C-g aborts (if
681 inhibit-quit is set because e.g. this function was called from a process
682 filter and C-g is pressed, this function will return `nil', rather than a
683 string).
685 Note that the keystrokes comprising the text can still be recovered
687 applications."
699 ;; This function may get called from a process filter, where
700 ;; inhibit-quit is set. In later versions of emacs read-char
701 ;; may clear quit-flag itself and return C-g. That would make
702 ;; it impossible to quit this loop in a simple way, so
703 ;; re-enable it here (for backward-compatibility the check for
704 ;; quit-flag below would still be necessary, so this is seems
705 ;; like the simplest way to do things).
707 done t))
717 ;; Emulate a true quit, except that we have to return a value.
723 ans)))
726 "Read a string without echoing.
727 Then send it to the process running in the current buffer. A new-line
728 is additionally sent. String is not saved on comint input history list.
729 Security bug: your string can still be temporarily recovered with
731 ; (interactive (list (comint-read-noecho "Enter non-echoed text")))
740 \f
741 ;;; Low-level process communication
744 "*Long inputs send to comint processes are broken up into chunks of this size.
748 "Send PROCESS the contents of STRING as input.
749 This is equivalent to process-send-string, except that long input strings
750 are broken up into chunks of size comint-input-chunk-size. Processes
751 are given a chance to output between chunks. This can help prevent processes
752 from hanging when you send them long inputs on some OS's."
763 "Sends to PROC the region delimited by START and END.
764 This is a replacement for process-send-region that tries to keep
765 your process from hanging on long inputs. See comint-send-string."
768 \f
769 ;;; Random input hackage
772 "Kill all output from interpreter since last input."
781 "Display start of this batch of interpreter output at top of window.
782 Also put cursor there."
791 "Interrupt the current subjob."
796 "Send kill signal to the current subjob."
801 "Send quit signal to the current subjob."
806 "Stop the current subjob.
807 WARNING: if there is no current subjob, you can end up suspending
808 the top-level process running in the buffer. If you accidentally do
810 is not a problem with most shells, since they ignore this signal.)"
815 "Send CONT signal to process buffer's process group.
816 Useful if you accidentally suspend the top-level process."
821 "Kill all text from last stuff output by interpreter to point."
829 "Delete ARG characters forward, or send an EOF to process if at end of buffer."
837 \f
838 ;;; Support for source-file processing commands.
839 ;;;============================================================================
840 ;;; Many command-interpreters (e.g., Lisp, Scheme, Soar) have
841 ;;; commands that process files of source text (e.g. loading or compiling
842 ;;; files). So the corresponding process-in-a-buffer modes have commands
843 ;;; for doing this (e.g., lisp-load-file). The functions below are useful
844 ;;; for defining these commands.
845 ;;;
846 ;;; Alas, these guys don't do exactly the right thing for Lisp, Scheme
847 ;;; and Soar, in that they don't know anything about file extensions.
848 ;;; So the compile/load interface gets the wrong default occasionally.
849 ;;; The load-file/compile-file default mechanism could be smarter -- it
850 ;;; doesn't know about the relationship between filename extensions and
851 ;;; whether the file is source or executable. If you compile foo.lisp
852 ;;; with compile-file, then the next load-file should use foo.bin for
853 ;;; the default, not foo.lisp. This is tricky to do right, particularly
854 ;;; because the extension for executable files varies so much (.o, .bin,
855 ;;; .lbin, .mo, .vo, .ao, ...).
858 ;;; COMINT-SOURCE-DEFAULT -- determines defaults for source-file processing
859 ;;; commands.
860 ;;;
861 ;;; COMINT-CHECK-SOURCE -- if FNAME is in a modified buffer, asks you if you
862 ;;; want to save the buffer before issuing any process requests to the command
863 ;;; interpreter.
864 ;;;
865 ;;; COMINT-GET-SOURCE -- used by the source-file processing commands to prompt
866 ;;; for the file to process.
868 ;;; (COMINT-SOURCE-DEFAULT previous-dir/file source-modes)
869 ;;;============================================================================
870 ;;; This function computes the defaults for the load-file and compile-file
871 ;;; commands for tea, soar, cmulisp, and cmuscheme modes.
872 ;;;
873 ;;; - PREVIOUS-DIR/FILE is a pair (directory . filename) from the last
874 ;;; source-file processing command. NIL if there hasn't been one yet.
875 ;;; - SOURCE-MODES is a list used to determine what buffers contain source
876 ;;; files: if the major mode of the buffer is in SOURCE-MODES, it's source.
877 ;;; Typically, (lisp-mode) or (scheme-mode).
878 ;;;
879 ;;; If the command is given while the cursor is inside a string, *and*
880 ;;; the string is an existing filename, *and* the filename is not a directory,
881 ;;; then the string is taken as default. This allows you to just position
882 ;;; your cursor over a string that's a filename and have it taken as default.
883 ;;;
884 ;;; If the command is given in a file buffer whose major mode is in
885 ;;; SOURCE-MODES, then the the filename is the default file, and the
886 ;;; file's directory is the default directory.
887 ;;;
888 ;;; If the buffer isn't a source file buffer (e.g., it's the process buffer),
889 ;;; then the default directory & file are what was used in the last source-file
890 ;;; processing command (i.e., PREVIOUS-DIR/FILE). If this is the first time
891 ;;; the command has been run (PREVIOUS-DIR/FILE is nil), the default directory
892 ;;; is the cwd, with no default file. (\"no default file\" = nil)
893 ;;;
894 ;;; SOURCE-REGEXP is typically going to be something like (tea-mode)
895 ;;; for T programs, (lisp-mode) for Lisp programs, (soar-mode lisp-mode)
896 ;;; for Soar programs, etc.
897 ;;;
898 ;;; The function returns a pair: (default-directory . default-file).
909 ;;; (COMINT-CHECK-SOURCE fname)
910 ;;;============================================================================
911 ;;; Prior to loading or compiling (or otherwise processing) a file (in the CMU
912 ;;; process-in-a-buffer modes), this function can be called on the filename.
913 ;;; If the file is loaded into a buffer, and the buffer is modified, the user
914 ;;; is queried to see if he wants to save the buffer before proceeding with
915 ;;; the load or compile.
923 ;; save BUFF.
930 ;;; (COMINT-GET-SOURCE prompt prev-dir/file source-modes mustmatch-p)
931 ;;;============================================================================
932 ;;; COMINT-GET-SOURCE is used to prompt for filenames in command-interpreter
933 ;;; commands that process source files (like loading or compiling a file).
934 ;;; It prompts for the filename, provides a default, if there is one,
935 ;;; and returns the result filename.
936 ;;;
937 ;;; See COMINT-SOURCE-DEFAULT for more on determining defaults.
938 ;;;
939 ;;; PROMPT is the prompt string. PREV-DIR/FILE is the (directory . file) pair
940 ;;; from the last source processing command. SOURCE-MODES is a list of major
941 ;;; modes used to determine what file buffers contain source files. (These
942 ;;; two arguments are used for determining defaults). If MUSTMATCH-P is true,
943 ;;; then the filename reader will only accept a file that exists.
944 ;;;
945 ;;; A typical use:
946 ;;; (interactive (comint-get-source "Compile file: " prev-lisp-dir/file
947 ;;; '(lisp-mode) t))
949 ;;; This is pretty stupid about strings. It decides we're in a string
950 ;;; if there's a quote on both sides of point on the current line.
952 "Returns string around POINT that starts the current line or nil."
979 prompt deffile)
980 prompt)
981 defdir
983 mustmatch-p)))
986 ;;; I am somewhat divided on this string-default feature. It seems
987 ;;; to violate the principle-of-least-astonishment, in that it makes
988 ;;; the default harder to predict, so you actually have to look and see
989 ;;; what the default really is before choosing it. This can trip you up.
990 ;;; On the other hand, it can be useful, I guess. I would appreciate feedback
991 ;;; on this.
992 ;;; -Olin
994 \f
995 ;;; Simple process query facility.
996 ;;; ===========================================================================
997 ;;; This function is for commands that want to send a query to the process
998 ;;; and show the response to the user. For example, a command to get the
999 ;;; arglist for a Common Lisp function might send a "(arglist 'foo)" query
1000 ;;; to an inferior Common Lisp process.
1001 ;;;
1002 ;;; This simple facility just sends strings to the inferior process and pops
1003 ;;; up a window for the process buffer so you can see what the process
1004 ;;; responds with. We don't do anything fancy like try to intercept what the
1005 ;;; process responds with and put it in a pop-up window or on the message
1006 ;;; line. We just display the buffer. Low tech. Simple. Works good.
1008 ;;; Send to the inferior process PROC the string STR. Pop-up but do not select
1009 ;;; a window for the inferior process so that its response can be seen.
1019 ;; Try to position the proc window so you can see the answer.
1020 ;; This is bogus code. If you delete the (sit-for 0), it breaks.
1021 ;; I don't know why. Wizards invited to improve it.
1029 \f
1030 ;;; Filename completion in a buffer
1031 ;;; ===========================================================================
1032 ;;; Useful completion functions, courtesy of the Ergo group.
1034 ;;; Three commands:
1035 ;;; comint-dynamic-complete Complete filename at point.
1036 ;;; comint-dynamic-list-completions List completions in help buffer.
1037 ;;; comint-replace-by-expanded-filename Expand and complete filename at point;
1038 ;;; replace with expanded/completed name.
1040 ;;; These are not installed in the comint-mode keymap. But they are
1041 ;;; available for people who want them. Shell-mode installs them:
1042 ;;; (define-key cmushell-mode-map "\t" 'comint-dynamic-complete)
1043 ;;; (define-key cmushell-mode-map "\M-?" 'comint-dynamic-list-completions)))
1044 ;;;
1045 ;;; Commands like this are fine things to put in load hooks if you
1046 ;;; want them present in specific modes.
1050 "Returns the filename at point or causes an error."
1054 ;; Anchor the search forwards.
1062 "Expand the filename at point.
1063 Replace the filename with an expanded, canonicalised, and completed
1064 replacement.
1067 and \. are removed, and the filename is made absolute instead of relative.
1068 See functions expand-file-name and substitute-in-file-name. See also
1069 comint-dynamic-complete."
1087 "Dynamically complete the filename at point.
1088 This function is similar to `comint-replace-by-expanded-filename', except
1089 that it won't change parts of the filename already entered in the buffer;
1090 it just adds completion characters to the end of the filename."
1107 "List in help buffer all possible completions of the filename at point."
1128 \f
1129 ;;; Converting process modes to use comint mode
1130 ;;; ===========================================================================
1131 ;;; The code in the Emacs 19 distribution has all been modified to use comint
1132 ;;; where needed. However, there are `third-party' packages out there that
1133 ;;; still use the old shell mode. Here's a guide to conversion.
1134 ;;;
1135 ;;; Renaming variables
1136 ;;; Most of the work is renaming variables and functions. These are the common
1137 ;;; ones:
1138 ;;; Local variables:
1139 ;;; last-input-start comint-last-input-start
1140 ;;; last-input-end comint-last-input-end
1141 ;;; shell-prompt-pattern comint-prompt-regexp
1142 ;;; shell-set-directory-error-hook <no equivalent>
1143 ;;; Miscellaneous:
1144 ;;; shell-set-directory <unnecessary>
1145 ;;; shell-mode-map comint-mode-map
1146 ;;; Commands:
1147 ;;; shell-send-input comint-send-input
1148 ;;; shell-send-eof comint-delchar-or-maybe-eof
1149 ;;; kill-shell-input comint-kill-input
1150 ;;; interrupt-shell-subjob comint-interrupt-subjob
1151 ;;; stop-shell-subjob comint-stop-subjob
1152 ;;; quit-shell-subjob comint-quit-subjob
1153 ;;; kill-shell-subjob comint-kill-subjob
1154 ;;; kill-output-from-shell comint-kill-output
1155 ;;; show-output-from-shell comint-show-output
1156 ;;; copy-last-shell-input Use comint-previous-input/comint-next-input
1157 ;;;
1158 ;;; SHELL-SET-DIRECTORY is gone, its functionality taken over by
1159 ;;; SHELL-DIRECTORY-TRACKER, the shell mode's comint-input-sentinel.
1160 ;;; Comint mode does not provide functionality equivalent to
1161 ;;; shell-set-directory-error-hook; it is gone.
1162 ;;;
1163 ;;; comint-last-input-start is provided for modes which want to munge
1164 ;;; the buffer after input is sent, perhaps because the inferior
1165 ;;; insists on echoing the input. The LAST-INPUT-START variable in
1166 ;;; the old shell package was used to implement a history mechanism,
1167 ;;; but you should think twice before using comint-last-input-start
1168 ;;; for this; the input history ring often does the job better.
1169 ;;;
1170 ;;; If you are implementing some process-in-a-buffer mode, called foo-mode, do
1171 ;;; *not* create the comint-mode local variables in your foo-mode function.
1172 ;;; This is not modular. Instead, call comint-mode, and let *it* create the
1173 ;;; necessary comint-specific local variables. Then create the
1174 ;;; foo-mode-specific local variables in foo-mode. Set the buffer's keymap to
1175 ;;; be foo-mode-map, and its mode to be foo-mode. Set the comint-mode hooks
1176 ;;; (comint-prompt-regexp, comint-input-filter, comint-input-sentinel,
1177 ;;; comint-get-old-input) that need to be different from the defaults. Call
1178 ;;; foo-mode-hook, and you're done. Don't run the comint-mode hook yourself;
1179 ;;; comint-mode will take care of it. The following example, from cmushell.el,
1180 ;;; is typical:
1181 ;;;
1182 ;;; (defun shell-mode ()
1183 ;;; (interactive)
1184 ;;; (comint-mode)
1185 ;;; (setq comint-prompt-regexp shell-prompt-pattern)
1186 ;;; (setq major-mode 'shell-mode)
1187 ;;; (setq mode-name "Shell")
1188 ;;; (cond ((not shell-mode-map)
1189 ;;; (setq shell-mode-map (full-copy-sparse-keymap comint-mode-map))
1190 ;;; (define-key shell-mode-map "\M-\t" 'comint-dynamic-complete)
1191 ;;; (define-key shell-mode-map "\M-?"
1192 ;;; 'comint-dynamic-list-completions)))
1193 ;;; (use-local-map shell-mode-map)
1194 ;;; (make-local-variable 'shell-directory-stack)
1195 ;;; (setq shell-directory-stack nil)
1196 ;;; (setq comint-input-sentinel 'shell-directory-tracker)
1197 ;;; (run-hooks 'shell-mode-hook))
1198 ;;;
1199 ;;;
1200 ;;; Note that make-comint is different from make-shell in that it
1201 ;;; doesn't have a default program argument. If you give make-shell
1202 ;;; a program name of NIL, it cleverly chooses one of explicit-shell-name,
1203 ;;; $ESHELL, $SHELL, or /bin/sh. If you give make-comint a program argument
1204 ;;; of NIL, it barfs. Adjust your code accordingly...
1205 ;;;
1206 \f
1207 ;;; Do the user's customisation...
1210 "This hook is run when comint is loaded in.
1215 ;;; Change log:
1216 ;;; 9/12/89
1217 ;;; - Souped up the filename expansion procedures.
1218 ;;; Doc strings are much clearer and more detailed.
1219 ;;; Fixed a bug where doing a filename completion when the point
1220 ;;; was in the middle of the filename instead of at the end would lose.
1221 ;;;
1222 ;;; 2/17/90
1223 ;;; - Souped up the command history stuff so that text inserted
1224 ;;; by comint-previous-input-matching is removed by following
1225 ;;; command history recalls. comint-next/previous-input-matching
1226 ;;; is now much more smoothly integrated w/the command history stuff.
1227 ;;; - Added comint-eol-on-send flag and comint-input-sender hook.
1228 ;;; Comint-input-sender based on code contributed by Jeff Peck
1229 ;;; (peck@sun.com).
1230 ;;;
1231 ;;; 3/13/90 ccm@cmu.cs.edu
1232 ;;; - Added comint-previous-similar-input for looking up similar inputs.
1233 ;;; - Added comint-send-and-get-output to allow snarfing input from
1234 ;;; buffer.
1235 ;;; - Added the ability to pick up a source file by positioning over
1236 ;;; a string in comint-get-source.
1237 ;;; - Added add-hook to make it a little easier for the user to use
1238 ;;; multiple hooks.
1239 ;;;
1240 ;;; 5/22/90 shivers
1241 ;;; - Moved Chris' multiplexed ipc stuff to comint-ipc.el.
1242 ;;; - Altered Chris' comint-get-source string feature. The string
1243 ;;; is only offered as a default if it names an existing file.
1244 ;;; - Changed comint-exec to directly crank up the process, instead
1245 ;;; of calling the env program. This made background.el happy.
1246 ;;; - Added new buffer-local var comint-ptyp. The problem is that
1247 ;;; the signalling functions don't work as advertised. If you are
1248 ;;; communicating via pipes, the CURRENT-GROUP arg is supposed to
1249 ;;; be ignored, but, unfortunately it seems to be the case that you
1250 ;;; must pass a NIL for this arg in the pipe case. COMINT-PTYP
1251 ;;; is a flag that tells whether the process is communicating
1252 ;;; via pipes or a pty. The comint signalling functions use it
1253 ;;; to determine the necessary CURRENT-GROUP arg value. The bug
1254 ;;; has been reported to the Gnu folks.
1255 ;;; - comint-dynamic-complete flushes the help window if you hit space
1256 ;;; after you execute it.
1257 ;;; - Added functions comint-send-string, comint-send-region and var
1258 ;;; comint-input-chunk-size. comint-send-string tries to prevent processes
1259 ;;; from hanging when you send them long strings by breaking them into
1260 ;;; chunks and allowing process output between chunks. I got the idea from
1261 ;;; Eero Simoncelli's Common Lisp package. Note that using
1262 ;;; comint-send-string means that the process buffer's contents can change
1263 ;;; during a call! If you depend on process output only happening between
1264 ;;; toplevel commands, this could be a problem. In such a case, use
1265 ;;; process-send-string instead. If this is a problem for people, I'd like
1266 ;;; to hear about it.
1267 ;;; - Added comint-proc-query as a simple mechanism for commands that
1268 ;;; want to query an inferior process and display its response. For a
1269 ;;; typical use, see lisp-show-arglist in cmulisp.el.
1270 ;;; - Added constant comint-version, which is now "2.01".
1271 ;;;
1272 ;;; 6/14/90 shivers
1273 ;;; - Had comint-update-env defined twice. Removed extra copy. Also
1274 ;;; renamed mem to be comint-mem, for modularity. The duplication
1275 ;;; was reported by Michael Meissner.
1276 ;;; 6/16/90 shivers
1277 ;;; - Emacs has two different mechanisms for maintaining the process
1278 ;;; environment, determined at compile time by the MAINTAIN-ENVIRONMENT
1279 ;;; #define. One uses the process-environment global variable, and
1280 ;;; one uses a getenv/setenv interface. comint-exec assumed the
1281 ;;; process-environment interface; it has been generalised (with
1282 ;;; comint-exec-1) to handle both cases. Pretty bogus. We could,
1283 ;;; of course, skip all this and just use the etc/env program to
1284 ;;; handle the environment tweaking, but that obscures process
1285 ;;; queries that other modules (like background.el) depend on. etc/env
1286 ;;; is also fairly bogus. This bug, and some of the fix code was
1287 ;;; reported by Dan Pierson.
1288 ;;;
1289 ;;; 9/5/90 shivers
1290 ;;; - Changed make-variable-buffer-local's to make-local-variable's.
1291 ;;; This leaves non-comint-mode buffers alone. Stephane Payrard
1292 ;;; reported the sloppy useage.
1293 ;;; - You can now go from comint-previous-similar-input to
1294 ;;; comint-previous-input with no problem.
1295 ;;;
1296 ;;; 12/21/90 shivers
1297 ;;; - Added a condition-case to comint-get-source. Bogus strings
1298 ;;; beginning with ~ were making the file-exists-p barf.
1299 ;;; - Added "=" to the set of chars recognised by file completion
1300 ;;; as constituting a filename.
1301 ;;;
1302 ;;; 1/90 shivers
1303 ;;; These changes comprise release 2.02:
1304 ;;; - Removed the kill-all-local-variables in comint-mode. This
1305 ;;; made it impossible for client modes to set things before calling
1306 ;;; comint-mode. (In particular, it messed up ilisp.el) In general,
1307 ;;; the client mode should be responsible for a k-a-l-v's.
1308 ;;; - Fixed comint-match-partial-pathname so that it works in
1309 ;;; more cases: if the filename begins at the start-of-buffer;
1310 ;;; if point is on the first char of the filename. Just a question
1311 ;;; of getting the tricky bits right.
1312 ;;; - Added a hook, comint-exec-hook that is run each time a process
1313 ;;; is cranked up. Useful for things like process-kill-without-query.
1314 ;;;
1315 ;;; These two were pointed out by tale:
1316 ;;; - Improved the doc string in comint-send-input a little bit.
1317 ;;; - Tweaked make-comint to check process status with comint-check-proc
1318 ;;; instead of equivalent inline code.
1319 ;;;
1320 ;;; - Prompt-search history commands have been commented out. I never
1321 ;;; liked them; I don't think anyone used them.
1322 ;;; - Made comint-exec-hook a local var, as it should have been.
1323 ;;; (This way, for instance, you can have cmushell procs kill-w/o-query,
1324 ;;; but let Scheme procs be default.)
1325 ;;;
1326 ;;; 7/91 Shivers
1327 ;;; - Souped up comint-read-noecho with an optional argument, STARS.
1328 ;;; Suggested by mjlx@EAGLE.CNSF.CORNELL.EDU.
1329 ;;; - Moved comint-previous-input-matching from C-c r to C-M-r.
1330 ;;; C-c <letter> bindings are reserved for the user.
1331 ;;; These bindings were done by Jim Blandy.
1332 ;;; These changes comprise version 2.03.
1336 ;;; comint.el ends here