Mercurial > emacs
annotate lisp/progmodes/inf-lisp.el @ 10989:f4693d66f90c
(adaptive-fill-regexp): Skip # or ;.
Allow more than one of them (or *'s or >'s).
author | Richard M. Stallman <rms@gnu.org> |
---|---|
date | Mon, 13 Mar 1995 06:31:48 +0000 |
parents | 67b7d1ea7b2e |
children | 8c777db02099 |
rev | line source |
---|---|
835 | 1 ;;; inf-lisp.el --- an inferior-lisp mode |
7300 | 2 ;;; Copyright (C) 1988, 1993, 1994 Free Software Foundation, Inc. |
846
20674ae6bf52
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
836
diff
changeset
|
3 |
798
b7932f859d4e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
727
diff
changeset
|
4 ;; Author: Olin Shivers <shivers@cs.cmu.edu> |
2247
2c7997f249eb
Add or correct keywords
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
957
diff
changeset
|
5 ;; Keywords: processes, lisp |
798
b7932f859d4e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
727
diff
changeset
|
6 |
835 | 7 ;;; This file is part of GNU Emacs. |
8 | |
9 ;;; GNU Emacs is free software; you can redistribute it and/or modify | |
10 ;;; it under the terms of the GNU General Public License as published by | |
11 ;;; the Free Software Foundation; either version 2, or (at your option) | |
12 ;;; any later version. | |
13 | |
14 ;;; GNU Emacs is distributed in the hope that it will be useful, | |
15 ;;; but WITHOUT ANY WARRANTY; without even the implied warranty of | |
16 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
17 ;;; GNU General Public License for more details. | |
18 | |
19 ;;; You should have received a copy of the GNU General Public License | |
20 ;;; along with GNU Emacs; see the file COPYING. If not, write to | |
21 ;;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. | |
267 | 22 |
798
b7932f859d4e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
727
diff
changeset
|
23 ;;; Commentary: |
b7932f859d4e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
727
diff
changeset
|
24 |
267 | 25 ;;; Hacked from tea.el by Olin Shivers (shivers@cs.cmu.edu). 8/88 |
26 | |
835 | 27 ;;; This file defines a a lisp-in-a-buffer package (inferior-lisp |
28 ;;; mode) built on top of comint mode. This version is more | |
29 ;;; featureful, robust, and uniform than the Emacs 18 version. The | |
30 ;;; key bindings are also more compatible with the bindings of Hemlock | |
31 ;;; and Zwei (the Lisp Machine emacs). | |
267 | 32 |
33 ;;; Since this mode is built on top of the general command-interpreter-in- | |
34 ;;; a-buffer mode (comint mode), it shares a common base functionality, | |
35 ;;; and a common set of bindings, with all modes derived from comint mode. | |
36 ;;; This makes these modes easier to use. | |
37 | |
38 ;;; For documentation on the functionality provided by comint mode, and | |
39 ;;; the hooks available for customising it, see the file comint.el. | |
835 | 40 ;;; For further information on inferior-lisp mode, see the comments below. |
267 | 41 |
42 ;;; Needs fixin: | |
43 ;;; The load-file/compile-file default mechanism could be smarter -- it | |
44 ;;; doesn't know about the relationship between filename extensions and | |
45 ;;; whether the file is source or executable. If you compile foo.lisp | |
46 ;;; with compile-file, then the next load-file should use foo.bin for | |
47 ;;; the default, not foo.lisp. This is tricky to do right, particularly | |
48 ;;; because the extension for executable files varies so much (.o, .bin, | |
49 ;;; .lbin, .mo, .vo, .ao, ...). | |
50 ;;; | |
835 | 51 ;;; It would be nice if inferior-lisp (and inferior scheme, T, ...) modes |
267 | 52 ;;; had a verbose minor mode wherein sending or compiling defuns, etc. |
53 ;;; would be reflected in the transcript with suitable comments, e.g. | |
54 ;;; ";;; redefining fact". Several ways to do this. Which is right? | |
55 ;;; | |
56 ;;; When sending text from a source file to a subprocess, the process-mark can | |
57 ;;; move off the window, so you can lose sight of the process interactions. | |
58 ;;; Maybe I should ensure the process mark is in the window when I send | |
59 ;;; text to the process? Switch selectable? | |
60 | |
798
b7932f859d4e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
727
diff
changeset
|
61 ;;; Code: |
b7932f859d4e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
727
diff
changeset
|
62 |
b7932f859d4e
*** empty log message ***
Eric S. Raymond <esr@snark.thyrsus.com>
parents:
727
diff
changeset
|
63 (require 'comint) |
836 | 64 (require 'lisp-mode) |
65 | |
267 | 66 |
957 | 67 ;;;###autoload |
835 | 68 (defvar inferior-lisp-filter-regexp "\\`\\s *\\(:\\(\\w\\|\\s_\\)\\)?\\s *\\'" |
3663 | 69 "*What not to save on inferior Lisp's input history. |
70 Input matching this regexp is not saved on the input history in Inferior Lisp | |
71 mode. Default is whitespace followed by 0 or 1 single-letter colon-keyword | |
7639 | 72 \(as in :a, :c, etc.)") |
267 | 73 |
835 | 74 (defvar inferior-lisp-mode-map nil) |
75 (cond ((not inferior-lisp-mode-map) | |
76 (setq inferior-lisp-mode-map | |
6151
08de067a16fd
(inferior-lisp-mode-map): Use copy-keymap.
Richard M. Stallman <rms@gnu.org>
parents:
5303
diff
changeset
|
77 (copy-keymap comint-mode-map)) |
835 | 78 (setq inferior-lisp-mode-map |
79 (nconc inferior-lisp-mode-map shared-lisp-mode-map)) | |
80 (define-key inferior-lisp-mode-map "\C-x\C-e" 'lisp-eval-last-sexp) | |
81 (define-key inferior-lisp-mode-map "\C-c\C-l" 'lisp-load-file) | |
82 (define-key inferior-lisp-mode-map "\C-c\C-k" 'lisp-compile-file) | |
83 (define-key inferior-lisp-mode-map "\C-c\C-a" 'lisp-show-arglist) | |
84 (define-key inferior-lisp-mode-map "\C-c\C-d" 'lisp-describe-sym) | |
85 (define-key inferior-lisp-mode-map "\C-c\C-f" | |
86 'lisp-show-function-documentation) | |
87 (define-key inferior-lisp-mode-map "\C-c\C-v" | |
88 'lisp-show-variable-documentation))) | |
267 | 89 |
90 ;;; These commands augment Lisp mode, so you can process Lisp code in | |
91 ;;; the source files. | |
92 (define-key lisp-mode-map "\M-\C-x" 'lisp-eval-defun) ; Gnu convention | |
93 (define-key lisp-mode-map "\C-x\C-e" 'lisp-eval-last-sexp) ; Gnu convention | |
94 (define-key lisp-mode-map "\C-c\C-e" 'lisp-eval-defun) | |
95 (define-key lisp-mode-map "\C-c\C-r" 'lisp-eval-region) | |
96 (define-key lisp-mode-map "\C-c\C-c" 'lisp-compile-defun) | |
97 (define-key lisp-mode-map "\C-c\C-z" 'switch-to-lisp) | |
98 (define-key lisp-mode-map "\C-c\C-l" 'lisp-load-file) | |
99 (define-key lisp-mode-map "\C-c\C-k" 'lisp-compile-file) ; "kompile" file | |
100 (define-key lisp-mode-map "\C-c\C-a" 'lisp-show-arglist) | |
101 (define-key lisp-mode-map "\C-c\C-d" 'lisp-describe-sym) | |
102 (define-key lisp-mode-map "\C-c\C-f" 'lisp-show-function-documentation) | |
103 (define-key lisp-mode-map "\C-c\C-v" 'lisp-show-variable-documentation) | |
104 | |
105 | |
727 | 106 ;;; This function exists for backwards compatibility. |
107 ;;; Previous versions of this package bound commands to C-c <letter> | |
108 ;;; bindings, which is not allowed by the gnumacs standard. | |
109 | |
3663 | 110 ;;; "This function binds many inferior-lisp commands to C-c <letter> bindings, |
111 ;;;where they are more accessible. C-c <letter> bindings are reserved for the | |
112 ;;;user, so these bindings are non-standard. If you want them, you should | |
113 ;;;have this function called by the inferior-lisp-load-hook: | |
114 ;;; (setq inferior-lisp-load-hook '(inferior-lisp-install-letter-bindings)) | |
115 ;;;You can modify this function to install just the bindings you want." | |
835 | 116 (defun inferior-lisp-install-letter-bindings () |
727 | 117 (define-key lisp-mode-map "\C-ce" 'lisp-eval-defun-and-go) |
118 (define-key lisp-mode-map "\C-cr" 'lisp-eval-region-and-go) | |
119 (define-key lisp-mode-map "\C-cc" 'lisp-compile-defun-and-go) | |
120 (define-key lisp-mode-map "\C-cz" 'switch-to-lisp) | |
121 (define-key lisp-mode-map "\C-cl" 'lisp-load-file) | |
122 (define-key lisp-mode-map "\C-ck" 'lisp-compile-file) | |
123 (define-key lisp-mode-map "\C-ca" 'lisp-show-arglist) | |
124 (define-key lisp-mode-map "\C-cd" 'lisp-describe-sym) | |
125 (define-key lisp-mode-map "\C-cf" 'lisp-show-function-documentation) | |
126 (define-key lisp-mode-map "\C-cv" 'lisp-show-variable-documentation) | |
835 | 127 |
128 (define-key inferior-lisp-mode-map "\C-cl" 'lisp-load-file) | |
129 (define-key inferior-lisp-mode-map "\C-ck" 'lisp-compile-file) | |
130 (define-key inferior-lisp-mode-map "\C-ca" 'lisp-show-arglist) | |
131 (define-key inferior-lisp-mode-map "\C-cd" 'lisp-describe-sym) | |
132 (define-key inferior-lisp-mode-map "\C-cf" 'lisp-show-function-documentation) | |
133 (define-key inferior-lisp-mode-map "\C-cv" | |
134 'lisp-show-variable-documentation)) | |
727 | 135 |
136 | |
957 | 137 ;;;###autoload |
267 | 138 (defvar inferior-lisp-program "lisp" |
3663 | 139 "*Program name for invoking an inferior Lisp with for Inferior Lisp mode.") |
267 | 140 |
957 | 141 ;;;###autoload |
267 | 142 (defvar inferior-lisp-load-command "(load \"%s\")\n" |
143 "*Format-string for building a Lisp expression to load a file. | |
3663 | 144 This format string should use `%s' to substitute a file name |
267 | 145 and should result in a Lisp expression that will command the inferior Lisp |
146 to load that file. The default works acceptably on most Lisps. | |
147 The string \"(progn (load \\\"%s\\\" :verbose nil :print t) (values))\\\n\" | |
148 produces cosmetically superior output for this application, | |
149 but it works only in Common Lisp.") | |
150 | |
957 | 151 ;;;###autoload |
5303
8e6ba05e1271
(inferior-lisp-prompt): Don't match more than one line.
Richard M. Stallman <rms@gnu.org>
parents:
5104
diff
changeset
|
152 (defvar inferior-lisp-prompt "^[^> \n]*>+:? *" |
3663 | 153 "Regexp to recognise prompts in the Inferior Lisp mode. |
5303
8e6ba05e1271
(inferior-lisp-prompt): Don't match more than one line.
Richard M. Stallman <rms@gnu.org>
parents:
5104
diff
changeset
|
154 Defaults to \"^[^> \\n]*>+:? *\", which works pretty good for Lucid, kcl, |
3663 | 155 and franz. This variable is used to initialize `comint-prompt-regexp' in the |
156 Inferior Lisp buffer. | |
267 | 157 |
158 More precise choices: | |
159 Lucid Common Lisp: \"^\\(>\\|\\(->\\)+\\) *\" | |
160 franz: \"^\\(->\\|<[0-9]*>:\\) *\" | |
161 kcl: \"^>+ *\" | |
162 | |
163 This is a fine thing to set in your .emacs file.") | |
164 | |
3744
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
165 (defvar inferior-lisp-buffer nil "*The current inferior-lisp process buffer. |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
166 |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
167 MULTIPLE PROCESS SUPPORT |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
168 =========================================================================== |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
169 To run multiple Lisp processes, you start the first up |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
170 with \\[inferior-lisp]. It will be in a buffer named `*inferior-lisp*'. |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
171 Rename this buffer with \\[rename-buffer]. You may now start up a new |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
172 process with another \\[inferior-lisp]. It will be in a new buffer, |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
173 named `*inferior-lisp*'. You can switch between the different process |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
174 buffers with \\[switch-to-buffer]. |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
175 |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
176 Commands that send text from source buffers to Lisp processes -- |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
177 like `lisp-eval-defun' or `lisp-show-arglist' -- have to choose a process |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
178 to send to, when you have more than one Lisp process around. This |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
179 is determined by the global variable `inferior-lisp-buffer'. Suppose you |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
180 have three inferior Lisps running: |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
181 Buffer Process |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
182 foo inferior-lisp |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
183 bar inferior-lisp<2> |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
184 *inferior-lisp* inferior-lisp<3> |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
185 If you do a \\[lisp-eval-defun] command on some Lisp source code, |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
186 what process do you send it to? |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
187 |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
188 - If you're in a process buffer (foo, bar, or *inferior-lisp*), |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
189 you send it to that process. |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
190 - If you're in some other buffer (e.g., a source file), you |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
191 send it to the process attached to buffer `inferior-lisp-buffer'. |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
192 This process selection is performed by function `inferior-lisp-proc'. |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
193 |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
194 Whenever \\[inferior-lisp] fires up a new process, it resets |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
195 `inferior-lisp-buffer' to be the new process's buffer. If you only run |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
196 one process, this does the right thing. If you run multiple |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
197 processes, you can change `inferior-lisp-buffer' to another process |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
198 buffer with \\[set-variable].") |
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
199 |
957 | 200 ;;;###autoload |
835 | 201 (defvar inferior-lisp-mode-hook '() |
3663 | 202 "*Hook for customising Inferior Lisp mode.") |
267 | 203 |
835 | 204 (defun inferior-lisp-mode () |
267 | 205 "Major mode for interacting with an inferior Lisp process. |
206 Runs a Lisp interpreter as a subprocess of Emacs, with Lisp I/O through an | |
3663 | 207 Emacs buffer. Variable `inferior-lisp-program' controls which Lisp interpreter |
208 is run. Variables `inferior-lisp-prompt', `inferior-lisp-filter-regexp' and | |
209 `inferior-lisp-load-command' can customize this mode for different Lisp | |
267 | 210 interpreters. |
211 | |
212 For information on running multiple processes in multiple buffers, see | |
3663 | 213 documentation for variable `inferior-lisp-buffer'. |
267 | 214 |
835 | 215 \\{inferior-lisp-mode-map} |
267 | 216 |
3663 | 217 Customisation: Entry to this mode runs the hooks on `comint-mode-hook' and |
218 `inferior-lisp-mode-hook' (in that order). | |
267 | 219 |
220 You can send text to the inferior Lisp process from other buffers containing | |
221 Lisp source. | |
222 switch-to-lisp switches the current buffer to the Lisp process buffer. | |
223 lisp-eval-defun sends the current defun to the Lisp process. | |
224 lisp-compile-defun compiles the current defun. | |
225 lisp-eval-region sends the current region to the Lisp process. | |
226 lisp-compile-region compiles the current region. | |
227 | |
727 | 228 Prefixing the lisp-eval/compile-defun/region commands with |
229 a \\[universal-argument] causes a switch to the Lisp process buffer after sending | |
230 the text. | |
267 | 231 |
232 Commands: | |
233 Return after the end of the process' output sends the text from the | |
234 end of process to point. | |
235 Return before the end of the process' output copies the sexp ending at point | |
236 to the end of the process' output, and sends it. | |
237 Delete converts tabs to spaces as it moves back. | |
238 Tab indents for Lisp; with argument, shifts rest | |
239 of expression rigidly with the current line. | |
240 C-M-q does Tab on each line starting within following expression. | |
241 Paragraphs are separated only by blank lines. Semicolons start comments. | |
242 If you accidentally suspend your process, use \\[comint-continue-subjob] | |
243 to continue it." | |
244 (interactive) | |
245 (comint-mode) | |
246 (setq comint-prompt-regexp inferior-lisp-prompt) | |
835 | 247 (setq major-mode 'inferior-lisp-mode) |
248 (setq mode-name "Inferior Lisp") | |
7075
7c7b98107b4c
(inferior-lisp-mode): Remove space after `:' in mode-line-process.
Richard M. Stallman <rms@gnu.org>
parents:
6151
diff
changeset
|
249 (setq mode-line-process '(":%s")) |
835 | 250 (lisp-mode-variables t) |
251 (use-local-map inferior-lisp-mode-map) ;c-c c-k for "kompile" file | |
267 | 252 (setq comint-get-old-input (function lisp-get-old-input)) |
253 (setq comint-input-filter (function lisp-input-filter)) | |
254 (setq comint-input-sentinel 'ignore) | |
835 | 255 (run-hooks 'inferior-lisp-mode-hook)) |
267 | 256 |
257 (defun lisp-get-old-input () | |
3663 | 258 "Return a string containing the sexp ending at point." |
267 | 259 (save-excursion |
260 (let ((end (point))) | |
261 (backward-sexp) | |
262 (buffer-substring (point) end)))) | |
263 | |
264 (defun lisp-input-filter (str) | |
3663 | 265 "t if STR does not match `inferior-lisp-filter-regexp'." |
835 | 266 (not (string-match inferior-lisp-filter-regexp str))) |
267 | 267 |
957 | 268 ;;;###autoload |
835 | 269 (defun inferior-lisp (cmd) |
3663 | 270 "Run an inferior Lisp process, input and output via buffer `*inferior-lisp*'. |
271 If there is a process already running in `*inferior-lisp*', just switch | |
835 | 272 to that buffer. |
727 | 273 With argument, allows you to edit the command line (default is value |
3663 | 274 of `inferior-lisp-program'). Runs the hooks from |
275 `inferior-lisp-mode-hook' (after the `comint-mode-hook' is run). | |
267 | 276 \(Type \\[describe-mode] in the process buffer for a list of commands.)" |
727 | 277 (interactive (list (if current-prefix-arg |
278 (read-string "Run lisp: " inferior-lisp-program) | |
835 | 279 inferior-lisp-program))) |
280 (if (not (comint-check-proc "*inferior-lisp*")) | |
281 (let ((cmdlist (inferior-lisp-args-to-list cmd))) | |
282 (set-buffer (apply (function make-comint) | |
283 "inferior-lisp" (car cmdlist) nil (cdr cmdlist))) | |
284 (inferior-lisp-mode))) | |
285 (setq inferior-lisp-buffer "*inferior-lisp*") | |
286 (switch-to-buffer "*inferior-lisp*")) | |
287 | |
3663 | 288 ;;;###autoload |
289 (defalias 'run-lisp 'inferior-lisp) | |
267 | 290 |
727 | 291 ;;; Break a string up into a list of arguments. |
292 ;;; This will break if you have an argument with whitespace, as in | |
293 ;;; string = "-ab +c -x 'you lose'". | |
835 | 294 (defun inferior-lisp-args-to-list (string) |
727 | 295 (let ((where (string-match "[ \t]" string))) |
296 (cond ((null where) (list string)) | |
297 ((not (= where 0)) | |
298 (cons (substring string 0 where) | |
835 | 299 (inferior-lisp-args-to-list (substring string (+ 1 where) |
300 (length string))))) | |
727 | 301 (t (let ((pos (string-match "[^ \t]" string))) |
302 (if (null pos) | |
303 nil | |
835 | 304 (inferior-lisp-args-to-list (substring string pos |
305 (length string))))))))) | |
727 | 306 |
307 (defun lisp-eval-region (start end &optional and-go) | |
308 "Send the current region to the inferior Lisp process. | |
3663 | 309 Prefix argument means switch to the Lisp buffer afterwards." |
727 | 310 (interactive "r\nP") |
835 | 311 (comint-send-region (inferior-lisp-proc) start end) |
312 (comint-send-string (inferior-lisp-proc) "\n") | |
727 | 313 (if and-go (switch-to-lisp t))) |
267 | 314 |
727 | 315 (defun lisp-eval-defun (&optional and-go) |
316 "Send the current defun to the inferior Lisp process. | |
3663 | 317 Prefix argument means switch to the Lisp buffer afterwards." |
727 | 318 (interactive "P") |
267 | 319 (save-excursion |
727 | 320 (end-of-defun) |
321 (skip-chars-backward " \t\n\r\f") ; Makes allegro happy | |
322 (let ((end (point))) | |
323 (beginning-of-defun) | |
324 (lisp-eval-region (point) end))) | |
325 (if and-go (switch-to-lisp t))) | |
267 | 326 |
727 | 327 (defun lisp-eval-last-sexp (&optional and-go) |
328 "Send the previous sexp to the inferior Lisp process. | |
3663 | 329 Prefix argument means switch to the Lisp buffer afterwards." |
727 | 330 (interactive "P") |
331 (lisp-eval-region (save-excursion (backward-sexp) (point)) (point) and-go)) | |
267 | 332 |
727 | 333 ;;; Common Lisp COMPILE sux. |
334 (defun lisp-compile-region (start end &optional and-go) | |
335 "Compile the current region in the inferior Lisp process. | |
3663 | 336 Prefix argument means switch to the Lisp buffer afterwards." |
727 | 337 (interactive "r\nP") |
835 | 338 (comint-send-string |
339 (inferior-lisp-proc) | |
340 (format "(funcall (compile nil `(lambda () (progn 'compile %s))))\n" | |
341 (buffer-substring start end))) | |
727 | 342 (if and-go (switch-to-lisp t))) |
835 | 343 |
727 | 344 (defun lisp-compile-defun (&optional and-go) |
345 "Compile the current defun in the inferior Lisp process. | |
3663 | 346 Prefix argument means switch to the Lisp buffer afterwards." |
727 | 347 (interactive "P") |
267 | 348 (save-excursion |
349 (end-of-defun) | |
727 | 350 (skip-chars-backward " \t\n\r\f") ; Makes allegro happy |
267 | 351 (let ((e (point))) |
352 (beginning-of-defun) | |
727 | 353 (lisp-compile-region (point) e))) |
354 (if and-go (switch-to-lisp t))) | |
267 | 355 |
356 (defun switch-to-lisp (eob-p) | |
357 "Switch to the inferior Lisp process buffer. | |
358 With argument, positions cursor at end of buffer." | |
359 (interactive "P") | |
835 | 360 (if (get-buffer inferior-lisp-buffer) |
361 (pop-to-buffer inferior-lisp-buffer) | |
3744
f344542ac7fd
(inferior-lisp-buffer): Move defvar earlier.
Richard M. Stallman <rms@gnu.org>
parents:
3663
diff
changeset
|
362 (error "No current inferior Lisp buffer")) |
267 | 363 (cond (eob-p |
364 (push-mark) | |
365 (goto-char (point-max))))) | |
366 | |
727 | 367 |
368 ;;; Now that lisp-compile/eval-defun/region takes an optional prefix arg, | |
369 ;;; these commands are redundant. But they are kept around for the user | |
370 ;;; to bind if he wishes, for backwards functionality, and because it's | |
371 ;;; easier to type C-c e than C-u C-c C-e. | |
372 | |
267 | 373 (defun lisp-eval-region-and-go (start end) |
3663 | 374 "Send the current region to the inferior Lisp, and switch to its buffer." |
267 | 375 (interactive "r") |
727 | 376 (lisp-eval-region start end t)) |
267 | 377 |
378 (defun lisp-eval-defun-and-go () | |
3663 | 379 "Send the current defun to the inferior Lisp, and switch to its buffer." |
267 | 380 (interactive) |
727 | 381 (lisp-eval-defun t)) |
267 | 382 |
383 (defun lisp-compile-region-and-go (start end) | |
3663 | 384 "Compile the current region in the inferior Lisp, and switch to its buffer." |
267 | 385 (interactive "r") |
727 | 386 (lisp-compile-region start end t)) |
267 | 387 |
388 (defun lisp-compile-defun-and-go () | |
3663 | 389 "Compile the current defun in the inferior Lisp, and switch to its buffer." |
267 | 390 (interactive) |
727 | 391 (lisp-compile-defun t)) |
267 | 392 |
393 ;;; A version of the form in H. Shevis' soar-mode.el package. Less robust. | |
835 | 394 ;;; (defun lisp-compile-sexp (start end) |
395 ;;; "Compile the s-expression bounded by START and END in the inferior lisp. | |
396 ;;; If the sexp isn't a DEFUN form, it is evaluated instead." | |
397 ;;; (cond ((looking-at "(defun\\s +") | |
398 ;;; (goto-char (match-end 0)) | |
399 ;;; (let ((name-start (point))) | |
400 ;;; (forward-sexp 1) | |
401 ;;; (process-send-string "inferior-lisp" | |
402 ;;; (format "(compile '%s #'(lambda " | |
403 ;;; (buffer-substring name-start | |
404 ;;; (point))))) | |
405 ;;; (let ((body-start (point))) | |
406 ;;; (goto-char start) (forward-sexp 1) ; Can't use end-of-defun. | |
407 ;;; (process-send-region "inferior-lisp" | |
408 ;;; (buffer-substring body-start (point)))) | |
409 ;;; (process-send-string "inferior-lisp" ")\n")) | |
410 ;;; (t (lisp-eval-region start end))))) | |
411 ;;; | |
412 ;;; (defun lisp-compile-region (start end) | |
413 ;;; "Each s-expression in the current region is compiled (if a DEFUN) | |
414 ;;; or evaluated (if not) in the inferior lisp." | |
415 ;;; (interactive "r") | |
416 ;;; (save-excursion | |
417 ;;; (goto-char start) (end-of-defun) (beginning-of-defun) ; error check | |
418 ;;; (if (< (point) start) (error "region begins in middle of defun")) | |
419 ;;; (goto-char start) | |
420 ;;; (let ((s start)) | |
421 ;;; (end-of-defun) | |
422 ;;; (while (<= (point) end) ; Zip through | |
423 ;;; (lisp-compile-sexp s (point)) ; compiling up defun-sized chunks. | |
424 ;;; (setq s (point)) | |
425 ;;; (end-of-defun)) | |
426 ;;; (if (< s end) (lisp-compile-sexp s end))))) | |
427 ;;; | |
267 | 428 ;;; End of HS-style code |
429 | |
430 | |
431 (defvar lisp-prev-l/c-dir/file nil | |
3663 | 432 "Record last directory and file used in loading or compiling. |
433 This holds a cons cell of the form `(DIRECTORY . FILE)' | |
434 describing the last `lisp-load-file' or `lisp-compile-file' command.") | |
267 | 435 |
436 (defvar lisp-source-modes '(lisp-mode) | |
437 "*Used to determine if a buffer contains Lisp source code. | |
438 If it's loaded into a buffer that is in one of these major modes, it's | |
3663 | 439 considered a Lisp source file by `lisp-load-file' and `lisp-compile-file'. |
267 | 440 Used by these commands to determine defaults.") |
441 | |
442 (defun lisp-load-file (file-name) | |
443 "Load a Lisp file into the inferior Lisp process." | |
444 (interactive (comint-get-source "Load Lisp file: " lisp-prev-l/c-dir/file | |
445 lisp-source-modes nil)) ; NIL because LOAD | |
835 | 446 ; doesn't need an exact name |
267 | 447 (comint-check-source file-name) ; Check to see if buffer needs saved. |
448 (setq lisp-prev-l/c-dir/file (cons (file-name-directory file-name) | |
449 (file-name-nondirectory file-name))) | |
835 | 450 (comint-send-string (inferior-lisp-proc) |
727 | 451 (format inferior-lisp-load-command file-name)) |
452 (switch-to-lisp t)) | |
267 | 453 |
454 | |
455 (defun lisp-compile-file (file-name) | |
456 "Compile a Lisp file in the inferior Lisp process." | |
457 (interactive (comint-get-source "Compile Lisp file: " lisp-prev-l/c-dir/file | |
458 lisp-source-modes nil)) ; NIL = don't need | |
835 | 459 ; suffix .lisp |
267 | 460 (comint-check-source file-name) ; Check to see if buffer needs saved. |
461 (setq lisp-prev-l/c-dir/file (cons (file-name-directory file-name) | |
462 (file-name-nondirectory file-name))) | |
835 | 463 (comint-send-string (inferior-lisp-proc) (concat "(compile-file \"" |
464 file-name | |
465 "\"\)\n")) | |
727 | 466 (switch-to-lisp t)) |
267 | 467 |
468 | |
469 | |
470 ;;; Documentation functions: function doc, var doc, arglist, and | |
471 ;;; describe symbol. | |
472 ;;; =========================================================================== | |
473 | |
474 ;;; Command strings | |
475 ;;; =============== | |
476 | |
477 (defvar lisp-function-doc-command | |
478 "(let ((fn '%s)) | |
479 (format t \"Documentation for ~a:~&~a\" | |
480 fn (documentation fn 'function)) | |
481 (values))\n" | |
482 "Command to query inferior Lisp for a function's documentation.") | |
483 | |
484 (defvar lisp-var-doc-command | |
485 "(let ((v '%s)) | |
486 (format t \"Documentation for ~a:~&~a\" | |
487 v (documentation v 'variable)) | |
488 (values))\n" | |
489 "Command to query inferior Lisp for a variable's documentation.") | |
490 | |
491 (defvar lisp-arglist-command | |
492 "(let ((fn '%s)) | |
493 (format t \"Arglist for ~a: ~a\" fn (arglist fn)) | |
494 (values))\n" | |
495 "Command to query inferior Lisp for a function's arglist.") | |
496 | |
497 (defvar lisp-describe-sym-command | |
498 "(describe '%s)\n" | |
499 "Command to query inferior Lisp for a variable's documentation.") | |
500 | |
501 | |
502 ;;; Ancillary functions | |
503 ;;; =================== | |
504 | |
505 ;;; Reads a string from the user. | |
506 (defun lisp-symprompt (prompt default) | |
507 (list (let* ((prompt (if default | |
508 (format "%s (default %s): " prompt default) | |
835 | 509 (concat prompt ": "))) |
267 | 510 (ans (read-string prompt))) |
511 (if (zerop (length ans)) default ans)))) | |
512 | |
513 | |
514 ;;; Adapted from function-called-at-point in help.el. | |
515 (defun lisp-fn-called-at-pt () | |
516 "Returns the name of the function called in the current call. | |
3663 | 517 The value is nil if it can't find one." |
267 | 518 (condition-case nil |
519 (save-excursion | |
520 (save-restriction | |
521 (narrow-to-region (max (point-min) (- (point) 1000)) (point-max)) | |
522 (backward-up-list 1) | |
523 (forward-char 1) | |
524 (let ((obj (read (current-buffer)))) | |
525 (and (symbolp obj) obj)))) | |
526 (error nil))) | |
527 | |
528 | |
529 ;;; Adapted from variable-at-point in help.el. | |
530 (defun lisp-var-at-pt () | |
531 (condition-case () | |
532 (save-excursion | |
533 (forward-sexp -1) | |
534 (skip-chars-forward "'") | |
535 (let ((obj (read (current-buffer)))) | |
536 (and (symbolp obj) obj))) | |
537 (error nil))) | |
538 | |
539 | |
540 ;;; Documentation functions: fn and var doc, arglist, and symbol describe. | |
541 ;;; ====================================================================== | |
542 | |
543 (defun lisp-show-function-documentation (fn) | |
544 "Send a command to the inferior Lisp to give documentation for function FN. | |
3663 | 545 See variable `lisp-function-doc-command'." |
267 | 546 (interactive (lisp-symprompt "Function doc" (lisp-fn-called-at-pt))) |
835 | 547 (comint-proc-query (inferior-lisp-proc) |
548 (format lisp-function-doc-command fn))) | |
267 | 549 |
550 (defun lisp-show-variable-documentation (var) | |
551 "Send a command to the inferior Lisp to give documentation for function FN. | |
3663 | 552 See variable `lisp-var-doc-command'." |
267 | 553 (interactive (lisp-symprompt "Variable doc" (lisp-var-at-pt))) |
835 | 554 (comint-proc-query (inferior-lisp-proc) (format lisp-var-doc-command var))) |
267 | 555 |
556 (defun lisp-show-arglist (fn) | |
3663 | 557 "Send a query to the inferior Lisp for the arglist for function FN. |
558 See variable `lisp-arglist-command'." | |
267 | 559 (interactive (lisp-symprompt "Arglist" (lisp-fn-called-at-pt))) |
835 | 560 (comint-proc-query (inferior-lisp-proc) (format lisp-arglist-command fn))) |
267 | 561 |
562 (defun lisp-describe-sym (sym) | |
563 "Send a command to the inferior Lisp to describe symbol SYM. | |
3663 | 564 See variable `lisp-describe-sym-command'." |
267 | 565 (interactive (lisp-symprompt "Describe" (lisp-var-at-pt))) |
835 | 566 (comint-proc-query (inferior-lisp-proc) |
567 (format lisp-describe-sym-command sym))) | |
267 | 568 |
569 | |
3663 | 570 ;; "Returns the current inferior Lisp process. |
571 ;; See variable `inferior-lisp-buffer'." | |
835 | 572 (defun inferior-lisp-proc () |
267 | 573 (let ((proc (get-buffer-process (if (eq major-mode 'inferior-lisp-mode) |
574 (current-buffer) | |
835 | 575 inferior-lisp-buffer)))) |
267 | 576 (or proc |
5104
bcf4b8ed1c60
(inferior-lisp-proc): Clean up error message.
Richard M. Stallman <rms@gnu.org>
parents:
3744
diff
changeset
|
577 (error "No Lisp subprocess; see variable `inferior-lisp-buffer'")))) |
267 | 578 |
579 | |
580 ;;; Do the user's customisation... | |
581 ;;;=============================== | |
835 | 582 (defvar inferior-lisp-load-hook nil |
3663 | 583 "This hook is run when the library `inf-lisp' is loaded. |
267 | 584 This is a good place to put keybindings.") |
835 | 585 |
586 (run-hooks 'inferior-lisp-load-hook) | |
267 | 587 |
588 ;;; CHANGE LOG | |
589 ;;; =========================================================================== | |
835 | 590 ;;; 7/21/92 Jim Blandy |
591 ;;; - Changed all uses of the cmulisp name or prefix to inferior-lisp; | |
592 ;;; this is now the official inferior lisp package. Use the global | |
593 ;;; ChangeLog from now on. | |
267 | 594 ;;; 5/24/90 Olin |
595 ;;; - Split cmulisp and cmushell modes into separate files. | |
596 ;;; Not only is this a good idea, it's apparently the way it'll be rel 19. | |
597 ;;; - Upgraded process sends to use comint-send-string instead of | |
598 ;;; process-send-string. | |
599 ;;; - Explicit references to process "cmulisp" have been replaced with | |
600 ;;; (cmulisp-proc). This allows better handling of multiple process bufs. | |
601 ;;; - Added process query and var/function/symbol documentation | |
602 ;;; commands. Based on code written by Douglas Roberts. | |
603 ;;; - Added lisp-eval-last-sexp, bound to C-x C-e. | |
604 ;;; | |
605 ;;; 9/20/90 Olin | |
606 ;;; Added a save-restriction to lisp-fn-called-at-pt. This bug and fix | |
607 ;;; reported by Lennart Staflin. | |
608 ;;; | |
609 ;;; 3/12/90 Olin | |
610 ;;; - lisp-load-file and lisp-compile-file no longer switch-to-lisp. | |
611 ;;; Tale suggested this. | |
727 | 612 ;;; - Reversed this decision 7/15/91. You need the visual feedback. |
613 ;;; | |
614 ;;; 7/25/91 Olin | |
615 ;;; Changed all keybindings of the form C-c <letter>. These are | |
616 ;;; supposed to be reserved for the user to bind. This affected | |
617 ;;; mainly the compile/eval-defun/region[-and-go] commands. | |
618 ;;; This was painful, but necessary to adhere to the gnumacs standard. | |
619 ;;; For some backwards compatibility, see the | |
620 ;;; cmulisp-install-letter-bindings | |
621 ;;; function. | |
622 ;;; | |
623 ;;; 8/2/91 Olin | |
624 ;;; - The lisp-compile/eval-defun/region commands now take a prefix arg, | |
625 ;;; which means switch-to-lisp after sending the text to the Lisp process. | |
626 ;;; This obsoletes all the -and-go commands. The -and-go commands are | |
627 ;;; kept around for historical reasons, and because the user can bind | |
628 ;;; them to key sequences shorter than C-u C-c C-<letter>. | |
629 ;;; - If M-x cmulisp is invoked with a prefix arg, it allows you to | |
630 ;;; edit the command line. | |
584 | 631 |
835 | 632 (provide 'inf-lisp) |
584 | 633 |
835 | 634 ;;; inf-lisp.el ends here |