lisp/progmodes/inf-lisp.el

   1 ;;; inf-lisp.el --- an inferior-lisp mode
   2 ;;; Copyright (C) 1988, 1993, 1994 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              (copy-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   (pop-to-buffer "*inferior-lisp*"))
 287 ;;;###autoload (add-hook 'same-window-buffer-names "*inferior-lisp*")
 288
 289 ;;;###autoload
 290 (defalias 'run-lisp 'inferior-lisp)
 291
 292 ;;; Break a string up into a list of arguments.
 293 ;;; This will break if you have an argument with whitespace, as in
 294 ;;; string = "-ab +c -x 'you lose'".
 295 (defun inferior-lisp-args-to-list (string)
 296   (let ((where (string-match "[ \t]" string)))
 297     (cond ((null where) (list string))
 298           ((not (= where 0))
 299            (cons (substring string 0 where)
 300                  (inferior-lisp-args-to-list (substring string (+ 1 where)
 301                                                         (length string)))))
 302           (t (let ((pos (string-match "[^ \t]" string)))
 303                (if (null pos)
 304                    nil
 305                  (inferior-lisp-args-to-list (substring string pos
 306                                                         (length string)))))))))
 307
 308 (defun lisp-eval-region (start end &optional and-go)
 309   "Send the current region to the inferior Lisp process.
 310 Prefix argument means switch to the Lisp buffer afterwards."
 311   (interactive "r\nP")
 312   (comint-send-region (inferior-lisp-proc) start end)
 313   (comint-send-string (inferior-lisp-proc) "\n")
 314   (if and-go (switch-to-lisp t)))
 315
 316 (defun lisp-eval-defun (&optional and-go)
 317   "Send the current defun to the inferior Lisp process.
 318 Prefix argument means switch to the Lisp buffer afterwards."
 319   (interactive "P")
 320   (save-excursion
 321     (end-of-defun)
 322     (skip-chars-backward " \t\n\r\f") ;  Makes allegro happy
 323     (let ((end (point)))
 324       (beginning-of-defun)
 325       (lisp-eval-region (point) end)))
 326   (if and-go (switch-to-lisp t)))
 327
 328 (defun lisp-eval-last-sexp (&optional and-go)
 329   "Send the previous sexp to the inferior Lisp process.
 330 Prefix argument means switch to the Lisp buffer afterwards."
 331   (interactive "P")
 332   (lisp-eval-region (save-excursion (backward-sexp) (point)) (point) and-go))
 333
 334 ;;; Common Lisp COMPILE sux.
 335 (defun lisp-compile-region (start end &optional and-go)
 336   "Compile the current region in the inferior Lisp process.
 337 Prefix argument means switch to the Lisp buffer afterwards."
 338   (interactive "r\nP")
 339   (comint-send-string
 340    (inferior-lisp-proc)
 341    (format "(funcall (compile nil `(lambda () (progn 'compile %s))))\n"
 342            (buffer-substring start end)))
 343   (if and-go (switch-to-lisp t)))
 344
 345 (defun lisp-compile-defun (&optional and-go)
 346   "Compile the current defun in the inferior Lisp process.
 347 Prefix argument means switch to the Lisp buffer afterwards."
 348   (interactive "P")
 349   (save-excursion
 350     (end-of-defun)
 351     (skip-chars-backward " \t\n\r\f") ;  Makes allegro happy
 352     (let ((e (point)))
 353       (beginning-of-defun)
 354       (lisp-compile-region (point) e)))
 355   (if and-go (switch-to-lisp t)))
 356
 357 (defun switch-to-lisp (eob-p)
 358   "Switch to the inferior Lisp process buffer.
 359 With argument, positions cursor at end of buffer."
 360   (interactive "P")
 361   (if (get-buffer inferior-lisp-buffer)
 362       (pop-to-buffer inferior-lisp-buffer)
 363     (error "No current inferior Lisp buffer"))
 364   (cond (eob-p
 365          (push-mark)
 366          (goto-char (point-max)))))
 367
 368
 369 ;;; Now that lisp-compile/eval-defun/region takes an optional prefix arg,
 370 ;;; these commands are redundant. But they are kept around for the user
 371 ;;; to bind if he wishes, for backwards functionality, and because it's
 372 ;;; easier to type C-c e than C-u C-c C-e.
 373
 374 (defun lisp-eval-region-and-go (start end)
 375   "Send the current region to the inferior Lisp, and switch to its buffer."
 376   (interactive "r")
 377   (lisp-eval-region start end t))
 378
 379 (defun lisp-eval-defun-and-go ()
 380   "Send the current defun to the inferior Lisp, and switch to its buffer."
 381   (interactive)
 382   (lisp-eval-defun t))
 383
 384 (defun lisp-compile-region-and-go (start end)
 385   "Compile the current region in the inferior Lisp, and switch to its buffer."
 386   (interactive "r")
 387   (lisp-compile-region start end t))
 388
 389 (defun lisp-compile-defun-and-go ()
 390   "Compile the current defun in the inferior Lisp, and switch to its buffer."
 391   (interactive)
 392   (lisp-compile-defun t))
 393
 394 ;;; A version of the form in H. Shevis' soar-mode.el package. Less robust.
 395 ;;; (defun lisp-compile-sexp (start end)
 396 ;;;   "Compile the s-expression bounded by START and END in the inferior lisp.
 397 ;;; If the sexp isn't a DEFUN form, it is evaluated instead."
 398 ;;;   (cond ((looking-at "(defun\\s +")
 399 ;;;      (goto-char (match-end 0))
 400 ;;;      (let ((name-start (point)))
 401 ;;;        (forward-sexp 1)
 402 ;;;        (process-send-string "inferior-lisp"
 403 ;;;                             (format "(compile '%s #'(lambda "
 404 ;;;                                     (buffer-substring name-start
 405 ;;;                                                       (point)))))
 406 ;;;      (let ((body-start (point)))
 407 ;;;        (goto-char start) (forward-sexp 1) ; Can't use end-of-defun.
 408 ;;;        (process-send-region "inferior-lisp"
 409 ;;;                             (buffer-substring body-start (point))))
 410 ;;;      (process-send-string "inferior-lisp" ")\n"))
 411 ;;;     (t (lisp-eval-region start end)))))
 412 ;;;
 413 ;;; (defun lisp-compile-region (start end)
 414 ;;;   "Each s-expression in the current region is compiled (if a DEFUN)
 415 ;;; or evaluated (if not) in the inferior lisp."
 416 ;;;   (interactive "r")
 417 ;;;   (save-excursion
 418 ;;;     (goto-char start) (end-of-defun) (beginning-of-defun) ; error check
 419 ;;;     (if (< (point) start) (error "region begins in middle of defun"))
 420 ;;;     (goto-char start)
 421 ;;;     (let ((s start))
 422 ;;;       (end-of-defun)
 423 ;;;       (while (<= (point) end) ; Zip through
 424 ;;;     (lisp-compile-sexp s (point)) ; compiling up defun-sized chunks.
 425 ;;;     (setq s (point))
 426 ;;;     (end-of-defun))
 427 ;;;       (if (< s end) (lisp-compile-sexp s end)))))
 428 ;;;
 429 ;;; End of HS-style code
 430
 431
 432 (defvar lisp-prev-l/c-dir/file nil
 433   "Record last directory and file used in loading or compiling.
 434 This holds a cons cell of the form `(DIRECTORY . FILE)'
 435 describing the last `lisp-load-file' or `lisp-compile-file' command.")
 436
 437 (defvar lisp-source-modes '(lisp-mode)
 438   "*Used to determine if a buffer contains Lisp source code.
 439 If it's loaded into a buffer that is in one of these major modes, it's
 440 considered a Lisp source file by `lisp-load-file' and `lisp-compile-file'.
 441 Used by these commands to determine defaults.")
 442
 443 (defun lisp-load-file (file-name)
 444   "Load a Lisp file into the inferior Lisp process."
 445   (interactive (comint-get-source "Load Lisp file: " lisp-prev-l/c-dir/file
 446                                   lisp-source-modes nil)) ; NIL because LOAD
 447                                         ; doesn't need an exact name
 448   (comint-check-source file-name) ; Check to see if buffer needs saved.
 449   (setq lisp-prev-l/c-dir/file (cons (file-name-directory    file-name)
 450                                      (file-name-nondirectory file-name)))
 451   (comint-send-string (inferior-lisp-proc)
 452                       (format inferior-lisp-load-command file-name))
 453   (switch-to-lisp t))
 454
 455
 456 (defun lisp-compile-file (file-name)
 457   "Compile a Lisp file in the inferior Lisp process."
 458   (interactive (comint-get-source "Compile Lisp file: " lisp-prev-l/c-dir/file
 459                                   lisp-source-modes nil)) ; NIL = don't need
 460                                         ; suffix .lisp
 461   (comint-check-source file-name) ; Check to see if buffer needs saved.
 462   (setq lisp-prev-l/c-dir/file (cons (file-name-directory    file-name)
 463                                      (file-name-nondirectory file-name)))
 464   (comint-send-string (inferior-lisp-proc) (concat "(compile-file \""
 465                                                    file-name
 466                                                    "\"\)\n"))
 467   (switch-to-lisp t))
 468
 469
 470 \f
 471 ;;; Documentation functions: function doc, var doc, arglist, and
 472 ;;; describe symbol.
 473 ;;; ===========================================================================
 474
 475 ;;; Command strings
 476 ;;; ===============
 477
 478 (defvar lisp-function-doc-command
 479   "(let ((fn '%s))
 480      (format t \"Documentation for ~a:~&~a\"
 481              fn (documentation fn 'function))
 482      (values))\n"
 483   "Command to query inferior Lisp for a function's documentation.")
 484
 485 (defvar lisp-var-doc-command
 486   "(let ((v '%s))
 487      (format t \"Documentation for ~a:~&~a\"
 488              v (documentation v 'variable))
 489      (values))\n"
 490   "Command to query inferior Lisp for a variable's documentation.")
 491
 492 (defvar lisp-arglist-command
 493   "(let ((fn '%s))
 494      (format t \"Arglist for ~a: ~a\" fn (arglist fn))
 495      (values))\n"
 496   "Command to query inferior Lisp for a function's arglist.")
 497
 498 (defvar lisp-describe-sym-command
 499   "(describe '%s)\n"
 500   "Command to query inferior Lisp for a variable's documentation.")
 501
 502
 503 ;;; Ancillary functions
 504 ;;; ===================
 505
 506 ;;; Reads a string from the user.
 507 (defun lisp-symprompt (prompt default)
 508   (list (let* ((prompt (if default
 509                            (format "%s (default %s): " prompt default)
 510                          (concat prompt ": ")))
 511                (ans (read-string prompt)))
 512           (if (zerop (length ans)) default ans))))
 513
 514
 515 ;;; Adapted from function-called-at-point in help.el.
 516 (defun lisp-fn-called-at-pt ()
 517   "Returns the name of the function called in the current call.
 518 The value is nil if it can't find one."
 519   (condition-case nil
 520       (save-excursion
 521         (save-restriction
 522           (narrow-to-region (max (point-min) (- (point) 1000)) (point-max))
 523           (backward-up-list 1)
 524           (forward-char 1)
 525           (let ((obj (read (current-buffer))))
 526             (and (symbolp obj) obj))))
 527     (error nil)))
 528
 529
 530 ;;; Adapted from variable-at-point in help.el.
 531 (defun lisp-var-at-pt ()
 532   (condition-case ()
 533       (save-excursion
 534         (forward-sexp -1)
 535         (skip-chars-forward "'")
 536         (let ((obj (read (current-buffer))))
 537           (and (symbolp obj) obj)))
 538     (error nil)))
 539
 540
 541 ;;; Documentation functions: fn and var doc, arglist, and symbol describe.
 542 ;;; ======================================================================
 543
 544 (defun lisp-show-function-documentation (fn)
 545   "Send a command to the inferior Lisp to give documentation for function FN.
 546 See variable `lisp-function-doc-command'."
 547   (interactive (lisp-symprompt "Function doc" (lisp-fn-called-at-pt)))
 548   (comint-proc-query (inferior-lisp-proc)
 549                      (format lisp-function-doc-command fn)))
 550
 551 (defun lisp-show-variable-documentation (var)
 552   "Send a command to the inferior Lisp to give documentation for function FN.
 553 See variable `lisp-var-doc-command'."
 554   (interactive (lisp-symprompt "Variable doc" (lisp-var-at-pt)))
 555   (comint-proc-query (inferior-lisp-proc) (format lisp-var-doc-command var)))
 556
 557 (defun lisp-show-arglist (fn)
 558   "Send a query to the inferior Lisp for the arglist for function FN.
 559 See variable `lisp-arglist-command'."
 560   (interactive (lisp-symprompt "Arglist" (lisp-fn-called-at-pt)))
 561   (comint-proc-query (inferior-lisp-proc) (format lisp-arglist-command fn)))
 562
 563 (defun lisp-describe-sym (sym)
 564   "Send a command to the inferior Lisp to describe symbol SYM.
 565 See variable `lisp-describe-sym-command'."
 566   (interactive (lisp-symprompt "Describe" (lisp-var-at-pt)))
 567   (comint-proc-query (inferior-lisp-proc)
 568                      (format lisp-describe-sym-command sym)))
 569
 570 \f
 571 ;;  "Returns the current inferior Lisp process.
 572 ;; See variable `inferior-lisp-buffer'."
 573 (defun inferior-lisp-proc ()
 574   (let ((proc (get-buffer-process (if (eq major-mode 'inferior-lisp-mode)
 575                                       (current-buffer)
 576                                     inferior-lisp-buffer))))
 577     (or proc
 578         (error "No Lisp subprocess; see variable `inferior-lisp-buffer'"))))
 579
 580
 581 ;;; Do the user's customisation...
 582 ;;;===============================
 583 (defvar inferior-lisp-load-hook nil
 584   "This hook is run when the library `inf-lisp' is loaded.
 585 This is a good place to put keybindings.")
 586
 587 (run-hooks 'inferior-lisp-load-hook)
 588
 589 ;;; CHANGE LOG
 590 ;;; ===========================================================================
 591 ;;; 7/21/92 Jim Blandy
 592 ;;; - Changed all uses of the cmulisp name or prefix to inferior-lisp;
 593 ;;;   this is now the official inferior lisp package.  Use the global
 594 ;;;   ChangeLog from now on.
 595 ;;; 5/24/90 Olin
 596 ;;; - Split cmulisp and cmushell modes into separate files.
 597 ;;;   Not only is this a good idea, it's apparently the way it'll be rel 19.
 598 ;;; - Upgraded process sends to use comint-send-string instead of
 599 ;;;   process-send-string.
 600 ;;; - Explicit references to process "cmulisp" have been replaced with
 601 ;;;   (cmulisp-proc). This allows better handling of multiple process bufs.
 602 ;;; - Added process query and var/function/symbol documentation
 603 ;;;   commands. Based on code written by Douglas Roberts.
 604 ;;; - Added lisp-eval-last-sexp, bound to C-x C-e.
 605 ;;;
 606 ;;; 9/20/90 Olin
 607 ;;; Added a save-restriction to lisp-fn-called-at-pt. This bug and fix
 608 ;;; reported by Lennart Staflin.
 609 ;;;
 610 ;;; 3/12/90 Olin
 611 ;;; - lisp-load-file and lisp-compile-file no longer switch-to-lisp.
 612 ;;;   Tale suggested this.
 613 ;;; - Reversed this decision 7/15/91. You need the visual feedback.
 614 ;;;
 615 ;;; 7/25/91 Olin
 616 ;;; Changed all keybindings of the form C-c <letter>. These are
 617 ;;; supposed to be reserved for the user to bind. This affected
 618 ;;; mainly the compile/eval-defun/region[-and-go] commands.
 619 ;;; This was painful, but necessary to adhere to the gnumacs standard.
 620 ;;; For some backwards compatibility, see the
 621 ;;;     cmulisp-install-letter-bindings
 622 ;;; function.
 623 ;;;
 624 ;;; 8/2/91 Olin
 625 ;;; - The lisp-compile/eval-defun/region commands now take a prefix arg,
 626 ;;;   which means switch-to-lisp after sending the text to the Lisp process.
 627 ;;;   This obsoletes all the -and-go commands. The -and-go commands are
 628 ;;;   kept around for historical reasons, and because the user can bind
 629 ;;;   them to key sequences shorter than C-u C-c C-<letter>.
 630 ;;; - If M-x cmulisp is invoked with a prefix arg, it allows you to
 631 ;;;   edit the command line.
 632
 633 (provide 'inf-lisp)
 634
 635 ;;; inf-lisp.el ends here