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