1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
|
;;; Read-Eval-Print Loop
;; Copyright (C) 2001, 2009, 2010, 2011 Free Software Foundation, Inc.
;; This library is free software; you can redistribute it and/or
;; modify it under the terms of the GNU Lesser General Public
;; License as published by the Free Software Foundation; either
;; version 3 of the License, or (at your option) any later version.
;;
;; This library is distributed in the hope that it will be useful,
;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
;; Lesser General Public License for more details.
;;
;; You should have received a copy of the GNU Lesser General Public
;; License along with this library; if not, write to the Free Software
;; Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
;; 02110-1301 USA
;;; Code:
(define-module (system repl repl)
#:use-module (system base syntax)
#:use-module (system base pmatch)
#:use-module (system base compile)
#:use-module (system base language)
#:use-module (system vm vm)
#:use-module (system repl error-handling)
#:use-module (system repl common)
#:use-module (system repl command)
#:use-module (ice-9 control)
#:export (start-repl run-repl))
;;;
;;; Comments
;;;
;;; (You don't want a comment to force a continuation line.)
;;;
(define (read-scheme-line-comment port)
(let lp ()
(let ((ch (read-char port)))
(or (eof-object? ch)
(eqv? ch #\newline)
(lp)))))
(define (read-scheme-datum-comment port)
(read port))
;; ch is a peeked char
(define (read-comment lang port ch)
(and (eq? (language-name lang) 'scheme)
(case ch
((#\;)
(read-char port)
(read-scheme-line-comment port)
#t)
((#\#)
(read-char port)
(case (peek-char port)
((#\;)
(read-char port)
(read-scheme-datum-comment port)
#t)
;; Not doing R6RS block comments because of the possibility
;; of read-hash extensions. Lame excuse. Not doing scsh
;; block comments either, because I don't feel like handling
;; #!r6rs.
(else
(unread-char #\# port)
#f)))
(else
#f))))
;;;
;;; Meta commands
;;;
(define meta-command-token (cons 'meta 'command))
(define (meta-reader lang env)
(lambda* (#:optional (port (current-input-port)))
(with-input-from-port port
(lambda ()
(let ((ch (flush-leading-whitespace)))
(cond ((eof-object? ch)
;; EOF objects are not buffered. It's quite possible
;; to peek an EOF then read something else. It's
;; strange but it's how it works.
ch)
((eqv? ch #\,)
(read-char port)
meta-command-token)
((read-comment lang port ch)
*unspecified*)
(else ((language-reader lang) port env))))))))
(define (flush-all-input)
(if (and (char-ready?)
(not (eof-object? (peek-char))))
(begin
(read-char)
(flush-all-input))))
;; repl-reader is a function defined in boot-9.scm, and is replaced by
;; something else if readline has been activated. much of this hoopla is
;; to be able to re-use the existing readline machinery.
;;
;; Catches read errors, returning *unspecified* in that case.
(define (prompting-meta-read repl)
(catch #t
(lambda ()
(repl-reader (lambda () (repl-prompt repl))
(meta-reader (repl-language repl) (current-module))))
(lambda (key . args)
(case key
((quit)
(apply throw key args))
(else
(format (current-output-port) "While reading expression:\n")
(print-exception (current-output-port) #f key args)
(flush-all-input)
*unspecified*)))))
;;;
;;; The repl
;;;
(define* (start-repl #:optional (lang (current-language)) #:key debug)
;; ,language at the REPL will fluid-set! the *current-language*. Make
;; sure that it does so in a new scope.
(with-fluids ((*current-language* lang))
(run-repl (make-repl lang debug))))
;; (put 'abort-on-error 'scheme-indent-function 1)
(define-syntax-rule (abort-on-error string exp)
(catch #t
(lambda () exp)
(lambda (key . args)
(format #t "While ~A:~%" string)
(print-exception (current-output-port) #f key args)
(abort))))
(define (run-repl repl)
(define (with-stack-and-prompt thunk)
(call-with-prompt (default-prompt-tag)
(lambda () (start-stack #t (thunk)))
(lambda (k proc)
(with-stack-and-prompt (lambda () (proc k))))))
(% (with-fluids ((*repl-stack*
(cons repl (or (fluid-ref *repl-stack*) '()))))
(if (null? (cdr (fluid-ref *repl-stack*)))
(repl-welcome repl))
(let prompt-loop ()
(let ((exp (prompting-meta-read repl)))
(cond
((eqv? exp *unspecified*)) ; read error or comment, pass
((eq? exp meta-command-token)
(catch #t
(lambda ()
(meta-command repl))
(lambda (k . args)
(if (eq? k 'quit)
(abort args)
(begin
(format #t "While executing meta-command:~%")
(print-exception (current-output-port) #f k args))))))
((eof-object? exp)
(newline)
(abort '()))
(else
;; since the input port is line-buffered, consume up to the
;; newline
(flush-to-newline)
(call-with-error-handling
(lambda ()
(catch 'quit
(lambda ()
(call-with-values
(lambda ()
(% (let ((thunk
(abort-on-error "compiling expression"
(repl-prepare-eval-thunk
repl
(abort-on-error "parsing expression"
(repl-parse repl exp))))))
(run-hook before-eval-hook exp)
(call-with-error-handling
(lambda ()
(with-stack-and-prompt thunk))
#:on-error (repl-option-ref repl 'on-error)))
(lambda (k) (values))))
(lambda l
(for-each (lambda (v)
(repl-print repl v))
l))))
(lambda (k . args)
(abort args))))
#:on-error (repl-option-ref repl 'on-error)
#:trap-handler 'disabled)))
(flush-to-newline) ;; consume trailing whitespace
(prompt-loop))))
(lambda (k status)
status)))
;; Returns first non-whitespace char.
(define (flush-leading-whitespace)
(let ((ch (peek-char)))
(cond ((eof-object? ch) ch)
((char-whitespace? ch) (read-char) (flush-leading-whitespace))
(else ch))))
(define (flush-to-newline)
(if (char-ready?)
(let ((ch (peek-char)))
(if (and (not (eof-object? ch)) (char-whitespace? ch))
(begin
(read-char)
(if (not (char=? ch #\newline))
(flush-to-newline)))))))
|
