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