| 1 | ;;; inf-lisp.el --- an inferior-lisp mode |
| 2 | ;;; Copyright (C) 1988, 1993 Free Software Foundation, Inc. |
| 3 | |
| 4 | ;; Author: Olin Shivers <shivers@cs.cmu.edu> |
| 5 | ;; Keywords: processes, lisp |
| 6 | |
| 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. |
| 22 | |
| 23 | ;;; Commentary: |
| 24 | |
| 25 | ;;; Hacked from tea.el by Olin Shivers (shivers@cs.cmu.edu). 8/88 |
| 26 | |
| 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). |
| 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. |
| 40 | ;;; For further information on inferior-lisp mode, see the comments below. |
| 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 | ;;; |
| 51 | ;;; It would be nice if inferior-lisp (and inferior scheme, T, ...) modes |
| 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 | |
| 61 | ;;; Code: |
| 62 | |
| 63 | (require 'comint) |
| 64 | (require 'lisp-mode) |
| 65 | |
| 66 | \f |
| 67 | ;;;###autoload |
| 68 | (defvar inferior-lisp-filter-regexp "\\`\\s *\\(:\\(\\w\\|\\s_\\)\\)?\\s *\\'" |
| 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 |
| 72 | (as in :a, :c, etc.)") |
| 73 | |
| 74 | (defvar inferior-lisp-mode-map nil) |
| 75 | (cond ((not inferior-lisp-mode-map) |
| 76 | (setq inferior-lisp-mode-map |
| 77 | (full-copy-sparse-keymap comint-mode-map)) |
| 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))) |
| 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 | |
| 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 | |
| 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." |
| 116 | (defun inferior-lisp-install-letter-bindings () |
| 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) |
| 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)) |
| 135 | |
| 136 | |
| 137 | ;;;###autoload |
| 138 | (defvar inferior-lisp-program "lisp" |
| 139 | "*Program name for invoking an inferior Lisp with for Inferior Lisp mode.") |
| 140 | |
| 141 | ;;;###autoload |
| 142 | (defvar inferior-lisp-load-command "(load \"%s\")\n" |
| 143 | "*Format-string for building a Lisp expression to load a file. |
| 144 | This format string should use `%s' to substitute a file name |
| 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 | |
| 151 | ;;;###autoload |
| 152 | (defvar inferior-lisp-prompt "^[^> \n]*>+:? *" |
| 153 | "Regexp to recognise prompts in the Inferior Lisp mode. |
| 154 | Defaults to \"^[^> \\n]*>+:? *\", which works pretty good for Lucid, kcl, |
| 155 | and franz. This variable is used to initialize `comint-prompt-regexp' in the |
| 156 | Inferior Lisp buffer. |
| 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 | |
| 165 | (defvar inferior-lisp-buffer nil "*The current inferior-lisp process buffer. |
| 166 | |
| 167 | MULTIPLE PROCESS SUPPORT |
| 168 | =========================================================================== |
| 169 | To run multiple Lisp processes, you start the first up |
| 170 | with \\[inferior-lisp]. It will be in a buffer named `*inferior-lisp*'. |
| 171 | Rename this buffer with \\[rename-buffer]. You may now start up a new |
| 172 | process with another \\[inferior-lisp]. It will be in a new buffer, |
| 173 | named `*inferior-lisp*'. You can switch between the different process |
| 174 | buffers with \\[switch-to-buffer]. |
| 175 | |
| 176 | Commands that send text from source buffers to Lisp processes -- |
| 177 | like `lisp-eval-defun' or `lisp-show-arglist' -- have to choose a process |
| 178 | to send to, when you have more than one Lisp process around. This |
| 179 | is determined by the global variable `inferior-lisp-buffer'. Suppose you |
| 180 | have three inferior Lisps running: |
| 181 | Buffer Process |
| 182 | foo inferior-lisp |
| 183 | bar inferior-lisp<2> |
| 184 | *inferior-lisp* inferior-lisp<3> |
| 185 | If you do a \\[lisp-eval-defun] command on some Lisp source code, |
| 186 | what process do you send it to? |
| 187 | |
| 188 | - If you're in a process buffer (foo, bar, or *inferior-lisp*), |
| 189 | you send it to that process. |
| 190 | - If you're in some other buffer (e.g., a source file), you |
| 191 | send it to the process attached to buffer `inferior-lisp-buffer'. |
| 192 | This process selection is performed by function `inferior-lisp-proc'. |
| 193 | |
| 194 | Whenever \\[inferior-lisp] fires up a new process, it resets |
| 195 | `inferior-lisp-buffer' to be the new process's buffer. If you only run |
| 196 | one process, this does the right thing. If you run multiple |
| 197 | processes, you can change `inferior-lisp-buffer' to another process |
| 198 | buffer with \\[set-variable].") |
| 199 | |
| 200 | ;;;###autoload |
| 201 | (defvar inferior-lisp-mode-hook '() |
| 202 | "*Hook for customising Inferior Lisp mode.") |
| 203 | |
| 204 | (defun inferior-lisp-mode () |
| 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 |
| 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 |
| 210 | interpreters. |
| 211 | |
| 212 | For information on running multiple processes in multiple buffers, see |
| 213 | documentation for variable `inferior-lisp-buffer'. |
| 214 | |
| 215 | \\{inferior-lisp-mode-map} |
| 216 | |
| 217 | Customisation: Entry to this mode runs the hooks on `comint-mode-hook' and |
| 218 | `inferior-lisp-mode-hook' (in that order). |
| 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 | |
| 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. |
| 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) |
| 247 | (setq major-mode 'inferior-lisp-mode) |
| 248 | (setq mode-name "Inferior Lisp") |
| 249 | (setq mode-line-process '(": %s")) |
| 250 | (lisp-mode-variables t) |
| 251 | (use-local-map inferior-lisp-mode-map) ;c-c c-k for "kompile" file |
| 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) |
| 255 | (run-hooks 'inferior-lisp-mode-hook)) |
| 256 | |
| 257 | (defun lisp-get-old-input () |
| 258 | "Return a string containing the sexp ending at point." |
| 259 | (save-excursion |
| 260 | (let ((end (point))) |
| 261 | (backward-sexp) |
| 262 | (buffer-substring (point) end)))) |
| 263 | |
| 264 | (defun lisp-input-filter (str) |
| 265 | "t if STR does not match `inferior-lisp-filter-regexp'." |
| 266 | (not (string-match inferior-lisp-filter-regexp str))) |
| 267 | |
| 268 | ;;;###autoload |
| 269 | (defun inferior-lisp (cmd) |
| 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 |
| 272 | to that buffer. |
| 273 | With argument, allows you to edit the command line (default is value |
| 274 | of `inferior-lisp-program'). Runs the hooks from |
| 275 | `inferior-lisp-mode-hook' (after the `comint-mode-hook' is run). |
| 276 | \(Type \\[describe-mode] in the process buffer for a list of commands.)" |
| 277 | (interactive (list (if current-prefix-arg |
| 278 | (read-string "Run lisp: " inferior-lisp-program) |
| 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 | |
| 288 | ;;;###autoload |
| 289 | (defalias 'run-lisp 'inferior-lisp) |
| 290 | |
| 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'". |
| 294 | (defun inferior-lisp-args-to-list (string) |
| 295 | (let ((where (string-match "[ \t]" string))) |
| 296 | (cond ((null where) (list string)) |
| 297 | ((not (= where 0)) |
| 298 | (cons (substring string 0 where) |
| 299 | (inferior-lisp-args-to-list (substring string (+ 1 where) |
| 300 | (length string))))) |
| 301 | (t (let ((pos (string-match "[^ \t]" string))) |
| 302 | (if (null pos) |
| 303 | nil |
| 304 | (inferior-lisp-args-to-list (substring string pos |
| 305 | (length string))))))))) |
| 306 | |
| 307 | (defun lisp-eval-region (start end &optional and-go) |
| 308 | "Send the current region to the inferior Lisp process. |
| 309 | Prefix argument means switch to the Lisp buffer afterwards." |
| 310 | (interactive "r\nP") |
| 311 | (comint-send-region (inferior-lisp-proc) start end) |
| 312 | (comint-send-string (inferior-lisp-proc) "\n") |
| 313 | (if and-go (switch-to-lisp t))) |
| 314 | |
| 315 | (defun lisp-eval-defun (&optional and-go) |
| 316 | "Send the current defun to the inferior Lisp process. |
| 317 | Prefix argument means switch to the Lisp buffer afterwards." |
| 318 | (interactive "P") |
| 319 | (save-excursion |
| 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))) |
| 326 | |
| 327 | (defun lisp-eval-last-sexp (&optional and-go) |
| 328 | "Send the previous sexp to the inferior Lisp process. |
| 329 | Prefix argument means switch to the Lisp buffer afterwards." |
| 330 | (interactive "P") |
| 331 | (lisp-eval-region (save-excursion (backward-sexp) (point)) (point) and-go)) |
| 332 | |
| 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. |
| 336 | Prefix argument means switch to the Lisp buffer afterwards." |
| 337 | (interactive "r\nP") |
| 338 | (comint-send-string |
| 339 | (inferior-lisp-proc) |
| 340 | (format "(funcall (compile nil `(lambda () (progn 'compile %s))))\n" |
| 341 | (buffer-substring start end))) |
| 342 | (if and-go (switch-to-lisp t))) |
| 343 | |
| 344 | (defun lisp-compile-defun (&optional and-go) |
| 345 | "Compile the current defun in the inferior Lisp process. |
| 346 | Prefix argument means switch to the Lisp buffer afterwards." |
| 347 | (interactive "P") |
| 348 | (save-excursion |
| 349 | (end-of-defun) |
| 350 | (skip-chars-backward " \t\n\r\f") ; Makes allegro happy |
| 351 | (let ((e (point))) |
| 352 | (beginning-of-defun) |
| 353 | (lisp-compile-region (point) e))) |
| 354 | (if and-go (switch-to-lisp t))) |
| 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") |
| 360 | (if (get-buffer inferior-lisp-buffer) |
| 361 | (pop-to-buffer inferior-lisp-buffer) |
| 362 | (error "No current inferior Lisp buffer")) |
| 363 | (cond (eob-p |
| 364 | (push-mark) |
| 365 | (goto-char (point-max))))) |
| 366 | |
| 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 | |
| 373 | (defun lisp-eval-region-and-go (start end) |
| 374 | "Send the current region to the inferior Lisp, and switch to its buffer." |
| 375 | (interactive "r") |
| 376 | (lisp-eval-region start end t)) |
| 377 | |
| 378 | (defun lisp-eval-defun-and-go () |
| 379 | "Send the current defun to the inferior Lisp, and switch to its buffer." |
| 380 | (interactive) |
| 381 | (lisp-eval-defun t)) |
| 382 | |
| 383 | (defun lisp-compile-region-and-go (start end) |
| 384 | "Compile the current region in the inferior Lisp, and switch to its buffer." |
| 385 | (interactive "r") |
| 386 | (lisp-compile-region start end t)) |
| 387 | |
| 388 | (defun lisp-compile-defun-and-go () |
| 389 | "Compile the current defun in the inferior Lisp, and switch to its buffer." |
| 390 | (interactive) |
| 391 | (lisp-compile-defun t)) |
| 392 | |
| 393 | ;;; A version of the form in H. Shevis' soar-mode.el package. Less robust. |
| 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 | ;;; |
| 428 | ;;; End of HS-style code |
| 429 | |
| 430 | |
| 431 | (defvar lisp-prev-l/c-dir/file nil |
| 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.") |
| 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 |
| 439 | considered a Lisp source file by `lisp-load-file' and `lisp-compile-file'. |
| 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 |
| 446 | ; doesn't need an exact name |
| 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))) |
| 450 | (comint-send-string (inferior-lisp-proc) |
| 451 | (format inferior-lisp-load-command file-name)) |
| 452 | (switch-to-lisp t)) |
| 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 |
| 459 | ; suffix .lisp |
| 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))) |
| 463 | (comint-send-string (inferior-lisp-proc) (concat "(compile-file \"" |
| 464 | file-name |
| 465 | "\"\)\n")) |
| 466 | (switch-to-lisp t)) |
| 467 | |
| 468 | |
| 469 | \f |
| 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) |
| 509 | (concat prompt ": "))) |
| 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. |
| 517 | The value is nil if it can't find one." |
| 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. |
| 545 | See variable `lisp-function-doc-command'." |
| 546 | (interactive (lisp-symprompt "Function doc" (lisp-fn-called-at-pt))) |
| 547 | (comint-proc-query (inferior-lisp-proc) |
| 548 | (format lisp-function-doc-command fn))) |
| 549 | |
| 550 | (defun lisp-show-variable-documentation (var) |
| 551 | "Send a command to the inferior Lisp to give documentation for function FN. |
| 552 | See variable `lisp-var-doc-command'." |
| 553 | (interactive (lisp-symprompt "Variable doc" (lisp-var-at-pt))) |
| 554 | (comint-proc-query (inferior-lisp-proc) (format lisp-var-doc-command var))) |
| 555 | |
| 556 | (defun lisp-show-arglist (fn) |
| 557 | "Send a query to the inferior Lisp for the arglist for function FN. |
| 558 | See variable `lisp-arglist-command'." |
| 559 | (interactive (lisp-symprompt "Arglist" (lisp-fn-called-at-pt))) |
| 560 | (comint-proc-query (inferior-lisp-proc) (format lisp-arglist-command fn))) |
| 561 | |
| 562 | (defun lisp-describe-sym (sym) |
| 563 | "Send a command to the inferior Lisp to describe symbol SYM. |
| 564 | See variable `lisp-describe-sym-command'." |
| 565 | (interactive (lisp-symprompt "Describe" (lisp-var-at-pt))) |
| 566 | (comint-proc-query (inferior-lisp-proc) |
| 567 | (format lisp-describe-sym-command sym))) |
| 568 | |
| 569 | \f |
| 570 | ;; "Returns the current inferior Lisp process. |
| 571 | ;; See variable `inferior-lisp-buffer'." |
| 572 | (defun inferior-lisp-proc () |
| 573 | (let ((proc (get-buffer-process (if (eq major-mode 'inferior-lisp-mode) |
| 574 | (current-buffer) |
| 575 | inferior-lisp-buffer)))) |
| 576 | (or proc |
| 577 | (error "No Lisp subprocess; see variable `inferior-lisp-buffer'")))) |
| 578 | |
| 579 | |
| 580 | ;;; Do the user's customisation... |
| 581 | ;;;=============================== |
| 582 | (defvar inferior-lisp-load-hook nil |
| 583 | "This hook is run when the library `inf-lisp' is loaded. |
| 584 | This is a good place to put keybindings.") |
| 585 | |
| 586 | (run-hooks 'inferior-lisp-load-hook) |
| 587 | |
| 588 | ;;; CHANGE LOG |
| 589 | ;;; =========================================================================== |
| 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. |
| 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. |
| 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. |
| 631 | |
| 632 | (provide 'inf-lisp) |
| 633 | |
| 634 | ;;; inf-lisp.el ends here |