code.delx.au - gnu-emacs/blob - lisp/progmodes/inf-lisp.el

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