;ELC ;;; Compiled by pot@pot.cnuce.cnr.it on Tue Mar 18 15:53:34 2003 ;;; from file /home/pot/gnu/emacs-pretest.new/lisp/xscheme.el ;;; in Emacs version 21.3 ;;; with bytecomp version 2.85.4.1 ;;; with all optimizations. ;;; This file uses dynamic docstrings, first added in Emacs 19.29. (if (and (boundp 'emacs-version) (< (aref emacs-version (1- (length emacs-version))) ?A) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19.29"))) (error "`xscheme.el' was compiled for Emacs 19.29 or later")) ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; (byte-code "\300\301!\210\302\303\304\305\306\307%\207" [require scheme custom-declare-group xscheme nil "Major mode for editing Scheme and interacting with MIT's C-Scheme." :group lisp] 6) #@43 *Band loaded by the `run-scheme' command. (custom-declare-variable 'scheme-band-name 'nil '(#$ . -806) :type '(choice (const nil) string) :group 'xscheme) #@70 *Arguments passed to the Scheme program by the `run-scheme' command. (custom-declare-variable 'scheme-program-arguments 'nil '(#$ . -967) :type '(choice (const nil) string) :group 'xscheme) #@200 If non-nil, an expression may be transmitted while another is evaluating. Otherwise, attempting to evaluate an expression before the previous expression has finished evaluating will signal an error. (custom-declare-variable 'xscheme-allow-pipelined-evaluation 't '(#$ . 1164) :type 'boolean :group 'xscheme) #@122 String to insert into Scheme process buffer first time it is started. Is processed with `substitute-command-keys' first. (custom-declare-variable 'xscheme-startup-message '"This is the Scheme process buffer.\nType \\[advertised-xscheme-send-previous-expression] to evaluate the expression before point.\nType \\[xscheme-send-control-g-interrupt] to abort evaluation.\nType \\[describe-mode] for more information.\n\n" '(#$ . 1479) :type 'string :group 'xscheme) #@76 If non-nil, causes a message to be generated when the Scheme process dies. (custom-declare-variable 'xscheme-signal-death-message 'nil '(#$ . 1947) :type 'boolean :group 'xscheme) (defalias 'xscheme-evaluation-commands #[(keymap) "\301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\303#\210\301\311\312#\210\301\313\314#\207" [keymap define-key "" xscheme-send-definition "" advertised-xscheme-send-previous-expression "o" xscheme-send-buffer "z" " " xscheme-send-previous-expression "" xscheme-send-region] 4]) (defalias 'xscheme-interrupt-commands #[(keymap) "\301\302\303#\210\301\304\305#\210\301\306\307#\210\301\310\311#\210\301\312\313#\207" [keymap define-key "" xscheme-select-process-buffer "" xscheme-send-breakpoint-interrupt "" xscheme-send-control-g-interrupt "" xscheme-send-control-u-interrupt "" xscheme-send-control-x-interrupt] 4]) (byte-code "\301!\210\302!\207" [scheme-mode-map xscheme-evaluation-commands xscheme-interrupt-commands] 2) #@118 Run MIT Scheme in an inferior process. Output goes to the buffer `*scheme*'. With argument, asks for a command line. (defalias 'run-scheme #[(command-line) "\302\303!!\207" [command-line xscheme-process-command-line pop-to-buffer xscheme-start-process] 3 (#$ . 2954) (list (let ((default (or xscheme-process-command-line (xscheme-default-command-line)))) (if current-prefix-arg (read-string "Run Scheme: " default) default)))]) #@27 Reset the Scheme process. (defalias 'reset-scheme #[nil "\302\303!\211\203\304!\305=\203\306\307!\205*\310\311!\210\203#\312\313\"\210\314 !\210\310\315!)\207" [process xscheme-process-command-line get-process "scheme" process-status run yes-or-no-p "The Scheme process is running, are you SURE you want to reset it? " message "Resetting Scheme process..." kill-process t xscheme-start-process "Resetting Scheme process...done"] 4 (#$ . 3391) nil]) (defalias 'xscheme-default-command-line #[nil "\303 \203\f\304 P\202 \305\n\203\306\nP\202\305R\207" [scheme-program-name scheme-program-arguments scheme-band-name " -emacs" " " "" " -band "] 5]) #@3241 Major mode for interacting with the inferior Scheme process. Like scheme-mode except that: \[advertised-xscheme-send-previous-expression] sends the expression before point to the Scheme process as input \[xscheme-yank-previous-send] yanks the expression most recently sent to Scheme All output from the Scheme process is written in the Scheme process buffer, which is initially named "*scheme*". The result of evaluating a Scheme expression is also printed in the process buffer, preceded by the string ";Value: " to highlight it. If the process buffer is not visible at that time, the value will also be displayed in the minibuffer. If an error occurs, the process buffer will automatically pop up to show you the error message. While the Scheme process is running, the modelines of all buffers in scheme-mode are modified to show the state of the process. The possible states and their meanings are: input waiting for input run evaluating gc garbage collecting The process buffer's modeline contains additional information where the buffer's name is normally displayed: the command interpreter level and type. Scheme maintains a stack of command interpreters. Every time an error or breakpoint occurs, the current command interpreter is pushed on the command interpreter stack, and a new command interpreter is started. One example of why this is done is so that an error that occurs while you are debugging another error will not destroy the state of the initial error, allowing you to return to it after the second error has been fixed. The command interpreter level indicates how many interpreters are in the command interpreter stack. It is initially set to one, and it is incremented every time that stack is pushed, and decremented every time it is popped. The following commands are useful for manipulating the command interpreter stack: \[xscheme-send-breakpoint-interrupt] pushes the stack once \[xscheme-send-control-u-interrupt] pops the stack once \[xscheme-send-control-g-interrupt] pops everything off \[xscheme-send-control-x-interrupt] aborts evaluation, doesn't affect stack Some possible command interpreter types and their meanings are: [Evaluator] read-eval-print loop for evaluating expressions [Debugger] single character commands for debugging errors [Where] single character commands for examining environments Starting with release 6.2 of Scheme, the latter two types of command interpreters will change the major mode of the Scheme process buffer to scheme-debugger-mode , in which the evaluation commands are disabled, and the keys which normally self insert instead send themselves to the Scheme process. The command character ? will list the available commands. For older releases of Scheme, the major mode will be be scheme-interaction-mode , and the command characters must be sent as if they were expressions. Commands: Delete converts tabs to spaces as it moves back. Blank lines separate paragraphs. Semicolons start comments. \{scheme-interaction-mode-map} Entry to this mode calls the value of scheme-interaction-mode-hook with no args, if that value is non-nil. Likewise with the value of scheme-mode-hook. scheme-interaction-mode-hook is called after scheme-mode-hook. (defalias 'scheme-interaction-mode #[nil "\300 \210\301 \210\302 \210\303\304!\210\305\306\307\"\207" [kill-all-local-variables scheme-interaction-mode-initialize scheme-mode-variables make-local-variable xscheme-previous-send run-hooks scheme-mode-hook scheme-interaction-mode-hook] 3 (#$ . 4061) nil]) (defalias 'scheme-interaction-mode-initialize #[nil "\303!\210\304\305\211\207" [scheme-interaction-mode-map major-mode mode-name use-local-map scheme-interaction-mode "Scheme Interaction"] 2]) (defalias 'scheme-interaction-mode-commands #[(keymap) "\301\302\303#\210\301\304\305#\210\301\306\307#\207" [keymap define-key " " xscheme-send-current-line "" xscheme-send-proceed "" xscheme-yank-previous-send] 4]) (byte-code "\301B\302\301!\204\f\303 \204#\304 \305 !\210\306 !\210\307 !\210\310 !\210\303\207" [current-load-list scheme-interaction-mode-map boundp nil make-keymap scheme-mode-commands xscheme-interrupt-commands xscheme-evaluation-commands scheme-interaction-mode-commands] 2) (defalias 'xscheme-enter-interaction-mode #[nil "\212\301 q\210\302=?\205\303=\203\304 \202\302 )\207" [major-mode xscheme-process-buffer scheme-interaction-mode scheme-debugger-mode scheme-interaction-mode-initialize] 2]) (fset 'advertised-xscheme-send-previous-expression 'xscheme-send-previous-expression) #@316 Major mode for executing the Scheme debugger. Like scheme-mode except that the evaluation commands are disabled, and characters that would normally be self inserting are sent to the Scheme process instead. Typing ? will show you which characters perform useful functions. Commands: \{scheme-debugger-mode-map} (defalias 'scheme-debugger-mode #[nil "\300\301!\207" [error "Illegal entry to scheme-debugger-mode"] 2 (#$ . 8637)]) (defalias 'scheme-debugger-mode-initialize #[nil "\303!\210\304\305\211\207" [scheme-debugger-mode-map major-mode mode-name use-local-map scheme-debugger-mode "Scheme Debugger"] 2]) (defalias 'scheme-debugger-mode-commands #[(keymap) "\302\302\303W\205\304 \305!\306#\210T\211\202)\207" [char keymap 32 127 define-key char-to-string scheme-debugger-self-insert] 5]) (byte-code "\301B\302\301!\204\f\303 \204\304 \305 !\210\306 !\210\307 !\210\303\207" [current-load-list scheme-debugger-mode-map boundp nil make-keymap scheme-mode-commands xscheme-interrupt-commands scheme-debugger-mode-commands] 2) #@48 Transmit this character to the Scheme process. (defalias 'scheme-debugger-self-insert #[nil "\301!\207" [last-command-char xscheme-send-char] 2 (#$ . 9695) nil]) (defalias 'xscheme-enter-debugger-mode #[(prompt-string) "\212\301 q\210\302=?\205\303=\204\303 \210\304 )\207" [major-mode xscheme-process-buffer scheme-debugger-mode scheme-interaction-mode scheme-debugger-mode-initialize] 2]) (defalias 'xscheme-debugger-mode-p #[nil "\302 \211\205\212q\210 )\303=)\207" [buffer major-mode xscheme-process-buffer scheme-debugger-mode] 3]) #@108 Send the string arguments to the Scheme process. The strings are concatenated and terminated by a newline. (defalias 'xscheme-send-string #[(&rest strings) "\303 \204\304\305!\2055\306 \210\307 \210db\210\310\311\"\210\312!\207\313 \203&\314\315!\207 \2042\n\2032\314\316!\207\312!\207" [strings xscheme-allow-pipelined-evaluation xscheme-running-p xscheme-process-running-p yes-or-no-p "The Scheme process has died. Reset it? " reset-scheme xscheme-wait-for-process apply insert-before-markers xscheme-send-string-1 xscheme-debugger-mode-p error "No sends allowed in debugger mode" "No sends allowed while Scheme running"] 3 (#$ . 10250)]) (defalias 'xscheme-send-string-1 #[(strings) "\304\305\"\306 !\210\n\307=\205 \211)\207" [strings string major-mode xscheme-previous-send apply concat xscheme-send-string-2 scheme-interaction-mode] 3]) (defalias 'xscheme-send-string-2 #[(string) "\302\303!\304 \305P\"\210\306 \205\307!`\310\223)\207" [process string get-process "scheme" send-string "\n" xscheme-process-buffer-current-p process-mark nil] 4]) #@45 Insert the most recent expression at point. (defalias 'xscheme-yank-previous-send #[nil "\301 \210c\207" [xscheme-previous-send push-mark] 1 (#$ . 11328) nil]) #@64 Select the Scheme process buffer and move to its output point. (defalias 'xscheme-select-process-buffer #[nil "\303\304!\206 \305\306!\307!\206\305\310!\311 !\211\203#\312\n!\210\202'\313 !\210\314!b+\207" [process buffer window get-process "scheme" error "No scheme process" process-buffer "No process buffer" get-buffer-window select-window switch-to-buffer process-mark] 3 (#$ . 11495) nil]) #@92 Send the current region to the Scheme process. The region is sent terminated by a newline. (defalias 'xscheme-send-region #[(start end) "\302 \203b\210\303\304\305!!\306\223\210\307 {!\207" [end start xscheme-process-buffer-current-p process-mark get-process "scheme" nil xscheme-send-string] 3 (#$ . 11906) "r"]) #@186 Send the current definition to the Scheme process. If the current line begins with a non-whitespace character, parse an expression from the beginning of the line and send that instead. (defalias 'xscheme-send-definition #[nil "\302\211\212\303 \210`\304\305\302\306#\203`\202\307\310!\210)\311 \"*\207" [end start nil end-of-defun re-search-backward "^\\s(" t error "Can't find definition" xscheme-send-region] 4 (#$ . 12232) nil]) #@68 Send the expression to the right of `point' to the Scheme process. (defalias 'xscheme-send-next-expression #[nil "`\301\212\302 \210`)\")\207" [start xscheme-send-region forward-sexp] 3 (#$ . 12679) nil]) #@67 Send the expression to the left of `point' to the Scheme process. (defalias 'xscheme-send-previous-expression #[nil "`\301\212\302 \210`)\")\207" [end xscheme-send-region backward-sexp] 3 (#$ . 12892) nil]) #@98 Send the current line to the Scheme process. Useful for working with debugging Scheme under adb. (defalias 'xscheme-send-current-line #[nil "\212\302 \210`\303\210`{*\303\210\304c\210\305 !)\207" [start line beginning-of-line nil 10 xscheme-send-string-2] 2 (#$ . 13107) nil]) #@48 Send the current buffer to the Scheme process. (defalias 'xscheme-send-buffer #[nil "\300 \203 \301\302!\210\303ed\"\207" [xscheme-process-buffer-current-p error "Not allowed to send this buffer's contents to Scheme" xscheme-send-region] 3 (#$ . 13395) nil]) #@59 Prompt for a character and send it to the Scheme process. (defalias 'xscheme-send-char #[(char) "\301\302\303!\"\207" [char send-string "scheme" char-to-string] 4 (#$ . 13661) "cCharacter to send: "]) #@49 Cause the Scheme process to enter a breakpoint. (defalias 'xscheme-send-breakpoint-interrupt #[nil "\300\301\302\"\207" [xscheme-send-interrupt 98 nil] 3 (#$ . 13869) nil]) #@56 Cause the Scheme process to proceed from a breakpoint. (defalias 'xscheme-send-proceed #[nil "\300\301\302\"\207" [send-string "scheme" "(proceed)\n"] 3 (#$ . 14048) nil]) #@96 Cause the Scheme processor to halt and flush input. Control returns to the top level rep loop. (defalias 'xscheme-send-control-g-interrupt #[nil "\303 \204\f\304\305!\202&\n\203\306\307!\202&\303\306\310!\210\304\305!\210\311\305\312\313!\")\207" [inhibit-quit xscheme-control-g-synchronization-p xscheme-control-g-disabled-p t interrupt-process "scheme" message "Relax..." "Sending C-G interrupt to Scheme..." send-string char-to-string 0] 4 (#$ . 14226) nil]) #@67 Cause the Scheme process to halt, returning to previous rep loop. (defalias 'xscheme-send-control-u-interrupt #[nil "\300\301\302\"\207" [xscheme-send-interrupt 117 t] 3 (#$ . 14701) nil]) #@66 Cause the Scheme process to halt, returning to current rep loop. (defalias 'xscheme-send-control-x-interrupt #[nil "\300\301\302\"\207" [xscheme-send-interrupt 120 t] 3 (#$ . 14896) nil]) #@49 Send a ^A type interrupt to the Scheme process. (defalias 'xscheme-send-interrupt #[(char mark-p) "\303\304!\210\305\304\306!\"\210 \205\n\205\305\304\306\307!\"\207" [char mark-p xscheme-control-g-synchronization-p quit-process "scheme" send-string char-to-string 0] 4 (#$ . 15090) "cInterrupt character to send: "]) #@55 Command used to start the most recent Scheme process. (defvar xscheme-process-command-line nil (#$ . 15419)) #@59 Most recent expression transmitted to the Scheme process. (defvar xscheme-previous-send "" (#$ . 15534)) #@213 State of scheme process escape reader state machine: idle waiting for an escape sequence reading-type received an altmode but nothing else reading-string reading prompt string (defvar xscheme-process-filter-state 'idle (#$ . 15646)) #@125 This variable, if nil, indicates that the scheme process is waiting for input. Otherwise, it is busy evaluating something. (defvar xscheme-running-p nil (#$ . 15922)) #@201 If non-nil, insert markers in the scheme input stream to indicate when control-g interrupts were signaled. Do not allow more control-g's to be signaled until the scheme process acknowledges receipt. (defconst xscheme-control-g-synchronization-p t (#$ . 16097)) #@142 This variable, if non-nil, indicates that a control-g is being processed by the scheme process, so additional control-g's are to be ignored. (defvar xscheme-control-g-disabled-p nil (#$ . 16366)) #@109 This variable, if nil, prevents output from the scheme process from being inserted into the process-buffer. (defvar xscheme-allow-output-p t (#$ . 16569)) #@35 The current scheme prompt string. (defvar xscheme-prompt "" (#$ . 16730)) #@68 Accumulator for the string being received from the scheme process. (defvar xscheme-string-accumulator "" (#$ . 16810)) #@64 Procedure to send the string argument from the scheme process. (defvar xscheme-string-receiver nil (#$ . 16935)) #@136 If non-nil, a procedure to call when the Scheme process is started. When called, the current buffer will be the Scheme process-buffer. (custom-declare-variable 'xscheme-start-hook 'nil '(#$ . 17055) :type 'hook :group 'xscheme) (byte-code "\301B\304\301!\204\f\305\302B\304\302!\204\305\303B\304\303!\204$\305\305\207" [current-load-list xscheme-runlight-string xscheme-mode-string xscheme-filter-input boundp nil] 2) (defalias 'xscheme-start-process #[(command-line) "\305\306!\307!\212q\210 \203\"\310 !\311>\203\"\312 !d\313\223\210\202d \203*\314 !\210db\210\315 \210o\203:\316\317\n!!\210\313\320\321\322\323\f!BB\")\312 !d\313\223\210\324\325!\210\326 \210\327 \330\"\210\331 \332\"\210\333\334!\210*)\207" [buffer process xscheme-startup-message process-connection-type command-line get-buffer-create "*scheme*" get-buffer-process process-status (run stop) process-mark nil delete-process scheme-interaction-mode insert-before-markers substitute-command-keys apply start-process "scheme" xscheme-parse-command-line xscheme-process-filter-initialize t xscheme-modeline-initialize set-process-sentinel xscheme-process-sentinel set-process-filter xscheme-process-filter run-hooks xscheme-start-hook] 6]) (defalias 'xscheme-parse-command-line #[(string) "\304!\305\306\n\203=\307\310\n#\211\204!\n\306O B\306\2028 \nU\203/\307\311\n#\2028\n O B T)\202 \237*\207" [string result start index substitute-in-file-name 0 nil string-match "[ ]" "[^ ]"] 5]) (defalias 'xscheme-wait-for-process #[nil "\301\302!\210\205\301\303!\210\202\207" [xscheme-running-p sleep-for 2 1] 2]) #@59 True iff there is a Scheme process whose status is `run'. (defalias 'xscheme-process-running-p #[nil "\301\302!\211\205 \303!\304=)\207" [process get-process "scheme" process-status run] 3 (#$ . 18688)]) (defalias 'xscheme-process-buffer #[nil "\301\302!\211\205 \303!)\207" [process get-process "scheme" process-buffer] 3]) (defalias 'xscheme-process-buffer-window #[nil "\301 \211\205\n\302!)\207" [buffer xscheme-process-buffer get-buffer-window] 3]) #@59 True iff the current buffer is the Scheme process buffer. (defalias 'xscheme-process-buffer-current-p #[nil "\300 p=\207" [xscheme-process-buffer] 2 (#$ . 19157)]) (defalias 'xscheme-process-sentinel #[(proc reason) "\304\305=!\210\305=\203\306 \210\202\307\310\311>?\205' \205'\312 \210\313\314!\207" [reason scheme-mode-line-process xscheme-mode-string xscheme-signal-death-message xscheme-process-filter-initialize run xscheme-modeline-initialize "" "no process" (run stop) beep message "The Scheme process has died! Do M-x reset-scheme to restart it"] 3]) (defalias 'xscheme-process-filter-initialize #[(running-p) "\306 \307\310\311\312\211 \207" [xscheme-process-filter-state running-p xscheme-running-p xscheme-control-g-disabled-p xscheme-allow-output-p xscheme-prompt idle nil t "" (": " xscheme-runlight-string) scheme-mode-line-process] 2]) (defalias 'xscheme-process-filter #[(proc string) " \205\255\n\306=\2034\307\310 \"\211\203'\311 \312 O!\210 T\313O\314\2020 \313\311!\210))\202\n\314=\203r\315 G!\203G\313\211\202 \312H \316\313O\317\f \"\211\203g\3208A@!\210\202n\311\321\f\"\210\306*\202\n\322=\203\246\307\310 \"\211\203\232 \312 OP T\313O\306!\210)\202\242 P\313)\202\323\324!\210\202)\207" [string xscheme-filter-input xscheme-process-filter-state start char xscheme-process-filter-alist idle string-match "" xscheme-process-filter-output 0 nil reading-type zerop 1 assoc 2 27 reading-string error "Scheme process filter -- bad state" entry xscheme-string-accumulator xscheme-string-receiver] 5]) (defalias 'xscheme-process-filter-output #[(&rest args) "\205I\305\306 \"\212\307 \210\310\311\n\"\203E\312\224\312\225\313\n\312\fO!\210\n\fH\314U\2038n\2041\313\315!\210\313\314!\210\202;\316 \210\n\fT\317O*\202 \313\n!*\207" [xscheme-allow-output-p args string end start apply concat xscheme-goto-output-point string-match "\\(\\|\f\\)" 0 insert-before-markers 12 10 beep nil] 4]) (defalias 'xscheme-guarantee-newlines #[(n) "\205;\212\303 \210\304 \204%n\203%\nSo\203\305\211\202 \306u\210\202\n)\303 \210\n\307V\205:\310\311!\210\nS\211\202*)\207" [xscheme-allow-output-p stop n xscheme-goto-output-point nil t -1 0 insert-before-markers 10] 3]) (defalias 'xscheme-goto-output-point #[nil "\301\302!\303!q\210\304!b)\207" [process get-process "scheme" process-buffer process-mark] 2]) (defalias 'xscheme-modeline-initialize #[nil "\303\303\304\211\207" [xscheme-runlight-string xscheme-mode-string mode-line-buffer-identification "" ("Scheme: " xscheme-mode-string)] 2]) (defalias 'xscheme-set-runlight #[(runlight) "\302\303!\207" [runlight xscheme-runlight-string force-mode-line-update t] 2]) #@673 Table used to decide how to handle process filter commands. Value is a list of entries, each entry is a list of three items. The first item is the character that the process filter dispatches on. The second item is the action to be taken, a function. The third item is the handler for the entry, a function. When the process filter sees a command whose character matches a particular entry, it calls the handler with two arguments: the action and the string containing the rest of the process filter's input stream. It is the responsibility of the handler to invoke the action with the appropriate arguments, and to reenter the process filter with the remaining input. (defvar xscheme-process-filter-alist '((68 xscheme-enter-debugger-mode xscheme-process-filter:string-action) (69 xscheme-eval xscheme-process-filter:string-action) (80 xscheme-set-prompt-variable xscheme-process-filter:string-action) (82 xscheme-enter-interaction-mode xscheme-process-filter:simple-action) (98 xscheme-start-gc xscheme-process-filter:simple-action) (101 xscheme-finish-gc xscheme-process-filter:simple-action) (102 xscheme-exit-input-wait xscheme-process-filter:simple-action) (103 xscheme-enable-control-g xscheme-process-filter:simple-action) (105 xscheme-prompt-for-expression xscheme-process-filter:string-action) (109 xscheme-message xscheme-process-filter:string-action) (110 xscheme-prompt-for-confirmation xscheme-process-filter:string-action) (111 xscheme-output-goto xscheme-process-filter:simple-action) (112 xscheme-set-prompt xscheme-process-filter:string-action) (115 xscheme-enter-input-wait xscheme-process-filter:simple-action) (118 xscheme-write-value xscheme-process-filter:string-action) (119 xscheme-cd xscheme-process-filter:string-action) (122 xscheme-display-process-buffer xscheme-process-filter:simple-action) (99 xscheme-unsolicited-read-char xscheme-process-filter:simple-action)) (#$ . 21894)) (defalias 'xscheme-process-filter:simple-action #[(action) "\302 \207" [xscheme-process-filter-state action idle] 1]) (defalias 'xscheme-process-filter:string-action #[(action) "\304\305\211\207" [action xscheme-string-receiver xscheme-string-accumulator xscheme-process-filter-state "" reading-string] 2]) #@61 The character displayed when the Scheme process is running. (defconst xscheme-runlight:running "run" (#$ . 24125)) #@71 The character displayed when the Scheme process is waiting for input. (defconst xscheme-runlight:input "input" (#$ . 24246)) #@72 The character displayed when the Scheme process is garbage collecting. (defconst xscheme-runlight:gc "gc" (#$ . 24377)) (defalias 'xscheme-start-gc #[nil "\301!\207" [xscheme-runlight:gc xscheme-set-runlight] 2]) (defalias 'xscheme-finish-gc #[nil "\303\203 \202\n\n!\207" [xscheme-running-p xscheme-runlight:running xscheme-runlight:input xscheme-set-runlight] 2]) (defalias 'xscheme-enter-input-wait #[nil "\302!\210\303\211\207" [xscheme-runlight:input xscheme-running-p xscheme-set-runlight nil] 2]) (defalias 'xscheme-exit-input-wait #[nil "\302!\210\303\211\207" [xscheme-runlight:running xscheme-running-p xscheme-set-runlight t] 2]) (defalias 'xscheme-enable-control-g #[nil "\301\211\207" [xscheme-control-g-disabled-p nil] 2]) (defalias 'xscheme-display-process-buffer #[nil "\301 \206 \302\303 !\304\213)\207" [window xscheme-process-buffer-window display-buffer xscheme-process-buffer ((byte-code "\301!\210\302 \210\303 \205\304 \207" [window select-window xscheme-goto-output-point xscheme-debugger-mode-p xscheme-enter-interaction-mode] 2))] 2]) (defalias 'xscheme-unsolicited-read-char #[nil "\300\207" [nil] 1]) (defalias 'xscheme-eval #[(string) "\301\302!@!\207" [string eval read-from-string] 3]) (defalias 'xscheme-message #[(string) "\301G!?\205\302\303\304\"\"\207" [string zerop xscheme-write-message-1 format ";%s"] 5]) (defalias 'xscheme-write-value #[(string) "\301G!\203\f\302\303\304\"\207\302\305\306\"\"\207" [string zerop xscheme-write-message-1 "(no value)" ";No value" format ";Value: %s"] 5]) (defalias 'xscheme-write-message-1 #[(message-string output-string) "\304\305!\306\307!!\211\203\310\311! \"\204\312\313\n\"\210*\314\315!\210\316 !\207" [process window message-string output-string get-process "scheme" get-buffer-window process-buffer pos-visible-in-window-p process-mark message "%s" xscheme-guarantee-newlines 1 xscheme-process-filter-output] 4]) (defalias 'xscheme-set-prompt-variable #[(string) "\211\207" [string xscheme-prompt] 2]) (defalias 'xscheme-set-prompt #[(string) "\303\304!\210\305!\306\307!\207" [string xscheme-prompt xscheme-mode-string xscheme-guarantee-newlines 2 xscheme-coerce-prompt force-mode-line-update t] 2]) (defalias 'xscheme-output-goto #[nil "\300 \210\301\302!\207" [xscheme-goto-output-point xscheme-guarantee-newlines 2] 2]) (defalias 'xscheme-coerce-prompt #[(string) "\305\306\"\203&\307\225\307 O \310O\311\n \"\211\203!\fA\202\"\n*P)\207\207" [string end prompt xscheme-prompt-alist entry string-match "^[0-9]+ " 0 nil assoc] 5]) #@76 An alist which maps the Scheme command interpreter type to a print string. (defvar xscheme-prompt-alist '(("[Normal REPL]" . "[Evaluator]") ("[Error REPL]" . "[Evaluator]") ("[Breakpoint REPL]" . "[Evaluator]") ("[Debugger REPL]" . "[Evaluator]") ("[Visiting environment]" . "[Evaluator]") ("[Environment Inspector]" . "[Where]")) (#$ . 26947)) (defalias 'xscheme-cd #[(directory-string) "\212\301 q\210\302!)\207" [directory-string xscheme-process-buffer cd] 2]) (defalias 'xscheme-prompt-for-confirmation #[(prompt-string) "\301\302!\203 \303\202\f\304!\207" [prompt-string xscheme-send-char y-or-n-p 121 110] 3]) (defalias 'xscheme-prompt-for-expression #[(prompt-string) "\302\303\304 #!\207" [prompt-string xscheme-prompt-for-expression-map xscheme-send-string-2 read-from-minibuffer nil] 5]) (byte-code "\301B\303\301!\204\f\304 \204\305\n!\306\307\310 #\210\304\207" [current-load-list xscheme-prompt-for-expression-map minibuffer-local-map boundp nil copy-keymap substitute-key-definition exit-minibuffer xscheme-prompt-for-expression-exit] 4) (defalias 'xscheme-prompt-for-expression-exit #[nil "\300ed\"\301=\203\f\302 \207\303\304!\207" [xscheme-region-expression-p one exit-minibuffer error "input must be a single, complete expression"] 3 nil nil]) (defalias 'xscheme-region-expression-p #[(start end) "\212\305 \306\216\307 !\210\310\n \"\311\f@!\205/\312\f8\205/\310\n\312\f8\"\312\f8\203-\313\202.\314),\207" [old-syntax-table scheme-mode-syntax-table start end state syntax-table ((set-syntax-table old-syntax-table)) set-syntax-table parse-partial-sexp zerop 2 many one] 4]) (provide 'xscheme)