1 ;; Run Scheme under Emacs
2 ;; Copyright (C) 1986, 1987, 1989, 1990 Free Software Foundation, Inc.
4 ;; This file is part of GNU Emacs.
6 ;; GNU Emacs is free software; you can redistribute it and/or modify
7 ;; it under the terms of the GNU General Public License as published by
8 ;; the Free Software Foundation; either version 1, or (at your option)
11 ;; GNU Emacs is distributed in the hope that it will be useful,
12 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
13 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 ;; GNU General Public License for more details.
16 ;; You should have received a copy of the GNU General Public License
17 ;; along with GNU Emacs; see the file COPYING. If not, write to
18 ;; the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
20 ;;; Requires C-Scheme release 5 or later
21 ;;; Changes to Control-G handler require runtime version 13.85 or later
23 ;;; $Header: xscheme.el,v 1.26 90/09/11 01:51:20 GMT cph Exp $
27 (defvar scheme-program-name
"scheme"
28 "*Program invoked by the `run-scheme' command.")
30 (defvar scheme-band-name nil
31 "*Band loaded by the `run-scheme' command.")
33 (defvar scheme-program-arguments nil
34 "*Arguments passed to the Scheme program by the `run-scheme' command.")
36 (defvar xscheme-allow-pipelined-evaluation t
37 "If non-nil, an expression may be transmitted while another is evaluating.
38 Otherwise, attempting to evaluate an expression before the previous expression
39 has finished evaluating will signal an error.")
41 (defvar xscheme-startup-message
42 "This is the Scheme process buffer.
43 Type \\[advertised-xscheme-send-previous-expression] to evaluate the expression before point.
44 Type \\[xscheme-send-control-g-interrupt] to abort evaluation.
45 Type \\[describe-mode] for more information.
48 "String to insert into Scheme process buffer first time it is started.
49 Is processed with `substitute-command-keys' first.")
51 (defvar xscheme-signal-death-message nil
52 "If non-nil, causes a message to be generated when the Scheme process dies.")
54 (defun xscheme-evaluation-commands (keymap)
55 (define-key keymap
"\e\C-x" 'xscheme-send-definition
)
56 (define-key keymap
"\C-x\C-e" 'advertised-xscheme-send-previous-expression
)
57 (define-key keymap
"\eo" 'xscheme-send-buffer
)
58 (define-key keymap
"\ez" 'xscheme-send-definition
)
59 (define-key keymap
"\e\C-m" 'xscheme-send-previous-expression
)
60 (define-key keymap
"\e\C-z" 'xscheme-send-region
))
62 (defun xscheme-interrupt-commands (keymap)
63 (define-key keymap
"\C-c\C-s" 'xscheme-select-process-buffer
)
64 (define-key keymap
"\C-c\C-b" 'xscheme-send-breakpoint-interrupt
)
65 (define-key keymap
"\C-c\C-c" 'xscheme-send-control-g-interrupt
)
66 (define-key keymap
"\C-c\C-u" 'xscheme-send-control-u-interrupt
)
67 (define-key keymap
"\C-c\C-x" 'xscheme-send-control-x-interrupt
))
69 (xscheme-evaluation-commands scheme-mode-map
)
70 (xscheme-interrupt-commands scheme-mode-map
)
73 (defun run-scheme (command-line)
74 "Run an inferior Scheme process.
75 Output goes to the buffer `*scheme*'.
76 With argument, asks for a command line."
79 (or xscheme-process-command-line
80 (xscheme-default-command-line))))
81 (if current-prefix-arg
82 (read-string "Run Scheme: " default
)
84 (setq xscheme-process-command-line command-line
)
85 (switch-to-buffer (xscheme-start-process command-line
)))
87 (defun reset-scheme ()
88 "Reset the Scheme process."
90 (let ((process (get-process "scheme")))
91 (cond ((or (not process
)
92 (not (eq (process-status process
) 'run
))
94 "The Scheme process is running, are you SURE you want to reset it? "))
95 (message "Resetting Scheme process...")
96 (if process
(kill-process process t
))
97 (xscheme-start-process xscheme-process-command-line
)
98 (message "Resetting Scheme process...done")))))
100 (defun xscheme-default-command-line ()
101 (concat scheme-program-name
" -emacs"
102 (if scheme-program-arguments
103 (concat " " scheme-program-arguments
)
106 (concat " -band " scheme-band-name
)
109 ;;;; Interaction Mode
111 (defun scheme-interaction-mode ()
112 "Major mode for interacting with the inferior Scheme process.
113 Like scheme-mode except that:
115 \\[advertised-xscheme-send-previous-expression] sends the expression before point to the Scheme process as input
116 \\[xscheme-yank-previous-send] yanks the expression most recently sent to Scheme
118 All output from the Scheme process is written in the Scheme process
119 buffer, which is initially named \"*scheme*\". The result of
120 evaluating a Scheme expression is also printed in the process buffer,
121 preceded by the string \";Value: \" to highlight it. If the process
122 buffer is not visible at that time, the value will also be displayed
123 in the minibuffer. If an error occurs, the process buffer will
124 automatically pop up to show you the error message.
126 While the Scheme process is running, the modelines of all buffers in
127 scheme-mode are modified to show the state of the process. The
128 possible states and their meanings are:
130 input waiting for input
132 gc garbage collecting
134 The process buffer's modeline contains additional information where
135 the buffer's name is normally displayed: the command interpreter level
138 Scheme maintains a stack of command interpreters. Every time an error
139 or breakpoint occurs, the current command interpreter is pushed on the
140 command interpreter stack, and a new command interpreter is started.
141 One example of why this is done is so that an error that occurs while
142 you are debugging another error will not destroy the state of the
143 initial error, allowing you to return to it after the second error has
146 The command interpreter level indicates how many interpreters are in
147 the command interpreter stack. It is initially set to one, and it is
148 incremented every time that stack is pushed, and decremented every
149 time it is popped. The following commands are useful for manipulating
150 the command interpreter stack:
152 \\[xscheme-send-breakpoint-interrupt] pushes the stack once
153 \\[xscheme-send-control-u-interrupt] pops the stack once
154 \\[xscheme-send-control-g-interrupt] pops everything off
155 \\[xscheme-send-control-x-interrupt] aborts evaluation, doesn't affect stack
157 Some possible command interpreter types and their meanings are:
159 [Evaluator] read-eval-print loop for evaluating expressions
160 [Debugger] single character commands for debugging errors
161 [Where] single character commands for examining environments
163 Starting with release 6.2 of Scheme, the latter two types of command
164 interpreters will change the major mode of the Scheme process buffer
165 to scheme-debugger-mode , in which the evaluation commands are
166 disabled, and the keys which normally self insert instead send
167 themselves to the Scheme process. The command character ? will list
168 the available commands.
170 For older releases of Scheme, the major mode will be be
171 scheme-interaction-mode , and the command characters must be sent as
172 if they were expressions.
175 Delete converts tabs to spaces as it moves back.
176 Blank lines separate paragraphs. Semicolons start comments.
177 \\{scheme-interaction-mode-map}
179 Entry to this mode calls the value of scheme-interaction-mode-hook
180 with no args, if that value is non-nil.
181 Likewise with the value of scheme-mode-hook.
182 scheme-interaction-mode-hook is called after scheme-mode-hook."
184 (kill-all-local-variables)
185 (scheme-interaction-mode-initialize)
186 (scheme-mode-variables)
187 (make-local-variable 'xscheme-previous-send
)
188 (run-hooks 'scheme-mode-hook
'scheme-interaction-mode-hook
))
190 (defun scheme-interaction-mode-initialize ()
191 (use-local-map scheme-interaction-mode-map
)
192 (setq major-mode
'scheme-interaction-mode
)
193 (setq mode-name
"Scheme Interaction"))
195 (defun scheme-interaction-mode-commands (keymap)
196 (define-key keymap
"\C-c\C-m" 'xscheme-send-current-line
)
197 (define-key keymap
"\C-c\C-p" 'xscheme-send-proceed
)
198 (define-key keymap
"\C-c\C-y" 'xscheme-yank-previous-send
))
200 (defvar scheme-interaction-mode-map nil
)
201 (if (not scheme-interaction-mode-map
)
203 (setq scheme-interaction-mode-map
(make-keymap))
204 (scheme-mode-commands scheme-interaction-mode-map
)
205 (xscheme-interrupt-commands scheme-interaction-mode-map
)
206 (xscheme-evaluation-commands scheme-interaction-mode-map
)
207 (scheme-interaction-mode-commands scheme-interaction-mode-map
)))
209 (defun xscheme-enter-interaction-mode ()
211 (set-buffer (xscheme-process-buffer))
212 (if (not (eq major-mode
'scheme-interaction-mode
))
213 (if (eq major-mode
'scheme-debugger-mode
)
214 (scheme-interaction-mode-initialize)
215 (scheme-interaction-mode)))))
217 (fset 'advertised-xscheme-send-previous-expression
218 'xscheme-send-previous-expression
)
222 (defun scheme-debugger-mode ()
223 "Major mode for executing the Scheme debugger.
224 Like scheme-mode except that the evaluation commands
225 are disabled, and characters that would normally be self inserting are
226 sent to the Scheme process instead. Typing ? will show you which
227 characters perform useful functions.
230 \\{scheme-debugger-mode-map}"
231 (error "Illegal entry to scheme-debugger-mode"))
233 (defun scheme-debugger-mode-initialize ()
234 (use-local-map scheme-debugger-mode-map
)
235 (setq major-mode
'scheme-debugger-mode
)
236 (setq mode-name
"Scheme Debugger"))
238 (defun scheme-debugger-mode-commands (keymap)
241 (define-key keymap
(char-to-string char
) 'scheme-debugger-self-insert
)
242 (setq char
(1+ char
)))))
244 (defvar scheme-debugger-mode-map nil
)
245 (if (not scheme-debugger-mode-map
)
247 (setq scheme-debugger-mode-map
(make-keymap))
248 (scheme-mode-commands scheme-debugger-mode-map
)
249 (xscheme-interrupt-commands scheme-debugger-mode-map
)
250 (scheme-debugger-mode-commands scheme-debugger-mode-map
)))
252 (defun scheme-debugger-self-insert ()
253 "Transmit this character to the Scheme process."
255 (xscheme-send-char last-command-char
))
257 (defun xscheme-enter-debugger-mode (prompt-string)
259 (set-buffer (xscheme-process-buffer))
260 (if (not (eq major-mode
'scheme-debugger-mode
))
262 (if (not (eq major-mode
'scheme-interaction-mode
))
263 (scheme-interaction-mode))
264 (scheme-debugger-mode-initialize)))))
266 (defun xscheme-debugger-mode-p ()
267 (let ((buffer (xscheme-process-buffer)))
271 (eq major-mode
'scheme-debugger-mode
)))))
273 ;;;; Evaluation Commands
275 (defun xscheme-send-string (&rest strings
)
276 "Send the string arguments to the Scheme process.
277 The strings are concatenated and terminated by a newline."
278 (cond ((not (xscheme-process-running-p))
279 (if (yes-or-no-p "The Scheme process has died. Reset it? ")
282 (xscheme-wait-for-process)
283 (goto-char (point-max))
284 (apply 'insert-before-markers strings
)
285 (xscheme-send-string-1 strings
))))
286 ((xscheme-debugger-mode-p) (error "No sends allowed in debugger mode"))
287 ((and (not xscheme-allow-pipelined-evaluation
)
289 (error "No sends allowed while Scheme running"))
290 (t (xscheme-send-string-1 strings
))))
292 (defun xscheme-send-string-1 (strings)
293 (let ((string (apply 'concat strings
)))
294 (xscheme-send-string-2 string
)
295 (if (eq major-mode
'scheme-interaction-mode
)
296 (setq xscheme-previous-send string
))))
298 (defun xscheme-send-string-2 (string)
299 (let ((process (get-process "scheme")))
300 (send-string process
(concat string
"\n"))
301 (if (xscheme-process-buffer-current-p)
302 (set-marker (process-mark process
) (point)))))
304 (defun xscheme-yank-previous-send ()
305 "Insert the most recent expression at point."
308 (insert xscheme-previous-send
))
310 (defun xscheme-select-process-buffer ()
311 "Select the Scheme process buffer and move to its output point."
313 (let ((process (or (get-process "scheme") (error "No scheme process"))))
314 (let ((buffer (or (process-buffer process
) (error "No process buffer"))))
315 (let ((window (get-buffer-window buffer
)))
317 (select-window window
)
318 (switch-to-buffer buffer
))
319 (goto-char (process-mark process
))))))
321 (defun xscheme-send-region (start end
)
322 "Send the current region to the Scheme process.
323 The region is sent terminated by a newline."
325 (if (xscheme-process-buffer-current-p)
326 (progn (goto-char end
)
327 (set-marker (process-mark (get-process "scheme")) end
)))
328 (xscheme-send-string (buffer-substring start end
)))
330 (defun xscheme-send-definition ()
331 "Send the current definition to the Scheme process.
332 If the current line begins with a non-whitespace character,
333 parse an expression from the beginning of the line and send that instead."
335 (let ((start nil
) (end nil
))
339 (if (re-search-backward "^\\s(" nil t
)
341 (error "Can't find definition")))
342 (xscheme-send-region start end
)))
344 (defun xscheme-send-next-expression ()
345 "Send the expression to the right of `point' to the Scheme process."
347 (let ((start (point)))
348 (xscheme-send-region start
(save-excursion (forward-sexp) (point)))))
350 (defun xscheme-send-previous-expression ()
351 "Send the expression to the left of `point' to the Scheme process."
354 (xscheme-send-region (save-excursion (backward-sexp) (point)) end
)))
356 (defun xscheme-send-current-line ()
357 "Send the current line to the Scheme process.
358 Useful for working with debugging Scheme under adb."
363 (let ((start (point)))
365 (buffer-substring start
(point))))))
368 (xscheme-send-string-2 line
)))
370 (defun xscheme-send-buffer ()
371 "Send the current buffer to the Scheme process."
373 (if (xscheme-process-buffer-current-p)
374 (error "Not allowed to send this buffer's contents to Scheme"))
375 (xscheme-send-region (point-min) (point-max)))
377 (defun xscheme-send-char (char)
378 "Prompt for a character and send it to the Scheme process."
379 (interactive "cCharacter to send: ")
380 (send-string "scheme" (char-to-string char
)))
384 (defun xscheme-send-breakpoint-interrupt ()
385 "Cause the Scheme process to enter a breakpoint."
387 (xscheme-send-interrupt ?b nil
))
389 (defun xscheme-send-proceed ()
390 "Cause the Scheme process to proceed from a breakpoint."
392 (send-string "scheme" "(proceed)\n"))
394 (defun xscheme-send-control-g-interrupt ()
395 "Cause the Scheme processor to halt and flush input.
396 Control returns to the top level rep loop."
398 (let ((inhibit-quit t
))
399 (cond ((not xscheme-control-g-synchronization-p
)
400 (interrupt-process "scheme"))
401 (xscheme-control-g-disabled-p
402 (message "Relax..."))
404 (setq xscheme-control-g-disabled-p t
)
405 (message "Sending C-G interrupt to Scheme...")
406 (interrupt-process "scheme")
407 (send-string "scheme" (char-to-string 0))))))
409 (defun xscheme-send-control-u-interrupt ()
410 "Cause the Scheme process to halt, returning to previous rep loop."
412 (xscheme-send-interrupt ?u t
))
414 (defun xscheme-send-control-x-interrupt ()
415 "Cause the Scheme process to halt, returning to current rep loop."
417 (xscheme-send-interrupt ?x t
))
419 ;;; This doesn't really work right -- Scheme just gobbles the first
420 ;;; character in the input. There is no way for us to guarantee that
421 ;;; the argument to this procedure is the first char unless we put
422 ;;; some kind of marker in the input stream.
424 (defun xscheme-send-interrupt (char mark-p
)
425 "Send a ^A type interrupt to the Scheme process."
426 (interactive "cInterrupt character to send: ")
427 (quit-process "scheme")
428 (send-string "scheme" (char-to-string char
))
429 (if (and mark-p xscheme-control-g-synchronization-p
)
430 (send-string "scheme" (char-to-string 0))))
432 ;;;; Internal Variables
434 (defvar xscheme-process-command-line nil
435 "Command used to start the most recent Scheme process.")
437 (defvar xscheme-previous-send
""
438 "Most recent expression transmitted to the Scheme process.")
440 (defvar xscheme-process-filter-state
'idle
441 "State of scheme process escape reader state machine:
442 idle waiting for an escape sequence
443 reading-type received an altmode but nothing else
444 reading-string reading prompt string")
446 (defvar xscheme-running-p nil
447 "This variable, if nil, indicates that the scheme process is
448 waiting for input. Otherwise, it is busy evaluating something.")
450 (defconst xscheme-control-g-synchronization-p t
451 "If non-nil, insert markers in the scheme input stream to indicate when
452 control-g interrupts were signalled. Do not allow more control-g's to be
453 signalled until the scheme process acknowledges receipt.")
455 (defvar xscheme-control-g-disabled-p nil
456 "This variable, if non-nil, indicates that a control-g is being processed
457 by the scheme process, so additional control-g's are to be ignored.")
459 (defvar xscheme-allow-output-p t
460 "This variable, if nil, prevents output from the scheme process
461 from being inserted into the process-buffer.")
463 (defvar xscheme-prompt
""
464 "The current scheme prompt string.")
466 (defvar xscheme-string-accumulator
""
467 "Accumulator for the string being received from the scheme process.")
469 (defvar xscheme-string-receiver nil
470 "Procedure to send the string argument from the scheme process.")
472 (defvar xscheme-start-hook nil
473 "If non-nil, a procedure to call when the Scheme process is started.
474 When called, the current buffer will be the Scheme process-buffer.")
476 (defvar xscheme-runlight-string nil
)
477 (defvar xscheme-mode-string nil
)
478 (defvar xscheme-filter-input nil
)
480 ;;;; Basic Process Control
482 (defun xscheme-start-process (command-line)
483 (let ((buffer (get-buffer-create "*scheme*")))
484 (let ((process (get-buffer-process buffer
)))
487 (if (and process
(memq (process-status process
) '(run stop
)))
488 (set-marker (process-mark process
) (point-max))
489 (progn (if process
(delete-process process
))
490 (goto-char (point-max))
491 (scheme-interaction-mode)
493 (insert-before-markers
494 (substitute-command-keys xscheme-startup-message
)))
496 (let ((process-connection-type nil
))
497 (apply 'start-process
500 (xscheme-parse-command-line
502 (set-marker (process-mark process
) (point-max))
503 (xscheme-process-filter-initialize t
)
504 (xscheme-modeline-initialize)
505 (set-process-sentinel process
'xscheme-process-sentinel
)
506 (set-process-filter process
'xscheme-process-filter
)
507 (run-hooks 'xscheme-start-hook
)))))
510 (defun xscheme-parse-command-line (string)
511 (setq string
(substitute-in-file-name string
))
515 (let ((index (string-match "[ \t]" string start
)))
519 (cons (substring string start
)
523 (string-match "[^ \t]" string start
))
526 (cons (substring string start index
)
531 (defun xscheme-wait-for-process ()
533 (while xscheme-running-p
536 (defun xscheme-process-running-p ()
537 "True iff there is a Scheme process whose status is `run'."
538 (let ((process (get-process "scheme")))
540 (eq (process-status process
) 'run
))))
542 (defun xscheme-process-buffer ()
543 (let ((process (get-process "scheme")))
544 (and process
(process-buffer process
))))
546 (defun xscheme-process-buffer-window ()
547 (let ((buffer (xscheme-process-buffer)))
548 (and buffer
(get-buffer-window buffer
))))
550 (defun xscheme-process-buffer-current-p ()
551 "True iff the current buffer is the Scheme process buffer."
552 (eq (xscheme-process-buffer) (current-buffer)))
556 (defun xscheme-process-sentinel (proc reason
)
557 (xscheme-process-filter-initialize (eq reason
'run
))
559 (xscheme-modeline-initialize)
561 (setq scheme-mode-line-process
"")
562 (setq xscheme-mode-string
"no process")))
563 (if (and (not (memq reason
'(run stop
)))
564 xscheme-signal-death-message
)
567 "The Scheme process has died! Do M-x reset-scheme to restart it"))))
569 (defun xscheme-process-filter-initialize (running-p)
570 (setq xscheme-process-filter-state
'idle
)
571 (setq xscheme-running-p running-p
)
572 (setq xscheme-control-g-disabled-p nil
)
573 (setq xscheme-allow-output-p t
)
574 (setq xscheme-prompt
"")
575 (setq scheme-mode-line-process
'(": " xscheme-runlight-string
)))
577 (defun xscheme-process-filter (proc string
)
578 (let ((xscheme-filter-input string
))
579 (while xscheme-filter-input
580 (cond ((eq xscheme-process-filter-state
'idle
)
581 (let ((start (string-match "\e" xscheme-filter-input
)))
584 (xscheme-process-filter-output
585 (substring xscheme-filter-input
0 start
))
586 (setq xscheme-filter-input
587 (substring xscheme-filter-input
(1+ start
)))
588 (setq xscheme-process-filter-state
'reading-type
))
589 (let ((string xscheme-filter-input
))
590 (setq xscheme-filter-input nil
)
591 (xscheme-process-filter-output string
)))))
592 ((eq xscheme-process-filter-state
'reading-type
)
593 (if (zerop (length xscheme-filter-input
))
594 (setq xscheme-filter-input nil
)
595 (let ((char (aref xscheme-filter-input
0)))
596 (setq xscheme-filter-input
597 (substring xscheme-filter-input
1))
598 (let ((entry (assoc char xscheme-process-filter-alist
)))
600 (funcall (nth 2 entry
) (nth 1 entry
))
602 (xscheme-process-filter-output ?\e char
)
603 (setq xscheme-process-filter-state
'idle
)))))))
604 ((eq xscheme-process-filter-state
'reading-string
)
605 (let ((start (string-match "\e" xscheme-filter-input
)))
608 (concat xscheme-string-accumulator
609 (substring xscheme-filter-input
0 start
))))
610 (setq xscheme-filter-input
611 (substring xscheme-filter-input
(1+ start
)))
612 (setq xscheme-process-filter-state
'idle
)
613 (funcall xscheme-string-receiver string
))
615 (setq xscheme-string-accumulator
616 (concat xscheme-string-accumulator
617 xscheme-filter-input
))
618 (setq xscheme-filter-input nil
)))))
620 (error "Scheme process filter -- bad state"))))))
622 ;;;; Process Filter Output
624 (defun xscheme-process-filter-output (&rest args
)
625 (if xscheme-allow-output-p
626 (let ((string (apply 'concat args
)))
628 (xscheme-goto-output-point)
629 (while (string-match "\\(\007\\|\f\\)" string
)
630 (let ((start (match-beginning 0))
632 (insert-before-markers (substring string
0 start
))
633 (if (= ?
\f (aref string start
))
636 (insert-before-markers ?
\n))
637 (insert-before-markers ?
\f))
639 (setq string
(substring string
(1+ start
)))))
640 (insert-before-markers string
)))))
642 (defun xscheme-guarantee-newlines (n)
643 (if xscheme-allow-output-p
645 (xscheme-goto-output-point)
647 (while (and (not stop
)
653 (xscheme-goto-output-point)
655 (insert-before-markers ?
\n)
658 (defun xscheme-goto-output-point ()
659 (let ((process (get-process "scheme")))
660 (set-buffer (process-buffer process
))
661 (goto-char (process-mark process
))))
663 (defun xscheme-modeline-initialize ()
664 (setq xscheme-runlight-string
"")
665 (setq xscheme-mode-string
"")
666 (setq mode-line-buffer-identification
'("Scheme: " xscheme-mode-string
)))
668 (defun xscheme-set-runlight (runlight)
669 (setq xscheme-runlight-string runlight
)
670 (xscheme-modeline-redisplay))
672 (defun xscheme-modeline-redisplay ()
673 (save-excursion (set-buffer (other-buffer)))
674 (set-buffer-modified-p (buffer-modified-p))
677 ;;;; Process Filter Operations
679 (defvar xscheme-process-filter-alist
680 '((?D xscheme-enter-debugger-mode
681 xscheme-process-filter
:string-action
)
683 xscheme-process-filter
:string-action
)
684 (?P xscheme-set-prompt-variable
685 xscheme-process-filter
:string-action
)
686 (?R xscheme-enter-interaction-mode
687 xscheme-process-filter
:simple-action
)
689 xscheme-process-filter
:simple-action
)
690 (?e xscheme-finish-gc
691 xscheme-process-filter
:simple-action
)
692 (?f xscheme-exit-input-wait
693 xscheme-process-filter
:simple-action
)
694 (?g xscheme-enable-control-g
695 xscheme-process-filter
:simple-action
)
696 (?i xscheme-prompt-for-expression
697 xscheme-process-filter
:string-action
)
699 xscheme-process-filter
:string-action
)
700 (?n xscheme-prompt-for-confirmation
701 xscheme-process-filter
:string-action
)
702 (?o xscheme-output-goto
703 xscheme-process-filter
:simple-action
)
704 (?p xscheme-set-prompt
705 xscheme-process-filter
:string-action
)
706 (?s xscheme-enter-input-wait
707 xscheme-process-filter
:simple-action
)
708 (?v xscheme-write-value
709 xscheme-process-filter
:string-action
)
711 xscheme-process-filter
:string-action
)
712 (?z xscheme-display-process-buffer
713 xscheme-process-filter
:simple-action
)
714 (?c xscheme-unsolicited-read-char
715 xscheme-process-filter
:simple-action
))
716 "Table used to decide how to handle process filter commands.
717 Value is a list of entries, each entry is a list of three items.
719 The first item is the character that the process filter dispatches on.
720 The second item is the action to be taken, a function.
721 The third item is the handler for the entry, a function.
723 When the process filter sees a command whose character matches a
724 particular entry, it calls the handler with two arguments: the action
725 and the string containing the rest of the process filter's input
726 stream. It is the responsibility of the handler to invoke the action
727 with the appropriate arguments, and to reenter the process filter with
728 the remaining input.")
730 (defun xscheme-process-filter:simple-action
(action)
731 (setq xscheme-process-filter-state
'idle
)
734 (defun xscheme-process-filter:string-action
(action)
735 (setq xscheme-string-receiver action
)
736 (setq xscheme-string-accumulator
"")
737 (setq xscheme-process-filter-state
'reading-string
))
739 (defconst xscheme-runlight
:running
"run"
740 "The character displayed when the Scheme process is running.")
742 (defconst xscheme-runlight
:input
"input"
743 "The character displayed when the Scheme process is waiting for input.")
745 (defconst xscheme-runlight
:gc
"gc"
746 "The character displayed when the Scheme process is garbage collecting.")
748 (defun xscheme-start-gc ()
749 (xscheme-set-runlight xscheme-runlight
:gc
))
751 (defun xscheme-finish-gc ()
752 (xscheme-set-runlight
753 (if xscheme-running-p xscheme-runlight
:running xscheme-runlight
:input
)))
755 (defun xscheme-enter-input-wait ()
756 (xscheme-set-runlight xscheme-runlight
:input
)
757 (setq xscheme-running-p nil
))
759 (defun xscheme-exit-input-wait ()
760 (xscheme-set-runlight xscheme-runlight
:running
)
761 (setq xscheme-running-p t
))
763 (defun xscheme-enable-control-g ()
764 (setq xscheme-control-g-disabled-p nil
))
766 (defun xscheme-display-process-buffer ()
767 (let ((window (or (xscheme-process-buffer-window)
768 (display-buffer (xscheme-process-buffer)))))
769 (save-window-excursion
770 (select-window window
)
771 (xscheme-goto-output-point)
772 (if (xscheme-debugger-mode-p)
773 (xscheme-enter-interaction-mode)))))
775 (defun xscheme-unsolicited-read-char ()
778 (defun xscheme-eval (string)
779 (eval (car (read-from-string string
))))
781 (defun xscheme-message (string)
782 (if (not (zerop (length string
)))
783 (xscheme-write-message-1 string
(format ";%s" string
))))
785 (defun xscheme-write-value (string)
786 (if (zerop (length string
))
787 (xscheme-write-message-1 "(no value)" ";No value")
788 (xscheme-write-message-1 string
(format ";Value: %s" string
))))
790 (defun xscheme-write-message-1 (message-string output-string
)
791 (let* ((process (get-process "scheme"))
792 (window (get-buffer-window (process-buffer process
))))
794 (not (pos-visible-in-window-p (process-mark process
)
796 (message "%s" message-string
)))
797 (xscheme-guarantee-newlines 1)
798 (xscheme-process-filter-output output-string
))
800 (defun xscheme-set-prompt-variable (string)
801 (setq xscheme-prompt string
))
803 (defun xscheme-set-prompt (string)
804 (setq xscheme-prompt string
)
805 (xscheme-guarantee-newlines 2)
806 (setq xscheme-mode-string
(xscheme-coerce-prompt string
))
807 (xscheme-modeline-redisplay))
809 (defun xscheme-output-goto ()
810 (xscheme-goto-output-point)
811 (xscheme-guarantee-newlines 2))
813 (defun xscheme-coerce-prompt (string)
814 (if (string-match "^[0-9]+ " string
)
815 (let ((end (match-end 0)))
816 (concat (substring string
0 end
)
817 (let ((prompt (substring string end
)))
818 (let ((entry (assoc prompt xscheme-prompt-alist
)))
824 (defvar xscheme-prompt-alist
825 '(("[Normal REPL]" .
"[Evaluator]")
826 ("[Error REPL]" .
"[Evaluator]")
827 ("[Breakpoint REPL]" .
"[Evaluator]")
828 ("[Debugger REPL]" .
"[Evaluator]")
829 ("[Visiting environment]" .
"[Evaluator]")
830 ("[Environment Inspector]" .
"[Where]"))
831 "An alist which maps the Scheme command interpreter type to a print string.")
833 (defun xscheme-cd (directory-string)
835 (set-buffer (xscheme-process-buffer))
836 (cd directory-string
)))
838 (defun xscheme-prompt-for-confirmation (prompt-string)
839 (xscheme-send-char (if (y-or-n-p prompt-string
) ?y ?n
)))
841 (defun xscheme-prompt-for-expression (prompt-string)
842 (xscheme-send-string-2
843 (read-from-minibuffer prompt-string nil xscheme-prompt-for-expression-map
)))
845 (defvar xscheme-prompt-for-expression-map nil
)
846 (if (not xscheme-prompt-for-expression-map
)
848 (setq xscheme-prompt-for-expression-map
849 (copy-keymap minibuffer-local-map
))
850 (substitute-key-definition 'exit-minibuffer
851 'xscheme-prompt-for-expression-exit
852 xscheme-prompt-for-expression-map
)))
854 (defun xscheme-prompt-for-expression-exit ()
856 (if (eq (xscheme-region-expression-p (point-min) (point-max)) 'one
)
858 (error "input must be a single, complete expression")))
860 (defun xscheme-region-expression-p (start end
)
862 (let ((old-syntax-table (syntax-table)))
865 (set-syntax-table scheme-mode-syntax-table
)
866 (let ((state (parse-partial-sexp start end
)))
867 (and (zerop (car state
)) ;depth = 0
868 (nth 2 state
) ;last-sexp exists, i.e. >= 1 sexps
869 (let ((state (parse-partial-sexp start
(nth 2 state
))))
870 (if (nth 2 state
) 'many
'one
)))))
871 (set-syntax-table old-syntax-table
)))))