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