;ELC ;;; compiled by cph@flenser.ai.mit.edu on Wed Jan 5 01:26:11 2000 ;;; from file /scheme/etc/xscheme.el ;;; emacs version 19.34.1. ;;; bytecomp version FSF 2.10 ;;; optimization is on. ;;; this file uses opcodes which do not exist in Emacs 18. (if (and (boundp 'emacs-version) (or (and (boundp 'epoch::version) epoch::version) (string-lessp emacs-version "19.29"))) (error "`xscheme.el' was compiled for Emacs 19.29 or later")) (require (quote scheme)) #@47 *Program invoked by the `run-scheme' command. (defvar scheme-program-name "scheme" (#$ . -482)) #@43 *Band loaded by the `run-scheme' command. (defvar scheme-band-name nil (#$ . -584)) #@70 *Arguments passed to the Scheme program by the `run-scheme' command. (defvar scheme-program-arguments nil (#$ . -674)) #@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. (defvar xscheme-allow-pipelined-evaluation t (#$ . 800)) #@59 Default global (shared) xscheme-runlight modeline format. (defvar default-xscheme-runlight (quote (": " xscheme-runlight-string)) (#$ . 1062)) #@122 String to insert into Scheme process buffer first time it is started. Is processed with `substitute-command-keys' first. (defvar 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" (#$ . 1212)) #@76 If non-nil, causes a message to be generated when the Scheme process dies. (defvar xscheme-signal-death-message nil (#$ . 1630)) #@47 *Process created by the `run-scheme' command. (defvar xscheme-process-name "*scheme*" (#$ . -1765)) #@46 *Buffer created by the `run-scheme' command. (defvar xscheme-buffer-name "*scheme*" (#$ . -1871)) (defalias 'xscheme-emacs-version>= #[(major minor) "ÀÁ\n\"\n TÄOÀÁ \"Ç\nÈ O!ǃ% ÈO‚& ! ‰\n V†?\n U…? \fY-‡" [string-match "\\." emacs-version first-dot nil esv second-dot string-to-int 0 emacs-version-minor emacs-version-major major minor] 6]) (defalias 'xscheme-evaluation-commands #[(keymap) "À ÂÃ#ˆÀ ÄÅ#ˆÀ ÆÇ#ˆÀ ÈÃ#ˆÀ ÉÊ#ˆÀ ËÌ#‡" [define-key keymap "" 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) "À ÂÃ#ˆÀ ÄÅ#ˆÀ ÆÇ#ˆÀ ÈÉ#ˆÀ ÊË#‡" [define-key keymap "" 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 "À !ˆÂ !‡" [xscheme-evaluation-commands scheme-mode-map 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) "À \n #‡" [scheme-start command-line xscheme-process-name xscheme-buffer-name] 4 (#$ . 2915) (list (read-scheme-command-line current-prefix-arg))]) #@27 Reset the Scheme process. (defalias 'reset-scheme #[nil "À !‰ƒÃ\n!Ä=ƒÅÆ!…2ÇÈ!ˆ\nƒ'É\nÊ\"ˆË\n!ˆÌ #ˆÇÏ!)‡" [get-process xscheme-process-name 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 xscheme-process-command-line xscheme-buffer-name "Resetting Scheme process...done"] 5 (#$ . 3225) nil]) (defalias 'scheme-start #[(command-line process-name buffer-name &optional avoid-set) "„ Á \"ˆÄÅ #!ˆÈÂ!ˆ ‰‡" [avoid-set set-default xscheme-process-command-line command-line switch-to-buffer xscheme-start-process process-name buffer-name make-local-variable] 5]) (defalias 'read-scheme-command-line #[(arg) "†Á  ƒÄÅ\n\"‚\n)‡" [xscheme-process-command-line xscheme-default-command-line default arg read-string "Run Scheme: "] 3]) (defalias 'xscheme-default-command-line #[nil "Á\nƒ\fÃ\nP‚ Ä ƒÆ P‚ÄR‡" [scheme-program-name " -emacs" scheme-program-arguments " " "" scheme-band-name " -band "] 5]) #@58 Choose a scheme interaction buffer, or create a new one. (defalias 'start-scheme #[(buffer-name &optional globally) "À !Ã\n!‰ƒÅ\n!‚>Æ\n!ƒ(ÇÈÁ\n!ÉÆ\n!Ê°!ƒ;ËÌÍ! ‰#ˆ…>Ï !‚>ÐÑ!*‡" [get-buffer-create buffer-name buffer get-buffer-process process switch-to-buffer buffer-file-name yes-or-no-p "Buffer " " contains file " "; start scheme in it? " scheme-start read-scheme-command-line t globally global-set-scheme-interaction-buffer message "start-scheme aborted"] 7 (#$ . 4301) (list (read-buffer "Scheme interaction buffer: " xscheme-buffer-name nil) current-prefix-arg)]) (fset (quote select-scheme) (quote start-scheme)) #@44 Set the default scheme interaction buffer. (defalias 'global-set-scheme-interaction-buffer #[(buffer-name) "À Â\"ÄÅ \"ˆÄÆ \"ˆÄÇŠ qˆ)\"ˆÄÈÉ !Ê=ƒ) ‚*Ì\")‡" [verify-xscheme-buffer buffer-name nil process-name set-default xscheme-buffer-name xscheme-process-name xscheme-runlight-string xscheme-runlight process-status run default-xscheme-runlight ""] 4 (#$ . 4937) (list (read-buffer "Scheme interaction buffer: " xscheme-buffer-name t))]) #@59 Set the scheme interaction buffer for the current buffer. (defalias 'local-set-scheme-interaction-buffer #[(buffer-name) "À Â\"ÄÅ!ˆ ÄÆ!ˆ ÄÇ!ˆŠ qˆ)‰)‡" [verify-xscheme-buffer buffer-name t process-name make-local-variable xscheme-buffer-name xscheme-process-name xscheme-runlight] 3 (#$ . 5386) (list (read-buffer "Scheme interaction buffer: " xscheme-buffer-name t))]) #@68 Make the current buffer use the default scheme interaction buffer. (defalias 'local-clear-scheme-interaction-buffer #[nil "À ƒ ÁÂ!ˆÃÄ!ˆÃÅ!ˆÃÆ!‡" [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 (#$ . 5769) nil]) (defalias 'verify-xscheme-buffer #[(buffer-name localp) "ƒ Á ƒ ÂÃ!ˆÄ !‰…Ç!„(ÂÉ \"‚H„4ÂÊ \"‚HŠqˆÁ „CÂÊ \"ˆ)Ë!*‡" [localp xscheme-process-buffer-current-p error "Cannot change the interaction buffer of an interaction buffer" get-buffer buffer-name buffer get-buffer-process process "Buffer does not exist" "Buffer is not a scheme interaction buffer" process-name] 4]) #@3297 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-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 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 #[(&optional preserve) "„e à ˆÄÅ!ˆÄÆ!ˆÄÇ!ˆÄÈ!ˆÄÉ!ˆÄÊ!ˆ\np Ì !Í !‰„>ωB‚dÐ!Ñ!Ò!BÓÔ!ˆÕ!ˆÖ×\"ˆØÙ\"ˆ+Ú ˆÛ ˆÜÝÞ\"‡" [preserve major-mode previous-mode kill-all-local-variables make-local-variable xscheme-previous-mode xscheme-buffer-name xscheme-process-name xscheme-previous-process-state xscheme-runlight-string xscheme-runlight buffer buffer-name get-buffer-process process nil process-name process-filter process-sentinel xscheme-process-filter-initialize t xscheme-modeline-initialize set-process-sentinel xscheme-process-sentinel set-process-filter xscheme-process-filter scheme-interaction-mode-initialize scheme-mode-variables run-hooks scheme-mode-hook scheme-interaction-mode-hook] 4 (#$ . 6516) "P"]) #@44 Take buffer out of scheme interaction mode (defalias 'exit-scheme-interaction-mode #[nil "Á=„\nÂÃ!ˆ\f ˆÇp!‰…8É!Ê=ƒ)Ë @\"ˆÌ!Í=…8Î A\"*‡" [major-mode scheme-interaction-mode error "Buffer not in scheme interaction mode" xscheme-previous-process-state previous-state xscheme-previous-mode get-buffer-process process process-filter xscheme-process-filter set-process-filter process-sentinel xscheme-process-sentinel set-process-sentinel] 4 (#$ . 10591) nil]) (defalias 'scheme-interaction-mode-initialize #[nil "„Á Â!ˆÃ!ˆÄ!ˆÅ!ˆÆ!ˆÇɉ\n‡" [scheme-interaction-mode-map make-keymap scheme-mode-commands xscheme-interrupt-commands xscheme-evaluation-commands scheme-interaction-mode-commands use-local-map scheme-interaction-mode major-mode "Scheme Interaction" mode-name] 2]) (byte-code "ÀÁ!„ÂÁ B‡" [boundp scheme-interaction-mode-map nil current-load-list] 2) (defalias 'scheme-interaction-mode-commands #[(keymap) "‰… @@ @A@#ˆ A‰„Ä)‡" [scheme-interaction-mode-commands-alist entries define-key keymap nil] 5]) (byte-code "ÀÁ!„ÂÁ BÄ Å\"‡" [boundp scheme-interaction-mode-commands-alist nil current-load-list append ((" " xscheme-send-current-line) ("" xscheme-send-proceed) ("" xscheme-yank) ("p" xscheme-yank-pop) ("n" xscheme-yank-push))] 3) (defalias 'xscheme-enter-interaction-mode #[nil "ŠÀ qˆ Â=?… Ã=ƒÄ ‚ÂÅ!)‡" [xscheme-process-buffer major-mode scheme-interaction-mode scheme-debugger-mode scheme-interaction-mode-initialize t] 2]) (fset (quote advertised-xscheme-send-previous-expression) (quote 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 "ÀÁ!‡" [error "Illegal entry to scheme-debugger-mode"] 2 (#$ . 12194)]) (defalias 'scheme-debugger-mode-initialize #[nil "À !ˆÂĉ‡" [use-local-map scheme-debugger-mode-map scheme-debugger-mode major-mode "Scheme Debugger" mode-name] 2]) (defalias 'scheme-debugger-mode-commands #[(keymap) "ÀÀÂW…Ã\fÅ !Æ#ˆ T‰‚)‡" [32 char 127 define-key keymap char-to-string scheme-debugger-self-insert] 5]) (byte-code "ÀÁ!„ÂÁ B „Ä Å !ˆÆ !ˆÇ !ˆÂ‡" [boundp scheme-debugger-mode-map nil current-load-list 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 "À !‡" [xscheme-send-char last-command-char] 2 (#$ . 13148) nil]) (defalias 'xscheme-enter-debugger-mode #[(prompt-string) "ŠÀ qˆ Â=?… Ã=„ÃÄ!ˆÅ )‡" [xscheme-process-buffer major-mode scheme-debugger-mode scheme-interaction-mode t scheme-debugger-mode-initialize] 2]) (defalias 'xscheme-debugger-mode-p #[nil "À ‰…Š qˆ\n)Ã=)‡" [xscheme-process-buffer buffer major-mode 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) "À „ÁÂ!…1à ˆÄ ˆÅ!‡Ç ƒÈÉ!‡\n„- ƒ-ÈÌ!‡Å!‡" [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 strings xscheme-debugger-mode-p error "No sends allowed in debugger mode" xscheme-allow-pipelined-evaluation xscheme-running-p "No sends allowed while Scheme running"] 2 (#$ . 13648)]) (defalias 'xscheme-send-string-1 #[(strings) "ÀÁ\n\"Ä !ˆ Æ=…Ç !)‡" [apply concat strings string xscheme-send-string-2 major-mode scheme-interaction-mode xscheme-insert-expression] 3]) (defalias 'xscheme-send-string-2 #[(string) "À !Ã\n\fÅP\"ˆÆ …Ç\n!`È“)‡" [get-process xscheme-process-name process send-string string "\n" xscheme-process-buffer-current-p process-mark nil] 4]) #@64 Select the Scheme process buffer and move to its output point. (defalias 'xscheme-select-process-buffer #[nil "À !† ÂÃ!Å\f!†ÂÆ!È!‰ ƒ'Ê !ˆ‚,Ë!ˆÌ\f!b+‡" [get-process xscheme-process-name error "No scheme process" process process-buffer "No process buffer" buffer get-buffer-window window select-window switch-to-buffer process-mark] 3 (#$ . 14574) nil]) (defalias 'xscheme-insert-expression #[(string) " B‰G\nVƒ\nS ›Ã¡ˆ ‰‡" [string xscheme-expressions-ring xscheme-expressions-ring-max nil xscheme-expressions-ring-yank-pointer] 3]) #@44 Rotate the yanking point in the kill ring. (defalias 'xscheme-rotate-yank-pointer #[(arg) "G‰ÂUƒÃÄ!‚/ GZ\\ ¦‰ÂWƒ' \\‚)›)‰)‡" [xscheme-expressions-ring length 0 error "Scheme expression ring is empty" arg xscheme-expressions-ring-yank-pointer index] 4 (#$ . 15130) "p"]) #@252 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]. (defalias 'xscheme-yank #[(&optional arg) "À <ƒ\n‚ Ã=ƒÄ‚ S!ˆÅ`!ˆ@cˆ :…(Ç ‡" [xscheme-rotate-yank-pointer arg 0 - -1 push-mark xscheme-expressions-ring-yank-pointer exchange-point-and-mark] 3 (#$ . 15426) "*P"]) (fset (quote xscheme-yank-previous-send) (quote xscheme-yank)) #@524 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. (defalias 'xscheme-yank-pop #[(arg) "À\nÀ=„À ˆ ÄZ ÅU?…6`Æ W`Æ |ˆÈ !ˆÉ`!ˆ\n@cˆ…5Ë )‡" [xscheme-yank this-command last-command arg 1 0 mark before xscheme-rotate-yank-pointer set-mark xscheme-expressions-ring-yank-pointer exchange-point-and-mark] 2 (#$ . 15969) "*p"]) #@541 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. (defalias 'xscheme-yank-push #[(arg) "À [!‡" [xscheme-yank-pop arg] 2 (#$ . 16777) "*p"]) #@92 Send the current region to the Scheme process. The region is sent terminated by a newline. (defalias 'xscheme-send-region #[(start end) "À ƒ bˆn„ÂÃ!ˆÄÅ!!`Ç“ˆÈ {!‡" [xscheme-process-buffer-current-p end insert-before-markers 10 process-mark get-process xscheme-process-name nil xscheme-send-string start] 3 (#$ . 17413) "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 "À‰ŠÃ ˆ`ÄÅÀÆ#ƒ`‚ÇÈ!ˆ)É\n \"*‡" [nil end start end-of-defun re-search-backward "^\\s(" t error "Can't find definition" xscheme-send-region] 4 (#$ . 17753) nil]) #@68 Send the expression to the right of `point' to the Scheme process. (defalias 'xscheme-send-next-expression #[nil "`ÁŠÂ ˆ`)\")‡" [start xscheme-send-region forward-sexp] 3 (#$ . 18153) nil]) #@67 Send the expression to the left of `point' to the Scheme process. (defalias 'xscheme-send-previous-expression #[nil "`ÁŠÂ ˆ`)\")‡" [end xscheme-send-region backward-sexp] 3 (#$ . 18351) nil]) #@98 Send the current line to the Scheme process. Useful for working with debugging Scheme under adb. (defalias 'xscheme-send-current-line #[nil "ŠÀyˆ`ˆ `{*ˆÄcˆÅ !)‡" [0 start nil line 10 xscheme-send-string-2] 2 (#$ . 18551) nil]) #@48 Send the current buffer to the Scheme process. (defalias 'xscheme-send-buffer #[nil "À ƒ ÁÂ!ˆÃed\"‡" [xscheme-process-buffer-current-p error "Not allowed to send this buffer's contents to Scheme" xscheme-send-region] 3 (#$ . 18790) nil]) #@59 Prompt for a character and send it to the Scheme process. (defalias 'xscheme-send-char #[(char) "À  !\"‡" [send-string xscheme-process-name char-to-string char] 4 (#$ . 19035) "cCharacter to send: "]) #@49 Cause the Scheme process to enter a breakpoint. (defalias 'xscheme-send-breakpoint-interrupt #[nil "ÀÁÂ\"‡" [xscheme-send-interrupt 98 nil] 3 (#$ . 19243) nil]) #@56 Cause the Scheme process to proceed from a breakpoint. (defalias 'xscheme-send-proceed #[nil "À Â\"‡" [send-string xscheme-process-name "(proceed)\n"] 3 (#$ . 19410) nil]) (defalias 'buffer-local-value-cell #[(buffer name) "Á !!ž‰„ÅÆ!‚\f)‡" [name buffer-local-variables get-buffer buffer pair error "buffer-local-value-cell: Not bound"] 5]) #@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 "À Ä\"„Ç!‚2 AƒÉÊ!‚2 À¡ˆÉË!ˆÇ!ˆÌÍÎ!\"*‡" [t inhibit-quit buffer-local-value-cell xscheme-buffer-name xscheme-control-g-disabled-p vcell xscheme-control-g-synchronization-p interrupt-process xscheme-process-name message "Relax..." "Sending C-G interrupt to Scheme..." send-string char-to-string 0] 4 (#$ . 19764) nil]) #@67 Cause the Scheme process to halt, returning to previous rep loop. (defalias 'xscheme-send-control-u-interrupt #[nil "ÀÁÂ\"‡" [xscheme-send-interrupt 117 t] 3 (#$ . 20249) nil]) #@66 Cause the Scheme process to halt, returning to current rep loop. (defalias 'xscheme-send-control-x-interrupt #[nil "ÀÁÂ\"‡" [xscheme-send-interrupt 120 t] 3 (#$ . 20432) nil]) #@49 Send a ^A type interrupt to the Scheme process. (defalias 'xscheme-send-interrupt #[(char mark-p) "À !ˆÂ Ã\f!\"ˆ …… ÃÇ!\"‡" [quit-process xscheme-process-name send-string char-to-string char mark-p xscheme-control-g-synchronization-p 0] 4 (#$ . 20614) "cInterrupt character to send: "]) #@55 Command used to start the most recent Scheme process. (defvar xscheme-process-command-line nil (#$ . 20914)) #@45 *Maximum length of Scheme expressions ring. (defvar xscheme-expressions-ring-max 30 (#$ . -21029)) #@65 List of expressions recently transmitted to the Scheme process. (defvar xscheme-expressions-ring nil (#$ . 21134)) #@77 The tail of the Scheme expressions ring whose car is the last thing yanked. (defvar xscheme-expressions-ring-yank-pointer nil (#$ . 21255)) #@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 (quote idle) (#$ . 21402)) #@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 (#$ . 21685)) #@203 If non-nil, insert markers in the scheme input stream to indicate when control-g interrupts were signalled. Do not allow more control-g's to be signalled until the scheme process acknowledges receipt. (defconst xscheme-control-g-synchronization-p t (#$ . 21860)) #@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 (#$ . 22131)) #@109 This variable, if nil, prevents output from the scheme process from being inserted into the process-buffer. (defvar xscheme-allow-output-p t (#$ . 22334)) #@35 The current scheme prompt string. (defvar xscheme-prompt "" (#$ . 22495)) #@68 Accumulator for the string being received from the scheme process. (defvar xscheme-string-accumulator "" (#$ . 22575)) #@64 Procedure to send the string argument from the scheme process. (defvar xscheme-string-receiver nil (#$ . 22700)) #@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. (defvar xscheme-start-hook nil (#$ . 22820)) (byte-code "ÀÁ!„ÂÁ BÀÄ!„ÅÄ BÀÆ!„!ÅÆ BÇÈÉ\"ˆÊËÌ\"‡" [boundp xscheme-runlight "" current-load-list xscheme-runlight-string nil xscheme-mode-string set-default scheme-mode-line-process ("" xscheme-runlight) mapcar make-variable-buffer-local (xscheme-expressions-ring xscheme-expressions-ring-yank-pointer xscheme-process-filter-state xscheme-running-p xscheme-control-g-disabled-p xscheme-allow-output-p xscheme-prompt xscheme-string-accumulator xscheme-mode-string scheme-mode-line-process)] 3) (defalias 'xscheme-start-process #[(command-line the-process the-buffer) "À !Ã\n!Š\nqˆ\fƒ\"Å\f!Æ>ƒ\"Ç\f!dÈ“ˆ‚’\fƒ*É\f!ˆdbˆÊÈ!ˆ \foƒ@ÍÎ!!ˆÈÑÒ \nÓ!BB\")Õ\f! š„_Õ\f!\fÖ\n! š„lÖ\n!ØÙ\f#ˆÇ\f!dÈ“ˆÚÛ!ˆÜ!ˆÝ\fÞ\"ˆß\fà\"ˆáâ!ˆ*\n)‡" [get-buffer-create the-buffer buffer get-buffer-process process process-status (run stop) process-mark nil delete-process scheme-interaction-mode the-process xscheme-process-name insert-before-markers substitute-command-keys xscheme-startup-message process-connection-type apply start-process xscheme-parse-command-line command-line process-name buffer-name xscheme-buffer-name message "Starting process %s in buffer %s" 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) "À !Âà ƒAÆÇ #‰„\" ÃO\fBÂ< Uƒ1ÆÉ #‚< O\fBT)‚\fŸ*‡" [substitute-in-file-name string 0 nil result start string-match "[ ]" index "[^ ]"] 5]) (defalias 'xscheme-wait-for-process #[nil "ÀÁ!ˆ\n…ÀÃ!ˆ‚‡" [sleep-for 2 xscheme-running-p 1] 2]) #@59 True iff there is a Scheme process whose status is `run'. (defalias 'xscheme-process-running-p #[nil "À !‰… Ã\n!Ä=)‡" [get-process xscheme-process-name process process-status run] 3 (#$ . 24683)]) (defalias 'xscheme-process-buffer #[nil "À !‰… Ã\n!)‡" [get-process xscheme-process-name process process-buffer] 3]) (defalias 'xscheme-process-buffer-window #[nil "À ‰…\n !)‡" [xscheme-process-buffer buffer get-buffer-window] 3]) #@59 True iff the current buffer is the Scheme process buffer. (defalias 'xscheme-process-buffer-current-p #[nil "À p=‡" [xscheme-process-buffer] 2 (#$ . 25124)]) (defalias 'xscheme-process-sentinel #[(proc reason) "À !Ã\n!Š\nqˆÅÇ=!ˆÇ=„-È Ê \fÌÍ!šƒ-ÎÏÈ\"ˆÐ>?…@…@Ò ˆÓÔ!+‡" [process-buffer proc buffer buffer-name name xscheme-process-filter-initialize reason run "" scheme-mode-line-process "no process" xscheme-mode-string default-value xscheme-buffer-name set-default xscheme-runlight (run stop) xscheme-signal-death-message beep message "The Scheme process has died! Do M-x reset-scheme to restart it"] 3]) (defalias 'xscheme-process-filter-initialize #[(running-p) "À\nÄÆÈ \nƒ-Êp! Ì Î !ˆ ÏÐ!šƒ,ÑÒ\"ˆ)=„<ÈšƒCÔÐÔÕFÖ›\nƒOÕ‚P× ‡" [idle xscheme-process-filter-state running-p xscheme-running-p nil xscheme-control-g-disabled-p t xscheme-allow-output-p "" xscheme-prompt buffer-name name (": " xscheme-runlight-string) scheme-mode-line-process xscheme-modeline-initialize default-value xscheme-buffer-name set-default xscheme-runlight default-xscheme-runlight ": " "?" 3 "no process"] 4]) (defalias 'xscheme-process-filter #[(proc string) "Á …àÁŠÄ !qˆÇ=ƒCÈÉ \"‰\nƒ6Ë Ì\nO!ˆ \nTÁOÍ‚? ÁË!ˆ))‚ÓÍ=ƒ† GÌUƒVÁ‚Ó ÌH ÏÁOÐ\"‰ƒyÓ8A@!ˆ‚‚ËÔ\"ˆÇ*‚ÓÕ=ƒÏÈÉ \"‰\nƒÃ Ì\nOP \nTÁOÇ<ƒº@‚¿!ˆ)‚Ë PÁ)‚ÓØÙ!ˆ)\nƒ\n!ˆ‚*‡" [string nil call-noexcursion xscheme-filter-input process-buffer proc xscheme-process-filter-state idle string-match "" start xscheme-process-filter-output 0 reading-type char 1 assoc xscheme-process-filter-alist entry 2 27 reading-string xscheme-string-accumulator xscheme-string-receiver error "Scheme process filter -- bad state"] 5]) (defalias 'xscheme-process-filter-output #[(&rest args) "…NÁ \"ŠÅ ˆÆÇ\f\"ƒJȔȕ \nË\fÈ\nO!ˆ\f\nHÌUƒ<n„5ËÍ!ˆËÌ!ˆ‚?Î ˆ\f\nTÏO*‚ Ë\f!*‡" [xscheme-allow-output-p apply concat args string xscheme-goto-output-point string-match "\\(\\|\f\\)" 0 end start insert-before-markers 12 10 beep nil] 4]) (defalias 'xscheme-guarantee-newlines #[(n) "…;ŠÁ ˆÂ „%nƒ%\fSoƒʼn‚ Æ ˆ‚\n)Á ˆ\fÇV…:ÈÉ!ˆ\fS‰‚*)‡" [xscheme-allow-output-p xscheme-goto-output-point nil stop n t backward-char 0 insert-before-markers 10] 3]) (defalias 'xscheme-goto-output-point #[nil "À !Ã\n!qˆÄ\n!b)‡" [get-process xscheme-process-name process process-buffer process-mark] 2]) (defalias 'xscheme-modeline-initialize #[(name) "À\nÃÄ!šƒÅÁÀ\"ˆÀ\nÇPÆD‰‡" ["" xscheme-runlight-string name default-value xscheme-buffer-name set-default xscheme-mode-string ": " mode-line-buffer-identification] 3]) (defalias 'xscheme-set-runlight #[(runlight) "Âp!ÃÄ!šƒÅÁ\"ˆÆ› ˆÈ ‡" [runlight xscheme-runlight-string buffer-name default-value xscheme-buffer-name set-default 3 xscheme-runlight xscheme-modeline-redisplay] 3]) (defalias 'xscheme-modeline-redisplay-1929 #[nil "ÀÁ!‡" [force-mode-line-update t] 2]) (defalias 'xscheme-modeline-redisplay-18 #[nil "ŠÀ qˆ)Á !ˆÃÄ!‡" [other-buffer set-buffer-modified-p buffer-modified-p sit-for 0] 2]) (byte-code "ÀÁÂÃ\"ƒ\fÄ‚ ÅM‡" [xscheme-modeline-redisplay xscheme-emacs-version>= 19 29 xscheme-modeline-redisplay-1929 xscheme-modeline-redisplay-18] 4) #@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 (quote ((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))) (#$ . 28368)) (defalias 'xscheme-process-filter:simple-action #[(action) "À\n ‡" [idle xscheme-process-filter-state action] 1]) (defalias 'xscheme-process-filter:string-action #[(action) "Âĉ‡" [action xscheme-string-receiver "" xscheme-string-accumulator reading-string xscheme-process-filter-state] 2]) (defalias 'xscheme-process-filter:string-action-noexcursion #[(action) "À ÂB!‡" [xscheme-process-filter:string-action action nil] 3]) #@61 The character displayed when the Scheme process is running. (defconst xscheme-runlight:running "run" (#$ . 30790)) #@71 The character displayed when the Scheme process is waiting for input. (defconst xscheme-runlight:input "input" (#$ . 30911)) #@72 The character displayed when the Scheme process is garbage collecting. (defconst xscheme-runlight:gc "gc" (#$ . 31042)) (defalias 'xscheme-start-gc #[nil "À !‡" [xscheme-set-runlight xscheme-runlight:gc] 2]) (defalias 'xscheme-finish-gc #[nil "À ƒ \n‚\n !‡" [xscheme-set-runlight xscheme-running-p xscheme-runlight:running xscheme-runlight:input] 2]) (defalias 'xscheme-enter-input-wait #[nil "À !ˆÂ‰‡" [xscheme-set-runlight xscheme-runlight:input nil xscheme-control-g-disabled-p xscheme-running-p] 2]) (defalias 'xscheme-exit-input-wait #[nil "À !ˆÂ‰‡" [xscheme-set-runlight xscheme-runlight:running t xscheme-running-p] 2]) (defalias 'xscheme-enable-control-g #[nil "À‰‡" [nil xscheme-control-g-disabled-p] 2]) (defalias 'xscheme-display-process-buffer #[nil "À † Á !Ä‹)‡" [xscheme-process-buffer-window display-buffer xscheme-process-buffer window ((byte-code "À !ˆÂ ˆÃ …Ä ‡" [select-window window xscheme-goto-output-point xscheme-debugger-mode-p xscheme-enter-interaction-mode] 2))] 2]) (defalias 'xscheme-unsolicited-read-char #[nil "À‡" [nil] 1]) (defalias 'xscheme-eval #[(string) "ÀÁ\n!@!‡" [eval read-from-string string] 3]) (defalias 'xscheme-message #[(string) "GÁU?…ÂÃÄ\"\"‡" [string 0 xscheme-write-message-1 format ";%s"] 5]) (defalias 'xscheme-write-value #[(string) "GÁUƒ\fÂÃÄ\"‡ÂÅÆ\"\"‡" [string 0 xscheme-write-message-1 "(no value)" ";No value" format ";Value: %s"] 5]) (defalias 'xscheme-write-message-1 #[(message-string output-string) "À !ÃÄ\n!!‰ƒÆÇ\n! \"„ÈÉ\n\"ˆ*ËÌ!ˆÍ!‡" [get-process xscheme-process-name process get-buffer-window process-buffer window pos-visible-in-window-p process-mark message "%s" message-string xscheme-guarantee-newlines 1 xscheme-process-filter-output output-string] 4]) (defalias 'xscheme-set-prompt-variable #[(string) "‰‡" [string xscheme-prompt] 2]) (defalias 'xscheme-set-prompt #[(string) "ÂÃ!ˆÄ!Æ ‡" [string xscheme-prompt xscheme-guarantee-newlines 2 xscheme-coerce-prompt xscheme-mode-string xscheme-modeline-redisplay] 2]) (defalias 'xscheme-output-goto #[nil "À ˆÁÂ!‡" [xscheme-goto-output-point xscheme-guarantee-newlines 2] 2]) (defalias 'xscheme-coerce-prompt #[(string) "ÀÁ\n\"ƒÕÅ\n\fÆO!ˆ\nÃ\fÇZO)‡\n‡" [string-match "^[0-9]+ \\[[^]]+\\] " string 0 end xscheme-process-filter-output nil 1] 4]) (defalias 'xscheme-cd #[(directory-string) "ŠÀ qˆÁ\n!)‡" [xscheme-process-buffer cd directory-string] 2]) (defalias 'xscheme-prompt-for-confirmation #[(prompt-string) "ÀÁ\n!ƒ Â\fÄ!‡" [xscheme-send-char y-or-n-p prompt-string 121 110] 3]) (defalias 'xscheme-prompt-for-expression #[(prompt-string) "ÀÁ\nÃ\f#!‡" [xscheme-send-string-2 read-from-minibuffer prompt-string nil xscheme-prompt-for-expression-map] 5]) (byte-code "ÀÁ!„ÂÁ B „Ä !ÆÇÈ #ˆÂ‡" [boundp xscheme-prompt-for-expression-map nil current-load-list copy-keymap minibuffer-local-map substitute-key-definition exit-minibuffer xscheme-prompt-for-expression-exit] 4) (defalias 'xscheme-prompt-for-expression-exit #[nil "Àed\"Á=ƒ\f ‡ÃÄ!‡" [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) "ŠÀ ÂŽÃ\f!ˆÅ\"‰@ÉU…7Ê8…7ÅÊ8\"Ê8ƒ5Ë‚6Ì),‡" [syntax-table old-syntax-table ((set-syntax-table old-syntax-table)) set-syntax-table scheme-mode-syntax-table parse-partial-sexp start end state 0 2 many one] 5])