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