lisp/progmodes/inf-lisp.el

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