;ELC ;;; Compiled ;;; in Emacs version 29.4 ;;; with all optimizations. (byte-code "\300\301!\210\300\302!\210\300\303!\210\304\305\306\307\310\311\312\313&\210\314\315\316\317\320DD\321\322\323%\207" [require comint lisp-mode shell custom-declare-group inferior-lisp nil "Run an outside Lisp in an Emacs buffer." :group lisp :version "22.1" custom-declare-variable inferior-lisp-filter-regexp funcall function #[0 "\300\207" ["\\`\\s *\\(:\\(\\w\\|\\s_\\)\\)?\\s *\\'"] 1 ""] "What not to save on inferior Lisp's input history.\nInput matching this regexp is not saved on the input history in Inferior Lisp\nmode. Default is whitespace followed by 0 or 1 single-letter colon-keyword\n(as in :a, :c, etc.)" :type regexp] 8) (defvar inferior-lisp-mode-map (byte-code "\302!\303 \"\210\304\305\306#\210\304\307\310#\210\304\311\312#\210\304\313\314#\210\304\315\316#\210\304\317\320#\210\304\321\322#\210\207" [comint-mode-map lisp-mode-shared-map copy-keymap set-keymap-parent define-key "" lisp-eval-last-sexp "\f" lisp-load-file " " lisp-compile-file "" lisp-show-arglist "" lisp-describe-sym "" lisp-show-function-documentation "" lisp-show-variable-documentation] 5))#@21 Inferior Lisp Menu. (defvar inferior-lisp-menu nil (#$ . 1205)) (byte-code "\302\303\304\305$\210\306 \307\310#\210\306 \311\312#\210\306 \313\310#\210\306 \314\315#\210\306 \316\317#\210\306 \320\321#\210\306 \322\323#\210\306 \324\325#\210\306 \326\327#\210\306 \330\331#\210\306 \332\333#\210\306 \334\335#\210\306 \336\337#\210\306 \340\341#\207" [inferior-lisp-mode-map lisp-mode-map easy-menu-do-define inferior-lisp-menu "Inferior Lisp Menu." ("Inf-Lisp" ["Eval Last Sexp" lisp-eval-last-sexp t] "--" ["Load File..." lisp-load-file t] ["Compile File..." lisp-compile-file t] "--" ["Show Arglist..." lisp-show-arglist t] ["Describe Symbol..." lisp-describe-sym t] ["Show Documentation for Function..." lisp-show-function-documentation t] ["Show Documentation for Variable..." lisp-show-variable-documentation t]) define-key "\230" lisp-eval-defun "" lisp-eval-last-sexp "" "" lisp-eval-region "" lisp-eval-form-and-next "" lisp-eval-paragraph "" lisp-compile-defun "" switch-to-lisp "\f" lisp-load-file " " lisp-compile-file "" lisp-show-arglist "" lisp-describe-sym "" lisp-show-function-documentation "" lisp-show-variable-documentation] 5) (defalias 'inferior-lisp-install-letter-bindings #[0 "\302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\312#\210\302\313\314#\210\302\315\316#\210\302\317\320#\210\302\321\322#\210\302\323\324#\210\302\325\326#\210\302 \313\314#\210\302 \315\316#\210\302 \317\320#\210\302 \321\322#\210\302 \323\324#\210\302 \325\326#\207" [lisp-mode-map inferior-lisp-mode-map define-key "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] 4]) (byte-code "\300\301\302\303\304DD\305\306\307%\210\300\310\302\303\311DD\312\306\307%\210\300\313\302\303\314DD\315\306\316%\207" [custom-declare-variable inferior-lisp-program funcall function #[0 "\300\207" ["lisp"] 1 #1=""] "Program name for invoking an inferior Lisp in Inferior Lisp mode." :type string inferior-lisp-load-command #[0 "\300\207" ["(load \"%s\")\n"] 1 #1#] "Format-string for building a Lisp expression to load a file.\nThis format string should use `%s' to substitute a file name\nand should result in a Lisp expression that will command the inferior Lisp\nto load that file. The default works acceptably on most Lisps.\nThe string \"(progn (load \\\"%s\\\" :verbose nil :print t) (values))\\n\"\nproduces cosmetically superior output for this application,\nbut it works only in Common Lisp." inferior-lisp-prompt #[0 "\300\207" ["^[^> \n]*>+:? *"] 1 #1#] "Regexp to recognize prompts in the Inferior Lisp mode.\nDefaults to \"^[^> \\n]*>+:? *\", which works pretty good for Lucid, kcl,\nand franz. This variable is used to initialize `comint-prompt-regexp' in the\nInferior Lisp buffer.\n\nThis variable is only used if the variable\n`comint-use-prompt-regexp' is non-nil.\n\nMore precise choices:\nLucid Common Lisp: \"^\\\\(>\\\\|\\\\(->\\\\)+\\\\) *\"\nfranz: \"^\\\\(->\\\\|<[0-9]*>:\\\\) *\"\nkcl: \"^>+ *\"" regexp] 6)#@1675 *The current `inferior-lisp' process buffer. MULTIPLE PROCESS SUPPORT =========================================================================== To run multiple Lisp processes, you start the first up with \[inferior-lisp]. It will be in a buffer named `*inferior-lisp*'. Rename this buffer with \[rename-buffer]. You may now start up a new process with another \[inferior-lisp]. It will be in a new buffer, named `*inferior-lisp*'. 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 `inferior-lisp-buffer'. Suppose you have three inferior Lisps running: Buffer Process foo inferior-lisp bar inferior-lisp<2> *inferior-lisp* inferior-lisp<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 *inferior-lisp*), 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 `inferior-lisp-buffer'. This process selection is performed by function `inferior-lisp-proc'. Whenever \[inferior-lisp] fires up a new process, it resets `inferior-lisp-buffer' to be the new process's buffer. If you only run one process, this does the right thing. If you run multiple processes, you might need to change `inferior-lisp-buffer' to whichever process buffer you want to use. (defvar inferior-lisp-buffer nil (#$ . 4407))#@42 Hook for customizing Inferior Lisp mode. (defvar inferior-lisp-mode-hook nil (#$ . 6132)) (put 'inferior-lisp-mode 'mode-class 'special) (defvar inferior-lisp-mode-hook nil) (byte-code "\300\301N\204\f\302\300\301\303#\210\304\305!\204\302\305\306\307#\210\300\207" [inferior-lisp-mode-hook variable-documentation put "Hook run after entering Inferior Lisp mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it. (This is true for all hook variables.)" boundp inferior-lisp-mode-map definition-name inferior-lisp-mode] 4) (defvar inferior-lisp-mode-map (make-sparse-keymap)) (byte-code "\301\302N\204\303\301\302\304\305!#\210\306\307!\204*\303\307\310\311#\210\312\307\306\307!\203&\313\202(\314 \"\210\307\302N\2048\303\307\302\304\315!#\210\306\300!\204X\303\300\310\311#\210\312\300\306\300!\203P\313\202V\316\300\313\"\210\"\210\300\302N\204f\303\300\302\304\317!#\210\303\311\320\321#\207" [inferior-lisp-mode-abbrev-table inferior-lisp-mode-map variable-documentation put purecopy "Keymap for `inferior-lisp-mode'." boundp inferior-lisp-mode-syntax-table definition-name inferior-lisp-mode defvar-1 nil make-syntax-table "Syntax table for `inferior-lisp-mode'." define-abbrev-table "Abbrev table for `inferior-lisp-mode'." derived-mode-parent comint-mode] 5)#@2437 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', `inferior-lisp-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 `inferior-lisp-buffer'. \{inferior-lisp-mode-map} Customization: Entry to this mode runs the hooks on `comint-mode-hook' and `inferior-lisp-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:\ \[comint-send-input] after the end of the process' output sends the text from the end of process to point. \[comint-send-input] before the end of the process' output copies the sexp ending at point to the end of the process' output, and sends it. \[comint-copy-old-input] copies the sexp ending at point to the end of the process' output, allowing you to edit it before sending it. If `comint-use-prompt-regexp' is nil (the default), \[comint-insert-input] on old input copies the entire old input to the end of the process' output, allowing you to edit it before sending it. When not used on old input, or if `comint-use-prompt-regexp' is non-nil, \[comint-insert-input] behaves according to its global binding. \[backward-delete-char-untabify] converts tabs to spaces as it moves back. \[lisp-indent-line] indents for Lisp; with argument, shifts rest of expression rigidly with the current line. \[indent-sexp] does \[lisp-indent-line] 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. (defalias 'inferior-lisp-mode #[0 "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315 !\204'\316 \317 \"\210\320\f!\211\2035\211\321 =\203;\322\f\323 \"\210\210\324 \325\"\204R =\204R\326 \325C#\210\327 !\210\330\f!\210  !\331\"\332 \210\330#!\210\333$\334%)\335\336!\207" [delay-mode-hooks major-mode mode-name inferior-lisp-mode-map inferior-lisp-mode-syntax-table inferior-lisp-mode-abbrev-table make-local-variable t comint-mode inferior-lisp-mode "Inferior Lisp" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table (":%s") lisp-mode-variables lisp-get-old-input lisp-input-filter run-mode-hooks inferior-lisp-mode-hook local-abbrev-table inferior-lisp-prompt comint-prompt-regexp mode-line-process lisp-mode-syntax-table comint-get-old-input comint-input-filter] 5 (#$ . 7457) nil])#@54 Return a string containing the sexp ending at point. (defalias 'lisp-get-old-input #[0 "\212`\300 \210`{)\207" [backward-sexp] 3 (#$ . 10897)])#@73 Return t if STR does not match `inferior-lisp-filter-regexp'. (fn STR) (defalias 'lisp-input-filter #[257 "\301\"?\207" [inferior-lisp-filter-regexp string-match] 4 (#$ . 11047)])#@531 Run an inferior Lisp process, input and output via buffer `*inferior-lisp*'. If there is a process already running in `*inferior-lisp*', 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 `inferior-lisp-mode-hook' (after the `comint-mode-hook' is run). If any parts of the command name contains spaces, they should be quoted using shell quote syntax. (Type \[describe-mode] in the process buffer for a list of commands.) (fn CMD) (defalias 'inferior-lisp #[257 "\302\303!\204\304!\305\306\307@\310A%q\210\311 \266\303\312\303 \"\207" [inferior-lisp-buffer display-comint-buffer-action comint-check-proc "*inferior-lisp*" split-string-shell-command apply make-comint "inferior-lisp" nil inferior-lisp-mode pop-to-buffer] 8 (#$ . 11236) (byte-code "\203 \302\303 \"\202\f C\207" [current-prefix-arg inferior-lisp-program read-string "Run lisp: "] 3)]) (defalias 'run-lisp 'inferior-lisp)#@141 Send the current paragraph to the inferior Lisp process. Prefix argument means switch to the Lisp buffer afterwards. (fn &optional AND-GO) (defalias 'lisp-eval-paragraph #[256 "\212\300 \210\301`\302 #)\207" [mark-paragraph lisp-eval-region mark] 5 (#$ . 12238) "P"])#@148 Send the current region to the inferior Lisp process. Prefix argument means switch to the Lisp buffer afterwards. (fn START END &optional AND-GO) (defalias 'lisp-eval-region #[770 "\300\301 #\210\302\301 \303\"\210\211\205\304\305!\207" [comint-send-region inferior-lisp-proc comint-send-string "\n" switch-to-lisp t] 7 (#$ . 12514) "r\nP"])#@84 Send STRING to the inferior Lisp process to be compiled and executed. (fn STRING) (defalias 'lisp-compile-string #[257 "\300\301 \302\303\"\"\207" [comint-send-string inferior-lisp-proc format "(funcall (compile nil (lambda () %s)))\n"] 6 (#$ . 12866)])#@71 Send STRING to the inferior Lisp process to be executed. (fn STRING) (defalias 'lisp-eval-string #[257 "\300\301 \302P\"\207" [comint-send-string inferior-lisp-proc "\n"] 5 (#$ . 13127)])#@257 Send the current defun to the inferior Lisp process. The actually processing is done by DO-STRING and DO-REGION which determine whether the code is compiled before evaluation. DEFVAR forms reset the variables to the init values. (fn DO-STRING DO-REGION) (defalias 'lisp-do-defun #[514 "\212\301 \210\302 \210`\303\301 \210\304\305!\203!\306\307`\310\\\"\311Q!\202%`\"*\207" [case-fold-search beginning-of-defun forward-sexp t looking-at "(defvar" "(defparameter " buffer-substring-no-properties 7 "\n"] 8 (#$ . 13323)])#@190 Send the current defun to the inferior Lisp process. DEFVAR forms reset the variables to the init values. Prefix argument means switch to the Lisp buffer afterwards. (fn &optional AND-GO) (defalias 'lisp-eval-defun #[256 "\300\301\302\"\210\211\205\f\303\304!\207" [lisp-do-defun lisp-eval-string lisp-eval-region switch-to-lisp t] 4 (#$ . 13858) "P"])#@137 Send the previous sexp to the inferior Lisp process. Prefix argument means switch to the Lisp buffer afterwards. (fn &optional AND-GO) (defalias 'lisp-eval-last-sexp #[256 "\300\212\301 \210`)`#\207" [lisp-eval-region backward-sexp] 5 (#$ . 14219) "P"])#@79 Send the previous sexp to the inferior Lisp process and move to the next one. (defalias 'lisp-eval-form-and-next #[0 "\300 @\301U\204\302 \210\202\303 \210\304 \207" [syntax-ppss 0 up-list lisp-eval-last-sexp forward-sexp] 2 (#$ . 14480) ""])#@151 Compile the current region in the inferior Lisp process. Prefix argument means switch to the Lisp buffer afterwards. (fn START END &optional AND-GO) (defalias 'lisp-compile-region #[770 "\300\301\"!\210\211\205\302\303!\207" [lisp-compile-string buffer-substring-no-properties switch-to-lisp t] 7 (#$ . 14733) "r\nP"])#@193 Compile the current defun in the inferior Lisp process. DEFVAR forms reset the variables to the init values. Prefix argument means switch to the Lisp buffer afterwards. (fn &optional AND-GO) (defalias 'lisp-compile-defun #[256 "\300\301\302\"\210\211\205\f\303\304!\207" [lisp-do-defun lisp-compile-string lisp-compile-region switch-to-lisp t] 4 (#$ . 15063) "P"])#@107 Switch to the inferior Lisp process buffer. With argument, positions cursor at end of buffer. (fn EOB-P) (defalias 'switch-to-lisp #[257 "\303!\203 \206\304\305\"\306!)\210\202\307\n!\210\211\205$\310 \210db\207" [inferior-lisp-buffer pop-up-frames inferior-lisp-program get-buffer-process get-buffer-window t pop-to-buffer run-lisp push-mark] 4 (#$ . 15436) "P"])#@89 Send the current region to the inferior Lisp, and switch to its buffer. (fn START END) (defalias 'lisp-eval-region-and-go #[514 "\300\301#\207" [lisp-eval-region t] 6 (#$ . 15818) "r"])#@72 Send the current defun to the inferior Lisp, and switch to its buffer. (defalias 'lisp-eval-defun-and-go #[0 "\300\301!\207" [lisp-eval-defun t] 2 (#$ . 16012) nil])#@92 Compile the current region in the inferior Lisp, and switch to its buffer. (fn START END) (defalias 'lisp-compile-region-and-go #[514 "\300\301#\207" [lisp-compile-region t] 6 (#$ . 16183) "r"])#@75 Compile the current defun in the inferior Lisp, and switch to its buffer. (defalias 'lisp-compile-defun-and-go #[0 "\300\301!\207" [lisp-compile-defun t] 2 (#$ . 16386) nil])#@187 Record last directory and file used in loading or compiling. This holds a cons cell of the form `(DIRECTORY . FILE)' describing the last `lisp-load-file' or `lisp-compile-file' command. (defvar lisp-prev-l/c-dir/file nil (#$ . 16567)) (byte-code "\300\301\302\303\304DD\305\306\307%\207" [custom-declare-variable lisp-source-modes funcall function #[0 "\300\207" [(lisp-mode)] 1 ""] "Used to determine if a buffer contains Lisp source code.\nIf it's loaded into a buffer that is in one of these major modes, it's\nconsidered a Lisp source file by `lisp-load-file' and `lisp-compile-file'.\nUsed by these commands to determine defaults." :type (repeat symbol)] 6)#@66 Load a Lisp file into the inferior Lisp process. (fn FILE-NAME) (defalias 'lisp-load-file #[257 "\302!\210\303!\304!B\305\306 \307 \"\"\210\310\311!\207" [lisp-prev-l/c-dir/file inferior-lisp-load-command comint-check-source file-name-directory file-name-nondirectory comint-send-string inferior-lisp-proc format switch-to-lisp t] 6 (#$ . 17235) (comint-get-source "Load Lisp file" lisp-prev-l/c-dir/file lisp-source-modes nil)])#@67 Compile a Lisp file in the inferior Lisp process. (fn FILE-NAME) (defalias 'lisp-compile-file #[257 "\301!\210\302!\303!B\304\305 \306\307Q\"\210\310\311!\207" [lisp-prev-l/c-dir/file comint-check-source file-name-directory file-name-nondirectory comint-send-string inferior-lisp-proc "(compile-file \"" "\")\n" switch-to-lisp t] 6 (#$ . 17676) (comint-get-source "Compile Lisp file" lisp-prev-l/c-dir/file lisp-source-modes nil)])#@64 Command to query inferior Lisp for a function's documentation. (defvar lisp-function-doc-command "(let ((fn '%s))\n (format t \"Documentation for ~a:~&~a\"\n fn (documentation fn 'function))\n (values))\n" (#$ . 18119))#@64 Command to query inferior Lisp for a variable'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" (#$ . 18357))#@58 Command to query inferior Lisp for a function's arglist. (defvar lisp-arglist-command "(let ((fn '%s))\n (format t \"Arglist for ~a: ~a\" fn (arglist fn))\n (values))\n" (#$ . 18587))#@64 Command to query inferior Lisp for a variable's documentation. (defvar lisp-describe-sym-command "(describe '%s)\n" (#$ . 18784))#@23 (fn PROMPT DEFAULT) (defalias 'lisp-symprompt #[514 "\300\301\"!\211G\302U\203\202\211\262C\207" [read-string format-prompt 0] 6 (#$ . 18919)])#@100 Return the name of the function called in the current call. The value is nil if it can't find one. (defalias 'lisp-fn-called-at-pt #[0 "\3001#\212\214e`\301Z]d}\210\302\303!\210\303u\210\304p!\2119\205\211*\2620\207\210\305\207" [(error) 1000 backward-up-list 1 read nil] 3 (#$ . 19079)]) (defalias 'lisp-var-at-pt #[0 "\3001\212\301\302!\210\303\304w\210\305p!\2119\205\211)\2620\207\210\304\207" [(error) forward-sexp -1 "'" nil read] 2])#@127 Send a command to the inferior Lisp to give documentation for function FN. See variable `lisp-function-doc-command'. (fn FN) (defalias 'lisp-show-function-documentation #[257 "\301\302 \303\"\"\207" [lisp-function-doc-command comint-proc-query inferior-lisp-proc format] 6 (#$ . 19535) (byte-code "\300\301\302 \"\207" [lisp-symprompt "Function doc" lisp-fn-called-at-pt] 3)])#@124 Send a command to the inferior Lisp to give documentation for variable VAR. See variable `lisp-var-doc-command'. (fn VAR) (defalias 'lisp-show-variable-documentation #[257 "\301\302 \303\"\"\207" [lisp-var-doc-command comint-proc-query inferior-lisp-proc format] 6 (#$ . 19921) (byte-code "\300\301\302 \"\207" [lisp-symprompt "Variable doc" lisp-var-at-pt] 3)])#@114 Send a query to the inferior Lisp for the arglist for function FN. See variable `lisp-arglist-command'. (fn FN) (defalias 'lisp-show-arglist #[257 "\301\302 \303\"\"\207" [lisp-arglist-command comint-proc-query inferior-lisp-proc format] 6 (#$ . 20293) (byte-code "\300\301\302 \"\207" [lisp-symprompt "Arglist" lisp-fn-called-at-pt] 3)])#@113 Send a command to the inferior Lisp to describe symbol SYM. See variable `lisp-describe-sym-command'. (fn SYM) (defalias 'lisp-describe-sym #[257 "\301\302 \303\"\"\207" [lisp-describe-sym-command comint-proc-query inferior-lisp-proc format] 6 (#$ . 20641) (byte-code "\300\301\302 \"\207" [lisp-symprompt "Describe" lisp-var-at-pt] 3)]) (defalias 'inferior-lisp-proc #[0 "\301\302\303!\203 p\202\f!\211\206\304\305!\207" [inferior-lisp-buffer get-buffer-process derived-mode-p inferior-lisp-mode error "No Lisp subprocess; see variable `inferior-lisp-buffer'"] 3])#@57 This hook is run when the library `inf-lisp' is loaded. (defvar inferior-lisp-load-hook nil (#$ . 21220)) (byte-code "\300\301\302\303#\210\304\301!\210\305\306!\207" [make-obsolete-variable inferior-lisp-load-hook "use `with-eval-after-load' instead." "28.1" run-hooks provide inf-lisp] 4)