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 67;;;###autoload 68(defvar inferior-lisp-filter-regexp "\\`\\s *\\(:\\(\\w\\|\\s_\\)\\)?\\s *\\'" 69 "*What not to save on inferior Lisp's input history. 70Input matching this regexp is not saved on the input history in Inferior Lisp 71mode. 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. 144This format string should use `%s' to substitute a file name 145and should result in a Lisp expression that will command the inferior Lisp 146to load that file. The default works acceptably on most Lisps. 147The string \"(progn (load \\\"%s\\\" :verbose nil :print t) (values))\\\n\" 148produces cosmetically superior output for this application, 149but 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. 154Defaults to \"^[^> \\n]*>+:? *\", which works pretty good for Lucid, kcl, 155and franz. This variable is used to initialize `comint-prompt-regexp' in the 156Inferior Lisp buffer. 157 158More precise choices: 159Lucid Common Lisp: \"^\\(>\\|\\(->\\)+\\) *\" 160franz: \"^\\(->\\|<[0-9]*>:\\) *\" 161kcl: \"^>+ *\" 162 163This is a fine thing to set in your .emacs file.") 164 165(defvar inferior-lisp-buffer nil "*The current inferior-lisp process buffer. 166 167MULTIPLE PROCESS SUPPORT 168=========================================================================== 169To run multiple Lisp processes, you start the first up 170with \\[inferior-lisp]. It will be in a buffer named `*inferior-lisp*'. 171Rename this buffer with \\[rename-buffer]. You may now start up a new 172process with another \\[inferior-lisp]. It will be in a new buffer, 173named `*inferior-lisp*'. You can switch between the different process 174buffers with \\[switch-to-buffer]. 175 176Commands that send text from source buffers to Lisp processes -- 177like `lisp-eval-defun' or `lisp-show-arglist' -- have to choose a process 178to send to, when you have more than one Lisp process around. This 179is determined by the global variable `inferior-lisp-buffer'. Suppose you 180have three inferior Lisps running: 181 Buffer Process 182 foo inferior-lisp 183 bar inferior-lisp<2> 184 *inferior-lisp* inferior-lisp<3> 185If you do a \\[lisp-eval-defun] command on some Lisp source code, 186what 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'. 192This process selection is performed by function `inferior-lisp-proc'. 193 194Whenever \\[inferior-lisp] fires up a new process, it resets 195`inferior-lisp-buffer' to be the new process's buffer. If you only run 196one process, this does the right thing. If you run multiple 197processes, you can change `inferior-lisp-buffer' to another process 198buffer 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. 206Runs a Lisp interpreter as a subprocess of Emacs, with Lisp I/O through an 207Emacs buffer. Variable `inferior-lisp-program' controls which Lisp interpreter 208is run. Variables `inferior-lisp-prompt', `inferior-lisp-filter-regexp' and 209`inferior-lisp-load-command' can customize this mode for different Lisp 210interpreters. 211 212For information on running multiple processes in multiple buffers, see 213documentation for variable `inferior-lisp-buffer'. 214 215\\{inferior-lisp-mode-map} 216 217Customisation: Entry to this mode runs the hooks on `comint-mode-hook' and 218`inferior-lisp-mode-hook' (in that order). 219 220You can send text to the inferior Lisp process from other buffers containing 221Lisp 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 232Commands: 233Return after the end of the process' output sends the text from the 234 end of process to point. 235Return before the end of the process' output copies the sexp ending at point 236 to the end of the process' output, and sends it. 237Delete converts tabs to spaces as it moves back. 238Tab indents for Lisp; with argument, shifts rest 239 of expression rigidly with the current line. 240C-M-q does Tab on each line starting within following expression. 241Paragraphs are separated only by blank lines. Semicolons start comments. 242If you accidentally suspend your process, use \\[comint-continue-subjob] 243to 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*'. 271If there is a process already running in `*inferior-lisp*', just switch 272to that buffer. 273With argument, allows you to edit the command line (default is value 274of `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 (switch-to-buffer "*inferior-lisp*")) 287 288;;;###autoload 289(defalias 'run-lisp 'inferior-lisp) 290 291;;; Break a string up into a list of arguments. 292;;; This will break if you have an argument with whitespace, as in 293;;; string = "-ab +c -x 'you lose'". 294(defun inferior-lisp-args-to-list (string) 295 (let ((where (string-match "[ \t]" string))) 296 (cond ((null where) (list string)) 297 ((not (= where 0)) 298 (cons (substring string 0 where) 299 (inferior-lisp-args-to-list (substring string (+ 1 where) 300 (length string))))) 301 (t (let ((pos (string-match "[^ \t]" string))) 302 (if (null pos) 303 nil 304 (inferior-lisp-args-to-list (substring string pos 305 (length string))))))))) 306 307(defun lisp-eval-region (start end &optional and-go) 308 "Send the current region to the inferior Lisp process. 309Prefix argument means switch to the Lisp buffer afterwards." 310 (interactive "r\nP") 311 (comint-send-region (inferior-lisp-proc) start end) 312 (comint-send-string (inferior-lisp-proc) "\n") 313 (if and-go (switch-to-lisp t))) 314 315(defun lisp-eval-defun (&optional and-go) 316 "Send the current defun to the inferior Lisp process. 317Prefix argument means switch to the Lisp buffer afterwards." 318 (interactive "P") 319 (save-excursion 320 (end-of-defun) 321 (skip-chars-backward " \t\n\r\f") ; Makes allegro happy 322 (let ((end (point))) 323 (beginning-of-defun) 324 (lisp-eval-region (point) end))) 325 (if and-go (switch-to-lisp t))) 326 327(defun lisp-eval-last-sexp (&optional and-go) 328 "Send the previous sexp to the inferior Lisp process. 329Prefix argument means switch to the Lisp buffer afterwards." 330 (interactive "P") 331 (lisp-eval-region (save-excursion (backward-sexp) (point)) (point) and-go)) 332 333;;; Common Lisp COMPILE sux. 334(defun lisp-compile-region (start end &optional and-go) 335 "Compile the current region in the inferior Lisp process. 336Prefix argument means switch to the Lisp buffer afterwards." 337 (interactive "r\nP") 338 (comint-send-string 339 (inferior-lisp-proc) 340 (format "(funcall (compile nil `(lambda () (progn 'compile %s))))\n" 341 (buffer-substring start end))) 342 (if and-go (switch-to-lisp t))) 343 344(defun lisp-compile-defun (&optional and-go) 345 "Compile the current defun in the inferior Lisp process. 346Prefix argument means switch to the Lisp buffer afterwards." 347 (interactive "P") 348 (save-excursion 349 (end-of-defun) 350 (skip-chars-backward " \t\n\r\f") ; Makes allegro happy 351 (let ((e (point))) 352 (beginning-of-defun) 353 (lisp-compile-region (point) e))) 354 (if and-go (switch-to-lisp t))) 355 356(defun switch-to-lisp (eob-p) 357 "Switch to the inferior Lisp process buffer. 358With argument, positions cursor at end of buffer." 359 (interactive "P") 360 (if (get-buffer inferior-lisp-buffer) 361 (pop-to-buffer inferior-lisp-buffer) 362 (error "No current inferior Lisp buffer")) 363 (cond (eob-p 364 (push-mark) 365 (goto-char (point-max))))) 366 367 368;;; Now that lisp-compile/eval-defun/region takes an optional prefix arg, 369;;; these commands are redundant. But they are kept around for the user 370;;; to bind if he wishes, for backwards functionality, and because it's 371;;; easier to type C-c e than C-u C-c C-e. 372 373(defun lisp-eval-region-and-go (start end) 374 "Send the current region to the inferior Lisp, and switch to its buffer." 375 (interactive "r") 376 (lisp-eval-region start end t)) 377 378(defun lisp-eval-defun-and-go () 379 "Send the current defun to the inferior Lisp, and switch to its buffer." 380 (interactive) 381 (lisp-eval-defun t)) 382 383(defun lisp-compile-region-and-go (start end) 384 "Compile the current region in the inferior Lisp, and switch to its buffer." 385 (interactive "r") 386 (lisp-compile-region start end t)) 387 388(defun lisp-compile-defun-and-go () 389 "Compile the current defun in the inferior Lisp, and switch to its buffer." 390 (interactive) 391 (lisp-compile-defun t)) 392 393;;; A version of the form in H. Shevis' soar-mode.el package. Less robust. 394;;; (defun lisp-compile-sexp (start end) 395;;; "Compile the s-expression bounded by START and END in the inferior lisp. 396;;; If the sexp isn't a DEFUN form, it is evaluated instead." 397;;; (cond ((looking-at "(defun\\s +") 398;;; (goto-char (match-end 0)) 399;;; (let ((name-start (point))) 400;;; (forward-sexp 1) 401;;; (process-send-string "inferior-lisp" 402;;; (format "(compile '%s #'(lambda " 403;;; (buffer-substring name-start 404;;; (point))))) 405;;; (let ((body-start (point))) 406;;; (goto-char start) (forward-sexp 1) ; Can't use end-of-defun. 407;;; (process-send-region "inferior-lisp" 408;;; (buffer-substring body-start (point)))) 409;;; (process-send-string "inferior-lisp" ")\n")) 410;;; (t (lisp-eval-region start end))))) 411;;; 412;;; (defun lisp-compile-region (start end) 413;;; "Each s-expression in the current region is compiled (if a DEFUN) 414;;; or evaluated (if not) in the inferior lisp." 415;;; (interactive "r") 416;;; (save-excursion 417;;; (goto-char start) (end-of-defun) (beginning-of-defun) ; error check 418;;; (if (< (point) start) (error "region begins in middle of defun")) 419;;; (goto-char start) 420;;; (let ((s start)) 421;;; (end-of-defun) 422;;; (while (<= (point) end) ; Zip through 423;;; (lisp-compile-sexp s (point)) ; compiling up defun-sized chunks. 424;;; (setq s (point)) 425;;; (end-of-defun)) 426;;; (if (< s end) (lisp-compile-sexp s end))))) 427;;; 428;;; End of HS-style code 429 430 431(defvar lisp-prev-l/c-dir/file nil 432 "Record last directory and file used in loading or compiling. 433This holds a cons cell of the form `(DIRECTORY . FILE)' 434describing the last `lisp-load-file' or `lisp-compile-file' command.") 435 436(defvar lisp-source-modes '(lisp-mode) 437 "*Used to determine if a buffer contains Lisp source code. 438If it's loaded into a buffer that is in one of these major modes, it's 439considered a Lisp source file by `lisp-load-file' and `lisp-compile-file'. 440Used by these commands to determine defaults.") 441 442(defun lisp-load-file (file-name) 443 "Load a Lisp file into the inferior Lisp process." 444 (interactive (comint-get-source "Load Lisp file: " lisp-prev-l/c-dir/file 445 lisp-source-modes nil)) ; NIL because LOAD 446 ; doesn't need an exact name 447 (comint-check-source file-name) ; Check to see if buffer needs saved. 448 (setq lisp-prev-l/c-dir/file (cons (file-name-directory file-name) 449 (file-name-nondirectory file-name))) 450 (comint-send-string (inferior-lisp-proc) 451 (format inferior-lisp-load-command file-name)) 452 (switch-to-lisp t)) 453 454 455(defun lisp-compile-file (file-name) 456 "Compile a Lisp file in the inferior Lisp process." 457 (interactive (comint-get-source "Compile Lisp file: " lisp-prev-l/c-dir/file 458 lisp-source-modes nil)) ; NIL = don't need 459 ; suffix .lisp 460 (comint-check-source file-name) ; Check to see if buffer needs saved. 461 (setq lisp-prev-l/c-dir/file (cons (file-name-directory file-name) 462 (file-name-nondirectory file-name))) 463 (comint-send-string (inferior-lisp-proc) (concat "(compile-file \"" 464 file-name 465 "\"\)\n")) 466 (switch-to-lisp t)) 467 468 469 470;;; Documentation functions: function doc, var doc, arglist, and 471;;; describe symbol. 472;;; =========================================================================== 473 474;;; Command strings 475;;; =============== 476 477(defvar lisp-function-doc-command 478 "(let ((fn '%s)) 479 (format t \"Documentation for ~a:~&~a\" 480 fn (documentation fn 'function)) 481 (values))\n" 482 "Command to query inferior Lisp for a function's documentation.") 483 484(defvar lisp-var-doc-command 485 "(let ((v '%s)) 486 (format t \"Documentation for ~a:~&~a\" 487 v (documentation v 'variable)) 488 (values))\n" 489 "Command to query inferior Lisp for a variable's documentation.") 490 491(defvar lisp-arglist-command 492 "(let ((fn '%s)) 493 (format t \"Arglist for ~a: ~a\" fn (arglist fn)) 494 (values))\n" 495 "Command to query inferior Lisp for a function's arglist.") 496 497(defvar lisp-describe-sym-command 498 "(describe '%s)\n" 499 "Command to query inferior Lisp for a variable's documentation.") 500 501 502;;; Ancillary functions 503;;; =================== 504 505;;; Reads a string from the user. 506(defun lisp-symprompt (prompt default) 507 (list (let* ((prompt (if default 508 (format "%s (default %s): " prompt default) 509 (concat prompt ": "))) 510 (ans (read-string prompt))) 511 (if (zerop (length ans)) default ans)))) 512 513 514;;; Adapted from function-called-at-point in help.el. 515(defun lisp-fn-called-at-pt () 516 "Returns the name of the function called in the current call. 517The value is nil if it can't find one." 518 (condition-case nil 519 (save-excursion 520 (save-restriction 521 (narrow-to-region (max (point-min) (- (point) 1000)) (point-max)) 522 (backward-up-list 1) 523 (forward-char 1) 524 (let ((obj (read (current-buffer)))) 525 (and (symbolp obj) obj)))) 526 (error nil))) 527 528 529;;; Adapted from variable-at-point in help.el. 530(defun lisp-var-at-pt () 531 (condition-case () 532 (save-excursion 533 (forward-sexp -1) 534 (skip-chars-forward "'") 535 (let ((obj (read (current-buffer)))) 536 (and (symbolp obj) obj))) 537 (error nil))) 538 539 540;;; Documentation functions: fn and var doc, arglist, and symbol describe. 541;;; ====================================================================== 542 543(defun lisp-show-function-documentation (fn) 544 "Send a command to the inferior Lisp to give documentation for function FN. 545See variable `lisp-function-doc-command'." 546 (interactive (lisp-symprompt "Function doc" (lisp-fn-called-at-pt))) 547 (comint-proc-query (inferior-lisp-proc) 548 (format lisp-function-doc-command fn))) 549 550(defun lisp-show-variable-documentation (var) 551 "Send a command to the inferior Lisp to give documentation for function FN. 552See variable `lisp-var-doc-command'." 553 (interactive (lisp-symprompt "Variable doc" (lisp-var-at-pt))) 554 (comint-proc-query (inferior-lisp-proc) (format lisp-var-doc-command var))) 555 556(defun lisp-show-arglist (fn) 557 "Send a query to the inferior Lisp for the arglist for function FN. 558See variable `lisp-arglist-command'." 559 (interactive (lisp-symprompt "Arglist" (lisp-fn-called-at-pt))) 560 (comint-proc-query (inferior-lisp-proc) (format lisp-arglist-command fn))) 561 562(defun lisp-describe-sym (sym) 563 "Send a command to the inferior Lisp to describe symbol SYM. 564See variable `lisp-describe-sym-command'." 565 (interactive (lisp-symprompt "Describe" (lisp-var-at-pt))) 566 (comint-proc-query (inferior-lisp-proc) 567 (format lisp-describe-sym-command sym))) 568 569 570;; "Returns the current inferior Lisp process. 571;; See variable `inferior-lisp-buffer'." 572(defun inferior-lisp-proc () 573 (let ((proc (get-buffer-process (if (eq major-mode 'inferior-lisp-mode) 574 (current-buffer) 575 inferior-lisp-buffer)))) 576 (or proc 577 (error "No Lisp subprocess; see variable `inferior-lisp-buffer'")))) 578 579 580;;; Do the user's customisation... 581;;;=============================== 582(defvar inferior-lisp-load-hook nil 583 "This hook is run when the library `inf-lisp' is loaded. 584This is a good place to put keybindings.") 585 586(run-hooks 'inferior-lisp-load-hook) 587 588;;; CHANGE LOG 589;;; =========================================================================== 590;;; 7/21/92 Jim Blandy 591;;; - Changed all uses of the cmulisp name or prefix to inferior-lisp; 592;;; this is now the official inferior lisp package. Use the global 593;;; ChangeLog from now on. 594;;; 5/24/90 Olin 595;;; - Split cmulisp and cmushell modes into separate files. 596;;; Not only is this a good idea, it's apparently the way it'll be rel 19. 597;;; - Upgraded process sends to use comint-send-string instead of 598;;; process-send-string. 599;;; - Explicit references to process "cmulisp" have been replaced with 600;;; (cmulisp-proc). This allows better handling of multiple process bufs. 601;;; - Added process query and var/function/symbol documentation 602;;; commands. Based on code written by Douglas Roberts. 603;;; - Added lisp-eval-last-sexp, bound to C-x C-e. 604;;; 605;;; 9/20/90 Olin 606;;; Added a save-restriction to lisp-fn-called-at-pt. This bug and fix 607;;; reported by Lennart Staflin. 608;;; 609;;; 3/12/90 Olin 610;;; - lisp-load-file and lisp-compile-file no longer switch-to-lisp. 611;;; Tale suggested this. 612;;; - Reversed this decision 7/15/91. You need the visual feedback. 613;;; 614;;; 7/25/91 Olin 615;;; Changed all keybindings of the form C-c <letter>. These are 616;;; supposed to be reserved for the user to bind. This affected 617;;; mainly the compile/eval-defun/region[-and-go] commands. 618;;; This was painful, but necessary to adhere to the gnumacs standard. 619;;; For some backwards compatibility, see the 620;;; cmulisp-install-letter-bindings 621;;; function. 622;;; 623;;; 8/2/91 Olin 624;;; - The lisp-compile/eval-defun/region commands now take a prefix arg, 625;;; which means switch-to-lisp after sending the text to the Lisp process. 626;;; This obsoletes all the -and-go commands. The -and-go commands are 627;;; kept around for historical reasons, and because the user can bind 628;;; them to key sequences shorter than C-u C-c C-<letter>. 629;;; - If M-x cmulisp is invoked with a prefix arg, it allows you to 630;;; edit the command line. 631 632(provide 'inf-lisp) 633 634;;; inf-lisp.el ends here 635