Current File : //kunden/usr/share/emacs/27.2/lisp/progmodes/xscheme.elc

;ELC
;;; Compiled
;;; in Emacs version 27.2
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(require 'scheme)
#@55 Command used to start the most recent Scheme process.
(defvar xscheme-process-command-line nil (#$ . 426))
#@64 Name of xscheme process that we're currently interacting with.
(defvar xscheme-process-name "scheme" (#$ . 539))
#@63 Name of xscheme buffer that we're currently interacting with.
(defvar xscheme-buffer-name "*scheme*" (#$ . 658))
#@44 Maximum length of Scheme expressions ring.
(defvar xscheme-expressions-ring-max 30 (#$ . 777))
#@65 List of expressions recently transmitted to the Scheme process.
(defvar xscheme-expressions-ring nil (#$ . 878))
(make-variable-buffer-local 'xscheme-expressions-ring)
#@77 The tail of the Scheme expressions ring whose car is the last thing yanked.
(defvar xscheme-expressions-ring-yank-pointer nil (#$ . 1052))
(make-variable-buffer-local 'xscheme-expressions-ring-yank-pointer)
#@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 (#$ . 1266))
(make-variable-buffer-local 'xscheme-running-p)
#@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 (#$ . 1488))
#@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 (#$ . 1756))
(make-variable-buffer-local 'xscheme-control-g-disabled-p)
#@64 Procedure to send the string argument from the scheme process.
(defvar xscheme-string-receiver nil (#$ . 2016))
#@60 Default global (shared) xscheme-runlight mode line format.
(defconst default-xscheme-runlight '(": " xscheme-runlight-string) (#$ . 2134))
(defvar xscheme-runlight "")
(defvar xscheme-runlight-string nil)
#@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 (#$ . 2346))
(make-variable-buffer-local 'xscheme-process-filter-state)
#@75 Non-nil stops scheme process output being inserted in the process buffer.
(defvar xscheme-allow-output-p t (#$ . 2679))
(make-variable-buffer-local 'xscheme-allow-output-p)
#@35 The current scheme prompt string.
(defvar xscheme-prompt "" (#$ . 2858))
(make-variable-buffer-local 'xscheme-prompt)
#@68 Accumulator for the string being received from the scheme process.
(defvar xscheme-string-accumulator "" (#$ . 2982))
(make-variable-buffer-local 'xscheme-string-accumulator)
(defvar xscheme-mode-string nil nil)
(byte-code "\300\301!\210\302\303\304\"\210\300\303!\210\305\306\307\310\311\312%\210\313\314\315\316\317DD\320\321\322\311\306&\210\313\323\315\316\324DD\325\321\326\311\306&\210\313\327\315\316\330DD\331\321\332\311\306&\210\313\333\315\316\334DD\335\321\336\311\306&\210\313\337\315\316\340DD\341\321\332\311\306&\210\313\342\315\316\343DD\344\321\345\311\306\346\347&	\207" [make-variable-buffer-local xscheme-mode-string set-default scheme-mode-line-process ("" xscheme-runlight) custom-declare-group xscheme nil "Major mode for editing Scheme and interacting with MIT's C-Scheme." :group lisp custom-declare-variable scheme-band-name funcall function #[0 "\300\207" [nil] 1] "Band loaded by the `run-scheme' command." :type (choice (const nil) string) scheme-program-arguments #[0 "\300\207" [nil] 1] "Arguments passed to the Scheme program by the `run-scheme' command." (choice (const nil) string) xscheme-allow-pipelined-evaluation #[0 "\300\207" [t] 1] "If non-nil, an expression may be transmitted while another is evaluating.\nOtherwise, attempting to evaluate an expression before the previous expression\nhas finished evaluating will signal an error." boolean xscheme-startup-message #[0 "\300\207" [#1="This is the Scheme process buffer.\nType \\[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"] 1 #1#] "String to insert into Scheme process buffer first time it is started.\nIs processed with `substitute-command-keys' first." string xscheme-signal-death-message #[0 "\300\207" [nil] 1] "If non-nil, causes a message to be generated when the Scheme process dies." xscheme-start-hook #[0 "\300\207" [nil] 1] "If non-nil, a procedure to call when the Scheme process is started.\nWhen called, the current buffer will be the Scheme process-buffer." hook :version "20.3"] 10)
#@15 

(fn KEYMAP)
(defalias 'xscheme-evaluation-commands #[257 "\300
\301\302#\210\300
\303\304#\210\305\304\306\303#\210\300
\307\310#\210\300
\311\302#\210\300
\312\304#\210\300
\313\314#\207" [define-key "" xscheme-send-definition "" xscheme-send-previous-expression put :advertised-binding "o" xscheme-send-buffer "z" "
" "" xscheme-send-region] 5 (#$ . 5132)])
#@15 

(fn KEYMAP)
(defalias 'xscheme-interrupt-commands #[257 "\300
\301\302#\210\300
\303\304#\210\300
\305\306#\210\300
\307\310#\210\300
\311\312#\207" [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] 5 (#$ . 5509)])
(byte-code "\301!\210\302!\207" [scheme-mode-map xscheme-evaluation-commands xscheme-interrupt-commands] 2)
#@137 Run MIT Scheme in an inferior process.
Output goes to the buffer `*scheme*'.
With argument, asks for a command line.

(fn COMMAND-LINE)
(defalias 'run-scheme #[257 "\302
	#\207" [xscheme-process-name xscheme-buffer-name xscheme-start] 5 (#$ . 5994) (byte-code "\301!C\207" [current-prefix-arg xscheme-read-command-line] 2)])
#@46 

(fn COMMAND-LINE PROCESS-NAME BUFFER-NAME)
(defalias 'xscheme-start #[771 "\301\300\"\210\302\303#!\210\304\300!\210\211\207" [xscheme-process-command-line set-default switch-to-buffer xscheme-start-process make-local-variable] 8 (#$ . 6327)])
#@12 

(fn ARG)
(defalias 'xscheme-read-command-line #[257 "\206\301 
\203\302\303\"\202\211\207" [xscheme-process-command-line xscheme-default-command-line read-string "Run Scheme: "] 5 (#$ . 6585)])
(defalias 'xscheme-default-command-line #[0 "\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])
#@27 Reset the Scheme process.
(defalias 'reset-scheme #[0 "\303!\211\203\304
!\305=\203\306\307!\205/\310\311!\210\211\203&\312
\313\"\210\314
!\210\315	\n#\210\310\316!\207" [xscheme-process-name xscheme-process-command-line xscheme-buffer-name get-process 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 delete-process xscheme-start-process "Resetting Scheme process...done"] 5 (#$ . 6996) nil])
#@95 Choose a scheme interaction buffer, or create a new one.

(fn BUFFER-NAME &optional GLOBALLY)
(defalias 'start-scheme #[513 "\300!\301
!\211\203\302!\202<\303!\203'\304\305\306!\307\303!\310\260!\2039\311\312\313!\211#\210\205<\314!\202<\315\316!\262
\207" [get-buffer-create get-buffer-process switch-to-buffer buffer-file-name yes-or-no-p "Buffer " buffer-name " contains file " "; start scheme in it? " xscheme-start xscheme-read-command-line t global-set-scheme-interaction-buffer message "start-scheme aborted"] 10 (#$ . 7509) (byte-code "\302\303\304#	D\207" [xscheme-buffer-name current-prefix-arg read-buffer "Scheme interaction buffer: " nil] 4)])
(fset 'select-scheme 'start-scheme)
#@62 Set the default scheme interaction buffer.

(fn BUFFER-NAME)
(defalias 'global-set-scheme-interaction-buffer #[257 "\302
\303\"\304\305\"\210\304\306\"\210\304\300rq\210)\"\210\304\307\310!\311=\203&	\202'\312\"\207" [xscheme-runlight-string default-xscheme-runlight verify-xscheme-buffer nil set-default xscheme-buffer-name xscheme-process-name xscheme-runlight process-status run ""] 6 (#$ . 8226) (byte-code "\301\302\303#C\207" [xscheme-buffer-name read-buffer "Scheme interaction buffer: " t] 4)])
#@77 Set the scheme interaction buffer for the current buffer.

(fn BUFFER-NAME)
(defalias 'local-set-scheme-interaction-buffer #[257 "\303
\304\"\305\300!\210
\305\301!\210\211\305\302!\210r
q\210\n)\211\207" [xscheme-buffer-name xscheme-process-name xscheme-runlight verify-xscheme-buffer t make-local-variable] 4 (#$ . 8743) (byte-code "\301\302\303#C\207" [xscheme-buffer-name read-buffer "Scheme interaction buffer: " t] 4)])
#@68 Make the current buffer use the default scheme interaction buffer.
(defalias 'local-clear-scheme-interaction-buffer #[0 "\300 \203	\301\302!\210\303\304!\210\303\305!\210\303\306!\207" [xscheme-process-buffer-current-p error "Cannot change the interaction buffer of an interaction buffer" kill-local-variable xscheme-buffer-name xscheme-process-name xscheme-runlight] 2 (#$ . 9179) nil])
#@27 

(fn BUFFER-NAME LOCALP)
(defalias 'verify-xscheme-buffer #[514 "\211\203
\300 \203
\301\302!\210\303!\211\205\304
!
\204\"\301\305\"\202?\211\204-\301\306\"\202?r
q\210\300 \204;\301\306\"\210)\307
!\207" [xscheme-process-buffer-current-p error "Cannot change the interaction buffer of an interaction buffer" get-buffer get-buffer-process "Buffer `%s' does not exist" "Buffer `%s' is not a scheme interaction buffer" process-name] 7 (#$ . 9574)])
#@3184 Major mode for interacting with an inferior MIT Scheme process.
Like `scheme-mode' except that:

\[xscheme-send-previous-expression] sends the expression before point to the Scheme process as input
\[xscheme-yank-pop] yanks an expression previously sent to Scheme
\[xscheme-yank-push] yanks an expression more 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 mode lines 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 mode line 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
`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 runs `scheme-mode-hook' and then
`scheme-interaction-mode-hook'.

(fn &optional PRESERVE)
(defalias 'scheme-interaction-mode #[256 "\211\204\203\305 \210\306\307!\210\306\310!\210\306\301!\210\211p\306\302!\210\311
!\306\303!\210\312 \313
!\211\203\201\306\304!\210\314
!\315\316!\210\317\n!\210\320\321\322\323\324\325\326!\327\"\330$\322\331\332\325\326!\333\"\334\335%B\262
\336\337$\210\320\321\322\323\324\325\326!\340\"\330$\322\331\332\325\326!\341\"\334\335%B\262
\342\337$\210\266\343 \210\344 \210\345\346\347\"\207" [major-mode xscheme-previous-mode xscheme-buffer-name xscheme-last-input-end xscheme-process-name kill-all-local-variables make-local-variable xscheme-runlight-string xscheme-runlight buffer-name make-marker get-buffer-process process-name xscheme-process-filter-initialize t xscheme-mode-line-initialize advice--add-function :override make-byte-code 0 "\301\300!\207" vconcat vector [process-sentinel] 2 257 "\301\300\"\207" [set-process-sentinel] 4 "\n\n(fn GV--VAL)" xscheme-process-sentinel nil [process-filter] [set-process-filter] xscheme-process-filter scheme-interaction-mode-initialize scheme-mode-variables run-mode-hooks scheme-mode-hook scheme-interaction-mode-hook] 14 (#$ . 10044) "P"])
#@45 Take buffer out of scheme interaction mode.
(defalias 'exit-scheme-interaction-mode #[0 "\301\302!\204\n\303\304!\210 \210\305p!\211\205@\211\306\307!\310\"\211\307!=\204(\311\"\210\266\211\306\312!\313\"\211\312!=?\205>\314\"\266\202\207" [xscheme-previous-mode derived-mode-p scheme-interaction-mode error "Buffer not in scheme interaction mode" get-buffer-process advice--remove-function process-sentinel xscheme-process-sentinel set-process-sentinel process-filter xscheme-process-filter set-process-filter] 6 (#$ . 14388) nil])
(defvar scheme-interaction-mode-commands-alist nil)
(defvar scheme-interaction-mode-map nil)
(defalias 'scheme-interaction-mode-initialize #[0 "\303!\210\304\305\211\207" [scheme-interaction-mode-map major-mode mode-name use-local-map scheme-interaction-mode "Scheme Interaction"] 2])
#@15 

(fn KEYMAP)
(defalias 'scheme-interaction-mode-commands #[257 "\211\205\301@@@A@#\210\211A\262
\202
\207" [scheme-interaction-mode-commands-alist define-key] 6 (#$ . 15229)])
(byte-code "\302\303\"	\204\304 \305	!\210\306	!\210\307	!\210\310	!\210\302\207" [scheme-interaction-mode-commands-alist scheme-interaction-mode-map append (("
" xscheme-send-current-line) ("" xscheme-delete-output) ("" xscheme-send-proceed) ("" xscheme-yank) ("p" xscheme-yank-pop) ("n" xscheme-yank-push)) make-keymap scheme-mode-commands xscheme-interrupt-commands xscheme-evaluation-commands scheme-interaction-mode-commands] 3)
(defalias 'xscheme-enter-interaction-mode #[0 "r\300 q\210\301\302!?\205\301\303!\203\304 \202\302\305!)\207" [xscheme-process-buffer derived-mode-p scheme-interaction-mode scheme-debugger-mode scheme-interaction-mode-initialize t] 2])
(byte-code "\300\301\302\303#\210\304\301\302\305#\207" [defalias advertised-xscheme-send-previous-expression xscheme-send-previous-expression nil make-obsolete "23.2"] 4)
#@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 #[0 "\300\301!\207" [error "Invalid entry to scheme-debugger-mode"] 2 (#$ . 16282)])
(defvar scheme-debugger-mode-map nil)
(defalias 'scheme-debugger-mode-initialize #[0 "\303!\210\304\305\211\207" [scheme-debugger-mode-map major-mode mode-name use-local-map scheme-debugger-mode "Scheme Debugger"] 2])
#@15 

(fn KEYMAP)
(defalias 'scheme-debugger-mode-commands #[257 "\300\211\301W\205\302\303!\304#\210\211T\262
\202
\207" [32 127 define-key char-to-string scheme-debugger-self-insert] 6 (#$ . 16941)])
(byte-code "\204\301 \302!\210\303!\210\304!\210\301\207" [scheme-debugger-mode-map 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 #[0 "\301!\207" [last-command-event xscheme-send-char] 2 (#$ . 17335) nil])
#@22 

(fn PROMPT-STRING)
(defalias 'xscheme-enter-debugger-mode #[257 "r\300 q\210\301\302!?\205\301\303!\204\303\304!\210\305 )\207" [xscheme-process-buffer derived-mode-p scheme-debugger-mode scheme-interaction-mode t scheme-debugger-mode-initialize] 3 (#$ . 17504)])
(defalias 'xscheme-debugger-mode-p #[0 "\300 \211\205r\211q\210\301\302!)\207" [xscheme-process-buffer derived-mode-p scheme-debugger-mode] 3])
#@128 Send the string arguments to the Scheme process.
The strings are concatenated and terminated by a newline.

(fn &rest STRINGS)
(defalias 'xscheme-send-string #[128 "\302 \204\303\304!\205-\305 \210\306 \210\307
!\207\310 \203\311\312!\207\204*	\203*\311\313!\207\307
!\207" [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 xscheme-send-string-1 xscheme-debugger-mode-p error "No sends allowed in debugger mode" "No sends allowed while Scheme running"] 3 (#$ . 17927)])
#@16 

(fn STRINGS)
(defalias 'xscheme-send-string-1 #[257 "\300\301\"\302
!\210\303\304!\205\305
!\207" [apply concat xscheme-send-string-2 derived-mode-p scheme-interaction-mode xscheme-insert-expression] 4 (#$ . 18534)])
#@15 

(fn STRING)
(defalias 'xscheme-send-string-2 #[257 "\301!\302
\303P\"\210\304 \205\305
!`\306\223\207" [xscheme-process-name get-process process-send-string "\n" xscheme-process-buffer-current-p process-mark nil] 6 (#$ . 18762)])
#@64 Select the Scheme process buffer and move to its output point.
(defalias 'xscheme-select-process-buffer #[0 "\301!\206	\302\303!\304
!\206\302\305!\306
!\211\203 \307
!\210\202$\310!\210\311!b\262
\262
\207" [xscheme-process-name get-process error "No scheme process" process-buffer "No process buffer" get-buffer-window select-window switch-to-buffer process-mark] 5 (#$ . 19004) nil])
#@15 

(fn STRING)
(defalias 'xscheme-insert-expression #[257 "\302\303#\211\207" [xscheme-expressions-ring-max xscheme-expressions-ring-yank-pointer add-to-history xscheme-expressions-ring] 5 (#$ . 19405)])
#@54 Rotate the yanking point in the kill ring.

(fn ARG)
(defalias 'xscheme-rotate-yank-pointer #[257 "G\211\302U\203\303\304!\202)

	GZ\\
\246\211\302W\203\"\211\\\202#\211\233\262
\211\207" [xscheme-expressions-ring xscheme-expressions-ring-yank-pointer 0 error "Scheme expression ring is empty"] 5 (#$ . 19617) "p"])
#@272 Insert the most recent expression at point.
With just C-U as argument, same but put point in front (and mark at end).
With argument n, reinsert the nth most recently sent expression.
See also the commands \[xscheme-yank-pop] and \[xscheme-yank-push].

(fn &optional ARG)
(defalias 'xscheme-yank #[256 "\301
<\203\n\302\202
\303=\203\304\202
S!\210\305 \210@c\210\211:\205&\306 \207" [xscheme-expressions-ring-yank-pointer xscheme-rotate-yank-pointer 0 - -1 push-mark exchange-point-and-mark] 4 (#$ . 19949) "*P"])
(fset 'xscheme-yank-previous-send 'xscheme-yank)
#@536 Insert or replace a just-yanked expression with an older expression.
If the previous command was not a yank, it yanks.
Otherwise, the region contains a stretch of reinserted
expression.  `yank-pop' deletes that text and inserts in its
place a different expression.

With no argument, the next older expression is inserted.
With argument n, the n'th older expression is inserted.
If n is negative, this is a more recent expression.

The sequence of expressions wraps around, so that after the oldest one
comes the newest one.

(fn ARG)
(defalias 'xscheme-yank-pop #[257 "\303	\303=\204\303 \210\211S\262
\211\304U?\2053`\305 W`\305 |\210\306!\210\307`!\210\n@c\210\211\2051\310 \262
\207" [this-command last-command xscheme-expressions-ring-yank-pointer xscheme-yank 0 mark xscheme-rotate-yank-pointer set-mark exchange-point-and-mark] 4 (#$ . 20528) "*p"])
#@553 Insert or replace a just-yanked expression with a more recent expression.
If the previous command was not a yank, it yanks.
Otherwise, the region contains a stretch of reinserted
expression.  `yank-pop' deletes that text and inserts in its
place a different expression.

With no argument, the next more recent expression is inserted.
With argument n, the n'th more recent expression is inserted.
If n is negative, a less recent expression is used.

The sequence of expressions wraps around, so that after the oldest one
comes the newest one.

(fn ARG)
(defalias 'xscheme-yank-push #[257 "\300\301Z!\207" [xscheme-yank-pop 0] 4 (#$ . 21398) "*p"])
#@108 Send the current region to the Scheme process.
The region is sent terminated by a newline.

(fn START END)
(defalias 'xscheme-send-region #[514 "\302 \203\211b\210n\204\303\304!\210\305\306!!`\307\223\210	`\307\223\210\310{!\207" [xscheme-process-name xscheme-last-input-end xscheme-process-buffer-current-p insert-before-markers 10 process-mark get-process nil xscheme-send-string] 5 (#$ . 22053) "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 #[0 "\300\211\212\301 \210`\262
\302\303\300\304#\203`\262\202\305\306!\210)\307\"\207" [nil end-of-defun re-search-backward "^\\s(" t error "Can't find definition" xscheme-send-region] 6 (#$ . 22471) nil])
#@68 Send the expression to the right of `point' to the Scheme process.
(defalias 'xscheme-send-next-expression #[0 "`\300
\212\301 \210`)\"\207" [xscheme-send-region forward-sexp] 4 (#$ . 22911) nil])
#@67 Send the expression to the left of `point' to the Scheme process.
(defalias 'xscheme-send-previous-expression #[0 "`\300\212\301 \210`)\"\207" [xscheme-send-region backward-sexp] 4 (#$ . 23114) nil])
#@98 Send the current line to the Scheme process.
Useful for working with debugging Scheme under adb.
(defalias 'xscheme-send-current-line #[0 "\300 \301 {\302\210\303c\210\304
!\207" [line-beginning-position line-end-position nil 10 xscheme-send-string-2] 3 (#$ . 23321) nil])
#@48 Send the current buffer to the Scheme process.
(defalias 'xscheme-send-buffer #[0 "\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 (#$ . 23601) nil])
#@70 Prompt for a character and send it to the Scheme process.

(fn CHAR)
(defalias 'xscheme-send-char #[257 "\301\302!\"\207" [xscheme-process-name process-send-string char-to-string] 5 (#$ . 23865) "cCharacter to send: "])
#@54 Delete all output from interpreter since last input.
(defalias 'xscheme-delete-output #[0 "\301p!\212\302
!b\210\303\304\305#\210\306y\210\307!`W\205!`|\210\310\311!)\207" [xscheme-last-input-end get-buffer-process process-mark re-search-backward "^;\\(Unspecified return value$\\|Value\\( [0-9]+\\)?: \\|\\(Abort\\|Up\\|Quit\\)!$\\)" t 0 marker-position insert-before-markers "*** output flushed ***\n"] 5 (#$ . 24093) nil])
#@49 Cause the Scheme process to enter a breakpoint.
(defalias 'xscheme-send-breakpoint-interrupt #[0 "\300\301\302\"\207" [xscheme-send-interrupt 98 nil] 3 (#$ . 24529) nil])
#@56 Cause the Scheme process to proceed from a breakpoint.
(defalias 'xscheme-send-proceed #[0 "\301\302\"\207" [xscheme-process-name process-send-string "(proceed)\n"] 3 (#$ . 24706) nil])
(defconst xscheme-control-g-message-string "Sending C-G interrupt to Scheme...")
#@96 Cause the Scheme processor to halt and flush input.
Control returns to the top level rep loop.
(defalias 'xscheme-send-control-g-interrupt #[0 "\306	\204\f\307\n!\2021rq\210\f)\203\310\311!\2021rq\210\306)\310
!\210\307\n!\210\312\313!\210\314\315!)\207" [inhibit-quit xscheme-control-g-synchronization-p xscheme-process-name xscheme-buffer-name xscheme-control-g-disabled-p xscheme-control-g-message-string t interrupt-process message "Relax..." sleep-for 0.1 xscheme-send-char 0] 2 (#$ . 24980) nil])
#@67 Cause the Scheme process to halt, returning to previous rep loop.
(defalias 'xscheme-send-control-u-interrupt #[0 "\300\301\302\"\207" [xscheme-send-interrupt 117 t] 3 (#$ . 25498) nil])
#@66 Cause the Scheme process to halt, returning to current rep loop.
(defalias 'xscheme-send-control-x-interrupt #[0 "\300\301\302\"\207" [xscheme-send-interrupt 120 t] 3 (#$ . 25691) nil])
#@67 Send a ^A type interrupt to the Scheme process.

(fn CHAR MARK-P)
(defalias 'xscheme-send-interrupt #[514 "\302!\210\303\304!\210\305!\210\211\205	\205\305\306!\207" [xscheme-process-name xscheme-control-g-synchronization-p quit-process sleep-for 0.1 xscheme-send-char 0] 4 (#$ . 25883) "cInterrupt character to send: "])
#@44 

(fn COMMAND-LINE THE-PROCESS THE-BUFFER)
(defalias 'xscheme-start-process #[771 "\304
!\305
!r
q\210\211\203 \306
!\307>\203 \310
!d\311\223\210\202\206\211\203(\312
!\210db\210\313\311!\210o\203;\314\315	!!\210\311\316\317\320	!BB\")\262
\321
!\232\204W\321
!\322!\232\204c\322!\323\324#\210\310
!d\311\223\210\325\326!\210\327!\210\330
\331\"\210\332
\333\"\210\334\335!\210)\210\211\207" [xscheme-process-name xscheme-startup-message process-connection-type xscheme-buffer-name get-buffer-create get-buffer-process process-status (run stop) process-mark nil delete-process scheme-interaction-mode insert-before-markers substitute-command-keys apply start-process xscheme-parse-command-line process-name buffer-name message "Starting process %s in buffer %s" xscheme-process-filter-initialize t xscheme-mode-line-initialize set-process-sentinel xscheme-process-sentinel set-process-filter xscheme-process-filter run-hooks xscheme-start-hook] 11 (#$ . 26217)])
#@15 

(fn STRING)
(defalias 'xscheme-parse-command-line #[257 "\300
!\262
\301\302
\203?\303\304#\211\204 \305\"B\262\302\2029\211U\203.\303\306#\2029\305#B\262\211T\262\210\202\211\237\207" [substitute-in-file-name 0 nil string-match "[ 	]" substring "[^ 	]"] 8 (#$ . 27209)])
(defalias 'xscheme-wait-for-process #[0 "\301\302!\210\205\301\303!\210\202\207" [xscheme-running-p sleep-for 2 1] 2])
#@58 True if there is a Scheme process whose status is `run'.
(defalias 'xscheme-process-running-p #[0 "\301!\211\205\f\302
!\303=\207" [xscheme-process-name get-process process-status run] 3 (#$ . 27635)])
(defalias 'xscheme-process-buffer #[0 "\301!\211\205\n\302
!\207" [xscheme-process-name get-process process-buffer] 3])
(defalias 'xscheme-process-buffer-window #[0 "\300 \211\205	\301
!\207" [xscheme-process-buffer get-buffer-window] 3])
#@58 True if the current buffer is the Scheme process buffer.
(defalias 'xscheme-process-buffer-current-p #[0 "\300 p=\207" [xscheme-process-buffer] 2 (#$ . 28087)])
#@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 '((65 xscheme-eval xscheme-process-filter:string-action-noexcursion) (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) (99 xscheme-unsolicited-read-char 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)) (#$ . 28255))
#@20 

(fn PROC REASON)
(defalias 'xscheme-process-sentinel #[514 "\303!\304
!r
q\210\305\306=!\210\306=\204'\307\310\211\311\312!\232\203'\313\314\307\"\210\315>?\2058\n\2058\316 \210\317\320!)\207" [scheme-mode-line-process xscheme-mode-string xscheme-signal-death-message process-buffer buffer-name xscheme-process-filter-initialize run "" "no process" default-value xscheme-buffer-name set-default xscheme-runlight (run stop) beep message "The Scheme process has died!  Do M-x reset-scheme to restart it"] 7 (#$ . 30240)])
#@18 

(fn RUNNING-P)
(defalias 'xscheme-process-filter-initialize #[257 "\306\211\307\310\311\211\203&\312p!\313\314
!\210\211\315\316!\232\203%\317\320\"\210\210=\2045\311\232\203<\321\316\321\322F\323\233
\203H\322\202I\324\240\207" [xscheme-process-filter-state xscheme-running-p xscheme-control-g-disabled-p xscheme-allow-output-p xscheme-prompt scheme-mode-line-process idle nil t "" buffer-name (": " xscheme-runlight-string) xscheme-mode-line-initialize default-value xscheme-buffer-name set-default xscheme-runlight ": " "?" 3 "no process" default-xscheme-runlight] 5 (#$ . 30778)])
#@20 

(fn PROC STRING)
(defalias 'xscheme-process-filter #[514 "\211\304
\205\274\304\262
r\305!q\210\306\267\202\254\307\310\"\211\2031\311\312\313#!\210\312T\"\262\314\202:\304\262\311
!\266\210\202\260
G\313U\203K\304\262\202\260
\313H\312\315\"\262\316
	\"\211\203g\317
8
A@!\210\202n\311\320\"\210\321\266\202\260\307\310\"\211\203\241\n\312\313#P\312T\"\262\321<\203\231@\211\262\202\235
!\210\210\202\250\nP\304\262\210\202\260\322\323!\210)\211\203
!\210\202\207" [xscheme-process-filter-state xscheme-process-filter-alist xscheme-string-accumulator xscheme-string-receiver nil process-buffer #s(hash-table size 3 test eq rehash-size 1.5 rehash-threshold 0.8125 purecopy t data (idle 21 reading-type 62 reading-string 115)) string-match "" xscheme-process-filter-output substring 0 reading-type 1 assoc 2 27 idle error "Scheme process filter -- bad state"] 10 (#$ . 31395)])
#@19 

(fn &rest ARGS)
(defalias 'xscheme-process-filter-output #[128 "\205\\\302\303\"\212\304 \210`\305\306\"\203C\307\224\310\311\307#!\210
H\312U\2035n\204.\310\313!\210\310\312!\210\2028\314 \210\311T\"\262\210\202
\310!\210	\205W\315	!`\232\205W	
\316\223\262
)\262
\207" [xscheme-allow-output-p xscheme-last-input-end apply concat xscheme-goto-output-point string-match "\\(\\|\f\\)" 0 insert-before-markers substring 12 10 beep marker-position nil] 9 (#$ . 32334)])
#@10 

(fn N)
(defalias 'xscheme-guarantee-newlines #[257 "\205;\212\301 \210\302\211\204%n\203%
S\262o\203\303\262
\202	\304u\210\202	\210\301 \210\211\305V\205:\306\307!\210\211S\262
\202))\207" [xscheme-allow-output-p xscheme-goto-output-point nil t -1 0 insert-before-markers 10] 3 (#$ . 32828)])
(defalias 'xscheme-goto-output-point #[0 "\301!\302
!q\210\303
!b\207" [xscheme-process-name get-process process-buffer process-mark] 3])
#@13 

(fn NAME)
(defalias 'xscheme-mode-line-initialize #[257 "\303\211\304\305!\232\203\306\300\303\"\210\303\211\307P\301D\211\207" [xscheme-runlight-string xscheme-mode-string mode-line-buffer-identification "" default-value xscheme-buffer-name set-default ": "] 4 (#$ . 33280)])
#@17 

(fn RUNLIGHT)
(defalias 'xscheme-set-runlight #[257 "\211\302p!\303\304!\232\203\305\300\"\210\306	\233
\240\210\307\310!\207" [xscheme-runlight-string xscheme-runlight buffer-name default-value xscheme-buffer-name set-default 3 force-mode-line-update t] 4 (#$ . 33570)])
#@15 

(fn ACTION)
(defalias 'xscheme-process-filter:simple-action #[257 "\301\211 \207" [xscheme-process-filter-state idle] 2 (#$ . 33854)])
#@15 

(fn ACTION)
(defalias 'xscheme-process-filter:string-action #[257 "\211\303\304\211\207" [xscheme-string-receiver xscheme-string-accumulator xscheme-process-filter-state "" reading-string] 3 (#$ . 33998)])
#@15 

(fn ACTION)
(defalias 'xscheme-process-filter:string-action-noexcursion #[257 "\300
\301B!\207" [xscheme-process-filter:string-action nil] 4 (#$ . 34215)])
#@61 The character displayed when the Scheme process is running.
(defconst xscheme-runlight:running "run" (#$ . 34379))
#@71 The character displayed when the Scheme process is waiting for input.
(defconst xscheme-runlight:input "input" (#$ . 34500))
#@72 The character displayed when the Scheme process is garbage collecting.
(defconst xscheme-runlight:gc "gc" (#$ . 34631))
(defalias 'xscheme-start-gc #[0 "\301!\207" [xscheme-runlight:gc xscheme-set-runlight] 2])
(defalias 'xscheme-finish-gc #[0 "\303\203		\202\n\n!\207" [xscheme-running-p xscheme-runlight:running xscheme-runlight:input xscheme-set-runlight] 2])
(defalias 'xscheme-enter-input-wait #[0 "\303!\210\304\211\211\207" [xscheme-runlight:input xscheme-control-g-disabled-p xscheme-running-p xscheme-set-runlight nil] 3])
(defalias 'xscheme-exit-input-wait #[0 "\302!\210\303\211\207" [xscheme-runlight:running xscheme-running-p xscheme-set-runlight t] 2])
(defalias 'xscheme-enable-control-g #[0 "\302\303 	\230\205\f\304\302!\207" [xscheme-control-g-disabled-p xscheme-control-g-message-string nil current-message message] 2])
(defalias 'xscheme-display-process-buffer #[0 "\300 \206	\301\302 !\303 \304\305\306\307\310!\311\"\312$\216\313!\210\314 \210\315 \205%\316 )\262
\207" [xscheme-process-buffer-window display-buffer xscheme-process-buffer current-window-configuration make-byte-code 0 "\301\300!\207" vconcat vector [set-window-configuration] 2 select-window xscheme-goto-output-point xscheme-debugger-mode-p xscheme-enter-interaction-mode] 8])
(defalias 'xscheme-unsolicited-read-char #[0 "\300\207" [nil] 1])
#@15 

(fn STRING)
(defalias 'xscheme-eval #[257 "\300\301!@!\207" [eval read-from-string] 4 (#$ . 35985)])
#@15 

(fn STRING)
(defalias 'xscheme-message #[257 "\211G\300U?\205\301
\302\303\"\"\207" [0 xscheme-write-message-1 format ";%s"] 6 (#$ . 36095)])
#@15 

(fn STRING)
(defalias 'xscheme-write-value #[257 "\211G\300U\203\f\301\302\303\"\207\301
\304\305\"\"\207" [0 xscheme-write-message-1 "(no value)" ";Unspecified return value" format ";Value: %s"] 6 (#$ . 36248)])
#@37 

(fn MESSAGE-STRING OUTPUT-STRING)
(defalias 'xscheme-write-message-1 #[514 "\301!\302\303!!\211\203\304\305!\"\204\306\307\"\210\266\310\311!\210\312
!\207" [xscheme-process-name get-process get-buffer-window process-buffer pos-visible-in-window-p process-mark message "%s" xscheme-guarantee-newlines 1 xscheme-process-filter-output] 7 (#$ . 36471)])
#@15 

(fn STRING)
(defalias 'xscheme-set-prompt-variable #[257 "\211\211\207" [xscheme-prompt] 3 (#$ . 36840)])
#@15 

(fn STRING)
(defalias 'xscheme-set-prompt #[257 "\211\302\303!\210\304
!\305\306!\207" [xscheme-prompt xscheme-mode-string xscheme-guarantee-newlines 2 xscheme-coerce-prompt force-mode-line-update t] 3 (#$ . 36955)])
(defalias 'xscheme-output-goto #[0 "\300 \210\301\302!\207" [xscheme-goto-output-point xscheme-guarantee-newlines 2] 2])
#@15 

(fn STRING)
(defalias 'xscheme-coerce-prompt #[257 "\300\301\"\203\302\225\303\304\"!\210\304\302S#\207\207" [string-match "^[0-9]+ \\[[^]]+\\] " 0 xscheme-process-filter-output substring] 6 (#$ . 37303)])
#@25 

(fn DIRECTORY-STRING)
(defalias 'xscheme-cd #[257 "r\300 q\210\301
!)\207" [xscheme-process-buffer cd] 3 (#$ . 37524)])
#@22 

(fn PROMPT-STRING)
(defalias 'xscheme-prompt-for-confirmation #[257 "\300\301!\203\302\202\f\303!\207" [xscheme-send-char y-or-n-p 121 110] 4 (#$ . 37652)])
(defvar xscheme-prompt-for-expression-map nil)
(byte-code "\204\302	!\303\304\305#\210\302\207" [xscheme-prompt-for-expression-map minibuffer-local-map copy-keymap substitute-key-definition exit-minibuffer xscheme-prompt-for-expression-exit] 4)
#@22 

(fn PROMPT-STRING)
(defalias 'xscheme-prompt-for-expression #[257 "\301\302\303#!\207" [xscheme-prompt-for-expression-map xscheme-send-string-2 read-from-minibuffer nil] 6 (#$ . 38071)])
(defalias 'xscheme-prompt-for-expression-exit #[0 "\300\301 d\"\302=\203
\303 \207\304\305!\207" [xscheme-region-expression-p minibuffer-prompt-end one exit-minibuffer error "Input must be a single, complete expression"] 3 nil nil])
#@18 

(fn START END)
(defalias 'xscheme-region-expression-p #[514 "\212\301 \302\303\304\305\306!\307\"\310$\216\311!\210\312\"\211@\303U\2057\310
8\2057\312\3108\"\310
8\2034\313\2025\314\262
\262
)\262
)\207" [scheme-mode-syntax-table syntax-table make-byte-code 0 "\301\300!\207" vconcat vector [set-syntax-table] 2 set-syntax-table parse-partial-sexp many one] 9 (#$ . 38502)])
(provide 'xscheme)