;;; compiled by eric@geech.gnu.ai.mit.edu on Mon Mar 22 13:26:37 1993 ;;; from file /gd/gnu/emacs/19.0/lisp/cmulisp.el ;;; emacs version 19.0.506. ;;; bytecomp version FSF 2.08 ;;; optimization is on. (byte-code "!!" [require comint] 2) (defvar cmulisp-filter-regexp "\\`\\s *\\(:\\(\\w\\|\\s_\\)\\)?\\s *\\'" "\ *What not to save on inferior Lisp's input history Input matching this regexp is not saved on the input history in cmulisp mode. Default is whitespace followed by 0 or 1 single-letter :keyword (as in :a, :c, etc.)") (byte-code "! > !\" # # # # # # #############" [boundp cmulisp-mode-map nil nconc full-copy-sparse-keymap comint-mode-map shared-lisp-mode-map define-key "" lisp-eval-last-sexp " " lisp-load-file " " lisp-compile-file "" lisp-show-arglist "" lisp-describe-sym "" lisp-show-function-documentation "" lisp-show-variable-documentation lisp-mode-map "" lisp-eval-defun "" "" lisp-eval-region "" lisp-compile-defun "" switch-to-lisp] 4) (fset 'cmulisp-install-letter-bindings #[nil " # # # # # # # # # #######" [define-key lisp-mode-map "e" lisp-eval-defun-and-go "r" lisp-eval-region-and-go "c" lisp-compile-defun-and-go "z" switch-to-lisp "l" lisp-load-file "k" lisp-compile-file "a" lisp-show-arglist "d" lisp-describe-sym "f" lisp-show-function-documentation "v" lisp-show-variable-documentation cmulisp-mode-map] 4 "\ This function binds many cmulisp commands to C-c bindings, where they are more accessible. C-c bindings are reserved for the user, so these bindings are non-standard. If you want them, you should have this function called by the cmulisp-load-hook: (setq cmulisp-load-hook '(cmulisp-install-letter-bindings)) You can modify this function to install just the bindings you want."]) (defvar inferior-lisp-program "lisp" "\ *Program name for invoking an inferior Lisp with `cmulisp'.") (defvar inferior-lisp-load-command "(load \"%s\")\n" "\ *Format-string for building a Lisp expression to load a file. This format string should use %s to substitute a file name and should result in a Lisp expression that will command the inferior Lisp to load that file. The default works acceptably on most Lisps. The string \"(progn (load \\\"%s\\\" :verbose nil :print t) (values))\\ \" produces cosmetically superior output for this application, but it works only in Common Lisp.") (defvar inferior-lisp-prompt "^[^> ]*>+:? *" "\ Regexp to recognise prompts in the inferior Lisp. Defaults to \"^[^> ]*>+:? *\", which works pretty good for Lucid, kcl, and franz. This variable is used to initialise comint-prompt-regexp in the cmulisp buffer. More precise choices: Lucid Common Lisp: \"^\\(>\\|\\(->\\)+\\) *\" franz: \"^\\(->\\|<[0-9]*>:\\) *\" kcl: \"^>+ *\" This is a fine thing to set in your .emacs file.") (defvar cmulisp-mode-hook nil "\ *Hook for customising cmulisp mode") (fset 'cmulisp-mode #[nil " ! !!" [comint-mode inferior-lisp-prompt comint-prompt-regexp cmulisp-mode major-mode "CMU Lisp" mode-name (": %s") mode-line-process lisp-mode-variables t use-local-map cmulisp-mode-map lisp-get-old-input comint-get-old-input lisp-input-filter comint-input-filter ignore comint-input-sentinel run-hooks cmulisp-mode-hook] 2 "\ Major mode for interacting with an inferior Lisp process. Runs a Lisp interpreter as a subprocess of Emacs, with Lisp I/O through an Emacs buffer. Variable inferior-lisp-program controls which Lisp interpreter is run. Variables inferior-lisp-prompt, cmulisp-filter-regexp and inferior-lisp-load-command can customize this mode for different Lisp interpreters. For information on running multiple processes in multiple buffers, see documentation for variable cmulisp-buffer. \\{cmulisp-mode-map} Customisation: Entry to this mode runs the hooks on comint-mode-hook and cmulisp-mode-hook (in that order). You can send text to the inferior Lisp process from other buffers containing Lisp source. switch-to-lisp switches the current buffer to the Lisp process buffer. lisp-eval-defun sends the current defun to the Lisp process. lisp-compile-defun compiles the current defun. lisp-eval-region sends the current region to the Lisp process. lisp-compile-region compiles the current region. Prefixing the lisp-eval/compile-defun/region commands with a \\[universal-argument] causes a switch to the Lisp process buffer after sending the text. Commands: Return after the end of the process' output sends the text from the end of process to point. Return before the end of the process' output copies the sexp ending at point to the end of the process' output, and sends it. Delete converts tabs to spaces as it moves back. Tab indents for Lisp; with argument, shifts rest of expression rigidly with the current line. C-M-q does Tab on each line starting within following expression. Paragraphs are separated only by blank lines. Semicolons start comments. If you accidentally suspend your process, use \\[comint-continue-subjob] to continue it." nil]) (fset 'lisp-get-old-input #[nil "` `\"*" [end backward-sexp buffer-substring] 3 "\ Snarf the sexp ending at point"]) (fset 'lisp-input-filter #[(str) " \n\"?" [string-match cmulisp-filter-regexp str] 3 "\ Don't save anything matching cmulisp-filter-regexp"]) (fset 'cmulisp #[(cmd) "! ! @ A%q )\n!" [comint-check-proc "*cmulisp*" cmulisp-args-to-list cmd cmdlist apply make-comint "cmulisp" nil cmulisp-mode cmulisp-buffer switch-to-buffer] 6 "\ Run an inferior Lisp process, input and output via buffer *cmulisp*. If there is a process already running in *cmulisp*, just switch to that buffer. With argument, allows you to edit the command line (default is value of inferior-lisp-program). Runs the hooks from cmulisp-mode-hook (after the comint-mode-hook is run). (Type \\[describe-mode] in the process buffer for a list of commands.)" (list (if current-prefix-arg (read-string "Run lisp: " inferior-lisp-program) inferior-lisp-program))]) (fset (quote cmulisp-args-to-list) #[(string) "\n\"\nC: U%\n O\n \\\nGO!B:\n\"??9\n\nGO!))" [string-match "[ ]" string where 0 tea-args-to-list 1 "[^ ]" pos cmulisp-args-to-list] 6]) (fset 'lisp-eval-region #[(start end &optional and-go) " \n # \"!" [comint-send-region cmulisp-proc start end comint-send-string "\n" and-go switch-to-lisp t] 4 "\ Send the current region to the inferior Lisp process. Prefix argument means switch-to-lisp afterwards." "r\nP"]) (fset 'lisp-eval-defun #[(&optional and-go) " !` ` \"*!" [end-of-defun skip-chars-backward " \n " end beginning-of-defun lisp-eval-region and-go switch-to-lisp t] 3 "\ Send the current defun to the inferior Lisp process. Prefix argument means switch-to-lisp afterwards." "P"]) (fset 'lisp-eval-last-sexp #[(&optional and-go) " `)`\n#" [lisp-eval-region backward-sexp and-go] 4 "\ Send the previous sexp to the inferior Lisp process. Prefix argument means switch-to-lisp afterwards." "P"]) (fset 'lisp-compile-region #[(start end &optional and-go) " \"\"\"!" [comint-send-string cmulisp-proc format "(funcall (compile nil `(lambda () (progn 'compile %s))))\n" buffer-substring start end and-go switch-to-lisp t] 7 "\ Compile the current region in the inferior Lisp process. Prefix argument means switch-to-lisp afterwards." "r\nP"]) (fset 'lisp-compile-defun #[(&optional and-go) " !` ` \"*!" [end-of-defun skip-chars-backward " \n " e beginning-of-defun lisp-compile-region and-go switch-to-lisp t] 3 "\ Compile the current defun in the inferior Lisp process. Prefix argument means switch-to-lisp afterwards." "P"]) (fset 'switch-to-lisp #[(eob-p) " ! !!  db" [get-buffer cmulisp-buffer pop-to-buffer error "No current process buffer. See variable cmulisp-buffer." eob-p push-mark] 2 "\ Switch to the inferior Lisp process buffer. With argument, positions cursor at end of buffer." "P"]) (fset 'lisp-eval-region-and-go #[(start end) " \n#" [lisp-eval-region start end t] 4 "\ Send the current region to the inferior Lisp, and switch to the process buffer." "r"]) (fset 'lisp-eval-defun-and-go #[nil "!" [lisp-eval-defun t] 2 "\ Send the current defun to the inferior Lisp, and switch to the process buffer." nil]) (fset 'lisp-compile-region-and-go #[(start end) " \n#" [lisp-compile-region start end t] 4 "\ Compile the current region in the inferior Lisp, and switch to the process buffer." "r"]) (fset 'lisp-compile-defun-and-go #[nil "!" [lisp-compile-defun t] 2 "\ Compile the current defun in the inferior Lisp, and switch to the process buffer." nil]) (defvar lisp-prev-l/c-dir/file nil "\ Saves the (directory . file) pair used in the last lisp-load-file or lisp-compile-file command. Used for determining the default in the next one.") (defvar lisp-source-modes (quote (lisp-mode)) "\ *Used to determine if a buffer contains Lisp source code. If it's loaded into a buffer that is in one of these major modes, it's considered a Lisp source file by lisp-load-file and lisp-compile-file. Used by these commands to determine defaults.") (fset 'lisp-load-file #[(file-name) " ! ! !B  \"\"!" [comint-check-source file-name file-name-directory file-name-nondirectory lisp-prev-l/c-dir/file comint-send-string cmulisp-proc format inferior-lisp-load-command switch-to-lisp t] 5 "\ Load a Lisp file into the inferior Lisp process." (comint-get-source "Load Lisp file: " lisp-prev-l/c-dir/file lisp-source-modes nil)]) (fset 'lisp-compile-file #[(file-name) " ! ! !B Q\"!" [comint-check-source file-name file-name-directory file-name-nondirectory lisp-prev-l/c-dir/file comint-send-string cmulisp-proc "(compile-file \"" "\")\n" switch-to-lisp t] 5 "\ Compile a Lisp file in the inferior Lisp process." (comint-get-source "Compile Lisp file: " lisp-prev-l/c-dir/file lisp-source-modes nil)]) (defvar lisp-function-doc-command "(let ((fn '%s))\n (format t \"Documentation for ~a:~&~a\"\n fn (documentation fn 'function))\n (values))\n" "\ Command to query inferior Lisp for a function's documentation.") (defvar lisp-var-doc-command "(let ((v '%s))\n (format t \"Documentation for ~a:~&~a\"\n v (documentation v 'variable))\n (values))\n" "\ Command to query inferior Lisp for a variable's documentation.") (defvar lisp-arglist-command "(let ((fn '%s))\n (format t \"Arglist for ~a: ~a\" fn (arglist fn))\n (values))\n" "\ Command to query inferior Lisp for a function's arglist.") (defvar lisp-describe-sym-command "(describe '%s)\n" "\ Command to query inferior Lisp for a variable's documentation.") (fset (quote lisp-symprompt) #[(prompt default) " # P !GU \"*C" [default format "%s (default %s): " prompt ": " read-string ans 0] 5]) (fset 'lisp-fn-called-at-pt #[nil "" [nil (byte-code "e`Z]d\"!!p!9+" [narrow-to-region 1000 backward-up-list 1 forward-char read obj] 5) ((error))] 3 "\ Returns the name of the function called in the current call. Nil if it can't find one."]) (fset (quote lisp-var-at-pt) #[nil "" [nil (byte-code "!!p!9 *" [forward-sexp -1 skip-chars-forward "'" read obj] 3) ((error))] 3]) (fset 'lisp-show-function-documentation #[(fn) " \"\"" [comint-proc-query cmulisp-proc format lisp-function-doc-command fn] 5 "\ Send a command to the inferior Lisp to give documentation for function FN. See variable lisp-function-doc-command." (byte-code " \"" [lisp-symprompt "Function doc" lisp-fn-called-at-pt] 3)]) (fset 'lisp-show-variable-documentation #[(var) " \"\"" [comint-proc-query cmulisp-proc format lisp-var-doc-command var] 5 "\ Send a command to the inferior Lisp to give documentation for function FN. See variable lisp-var-doc-command." (byte-code " \"" [lisp-symprompt "Variable doc" lisp-var-at-pt] 3)]) (fset 'lisp-show-arglist #[(fn) " \"\"" [comint-proc-query cmulisp-proc format lisp-arglist-command fn] 5 "\ Sends an query to the inferior Lisp for the arglist for function FN. See variable lisp-arglist-command." (byte-code " \"" [lisp-symprompt "Arglist" lisp-fn-called-at-pt] 3)]) (fset 'lisp-describe-sym #[(sym) " \"\"" [comint-proc-query cmulisp-proc format lisp-describe-sym-command sym] 5 "\ Send a command to the inferior Lisp to describe symbol SYM. See variable lisp-describe-sym-command." (byte-code " \"" [lisp-symprompt "Describe" lisp-var-at-pt] 3)]) (defvar cmulisp-buffer nil "\ *The current cmulisp process buffer. MULTIPLE PROCESS SUPPORT =========================================================================== Cmulisp.el supports, in a fairly simple fashion, running multiple Lisp processes. To run multiple Lisp processes, you start the first up with \\[cmulisp]. It will be in a buffer named *cmulisp*. Rename this buffer with \\[rename-buffer]. You may now start up a new process with another \\[cmulisp]. It will be in a new buffer, named *cmulisp*. You can switch between the different process buffers with \\[switch-to-buffer]. Commands that send text from source buffers to Lisp processes -- like lisp-eval-defun or lisp-show-arglist -- have to choose a process to send to, when you have more than one Lisp process around. This is determined by the global variable cmulisp-buffer. Suppose you have three inferior lisps running: Buffer Process foo cmulisp bar cmulisp<2> *cmulisp* cmulisp<3> If you do a \\[lisp-eval-defun] command on some Lisp source code, what process do you send it to? - If you're in a process buffer (foo, bar, or *cmulisp*), you send it to that process. - If you're in some other buffer (e.g., a source file), you send it to the process attached to buffer cmulisp-buffer. This process selection is performed by function cmulisp-proc. Whenever \\[cmulisp] fires up a new process, it resets cmulisp-buffer to be the new process's buffer. If you only run one process, this will do the right thing. If you run multiple processes, you can change cmulisp-buffer to another process buffer with \\[set-variable]. More sophisticated approaches are, of course, possible. If you find youself needing to switch back and forth between multiple processes frequently, you may wish to consider ilisp.el, a larger, more sophisticated package for running inferior Lisp processes. The approach taken here is for a minimal, simple implementation. Feel free to extend it.") (fset 'cmulisp-proc #[nil " = p !!)" [get-buffer-process major-mode inferior-lisp-mode cmulisp-buffer proc error "No current process. See variable cmulisp-buffer"] 4 "\ Returns the current cmulisp process. See variable cmulisp-buffer."]) (defvar cmulisp-load-hook nil "\ This hook is run when cmulisp is loaded in. This is a good place to put keybindings.") (byte-code "!!" [run-hooks cmulisp-load-hook provide cmulisp] 2)