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