heist 0.1.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- data/History.txt +21 -0
- data/Manifest.txt +53 -0
- data/README.txt +274 -0
- data/Rakefile +12 -0
- data/bin/heist +16 -0
- data/lib/bin_spec.rb +25 -0
- data/lib/builtin/library.scm +95 -0
- data/lib/builtin/primitives.rb +306 -0
- data/lib/builtin/syntax.rb +166 -0
- data/lib/builtin/syntax.scm +155 -0
- data/lib/heist.rb +47 -0
- data/lib/parser/nodes.rb +105 -0
- data/lib/parser/scheme.rb +1081 -0
- data/lib/parser/scheme.tt +80 -0
- data/lib/repl.rb +112 -0
- data/lib/runtime/binding.rb +31 -0
- data/lib/runtime/callable/continuation.rb +24 -0
- data/lib/runtime/callable/function.rb +55 -0
- data/lib/runtime/callable/macro.rb +170 -0
- data/lib/runtime/callable/macro/expansion.rb +15 -0
- data/lib/runtime/callable/macro/matches.rb +77 -0
- data/lib/runtime/callable/macro/splice.rb +56 -0
- data/lib/runtime/data/expression.rb +23 -0
- data/lib/runtime/data/identifier.rb +20 -0
- data/lib/runtime/data/list.rb +36 -0
- data/lib/runtime/frame.rb +118 -0
- data/lib/runtime/runtime.rb +61 -0
- data/lib/runtime/scope.rb +121 -0
- data/lib/runtime/stack.rb +60 -0
- data/lib/runtime/stackless.rb +49 -0
- data/lib/stdlib/benchmark.scm +12 -0
- data/lib/stdlib/birdhouse.scm +82 -0
- data/test/arithmetic.scm +57 -0
- data/test/benchmarks.scm +27 -0
- data/test/booleans.scm +6 -0
- data/test/closures.scm +16 -0
- data/test/conditionals.scm +55 -0
- data/test/continuations.scm +144 -0
- data/test/define_functions.scm +27 -0
- data/test/define_values.scm +28 -0
- data/test/delay.scm +8 -0
- data/test/file_loading.scm +9 -0
- data/test/hygienic.scm +39 -0
- data/test/let.scm +42 -0
- data/test/lib.scm +2 -0
- data/test/macro-helpers.scm +19 -0
- data/test/macros.scm +343 -0
- data/test/numbers.scm +19 -0
- data/test/plt-macros.txt +40 -0
- data/test/test_heist.rb +84 -0
- data/test/unhygienic.scm +11 -0
- data/test/vars.scm +2 -0
- metadata +138 -0
@@ -0,0 +1,155 @@
|
|
1
|
+
; Control structures
|
2
|
+
|
3
|
+
; (cond) goes through a list of tests, evaluating each one
|
4
|
+
; in order of appearance. Once a matching precondition is
|
5
|
+
; found, its consequent is tail-called and no further
|
6
|
+
; preconditions are evaluated.
|
7
|
+
(define-syntax cond (syntax-rules (else =>)
|
8
|
+
[(cond) #f]
|
9
|
+
[(cond (else expr1 expr2 ...))
|
10
|
+
(begin expr1 expr2 ...)]
|
11
|
+
[(cond (test => function) clause ...)
|
12
|
+
(let ([temp test])
|
13
|
+
(if temp
|
14
|
+
(function temp)
|
15
|
+
(cond clause ...)))]
|
16
|
+
[(cond (test expression ...) clause ...)
|
17
|
+
(if test
|
18
|
+
(begin expression ...)
|
19
|
+
(cond clause ...))]))
|
20
|
+
|
21
|
+
; (case) acts like Ruby's case statement. The value of the
|
22
|
+
; given expression is compared against a series of lists;
|
23
|
+
; once a list is found to include the value, the expressions
|
24
|
+
; following the list are evaluated and no further lists
|
25
|
+
; are tested.
|
26
|
+
(define-syntax case (syntax-rules (else)
|
27
|
+
[(case key) #f]
|
28
|
+
[(case key (else expr1 expr2 ...))
|
29
|
+
(begin expr1 expr2 ...)]
|
30
|
+
[(case key (() expr ...) clause ...)
|
31
|
+
(case key clause ...)]
|
32
|
+
[(case key
|
33
|
+
((datum1 datum2 ...) expr1 expr2 ...)
|
34
|
+
clause ...)
|
35
|
+
(let ([temp key])
|
36
|
+
(if (eqv? temp 'datum1)
|
37
|
+
(begin expr1 expr2 ...)
|
38
|
+
(case temp
|
39
|
+
((datum2 ...) expr1 expr2 ...)
|
40
|
+
clause ...)))]))
|
41
|
+
|
42
|
+
;----------------------------------------------------------------
|
43
|
+
|
44
|
+
; Binding constructs
|
45
|
+
|
46
|
+
; (let), (let*) and (letrec) each create a new scope and bind
|
47
|
+
; values to some symbols before executing a series of lists.
|
48
|
+
; They differ according to how they evaluate the bound values.
|
49
|
+
|
50
|
+
; (let) evaluates values in the enclosing scope, so lambdas will
|
51
|
+
; not be able to refer to other values assigned using the (let).
|
52
|
+
(define-syntax let (syntax-rules ()
|
53
|
+
[(let ([variable init] ...) body ...)
|
54
|
+
((lambda (variable ...)
|
55
|
+
body ...)
|
56
|
+
init ...)]
|
57
|
+
[(let name ([variable init] ...) body ...)
|
58
|
+
(letrec ([name (lambda (variable ...)
|
59
|
+
body ...)])
|
60
|
+
(name init ...))]))
|
61
|
+
|
62
|
+
; (let*) creates a new scope for each variable and evaluates
|
63
|
+
; each expression in its enclosing scope. Basically a shorthand
|
64
|
+
; for several nested (let)s. Variables may refer to those that
|
65
|
+
; preceed them but not vice versa.
|
66
|
+
(define-syntax let* (syntax-rules ()
|
67
|
+
[(let* ([name expression]) body ...)
|
68
|
+
(let ([name expression]) body ...)]
|
69
|
+
[(let* ([n1 e1] [n2 e2] ...) body ...)
|
70
|
+
(let ([n1 e1])
|
71
|
+
(let* ([n2 e2] ...) body ...))]))
|
72
|
+
|
73
|
+
; (letrec) evaluates values in the inner scope, so lambdas are
|
74
|
+
; able to refer to other values assigned using the (letrec).
|
75
|
+
(define-syntax letrec (syntax-rules ()
|
76
|
+
[(letrec ([variable init] ...) body ...)
|
77
|
+
((lambda ()
|
78
|
+
(define variable init) ...
|
79
|
+
body ...))]))
|
80
|
+
|
81
|
+
(define let-syntax let)
|
82
|
+
(define letrec-syntax letrec)
|
83
|
+
|
84
|
+
;----------------------------------------------------------------
|
85
|
+
|
86
|
+
; Iteration
|
87
|
+
|
88
|
+
; (do) is similar to the 'while' construct in procedural
|
89
|
+
; languages. It assigns initial values to a set of variables,
|
90
|
+
; then performs the list of given commands in a loop. If
|
91
|
+
; before any iteration the test is found to be false, the
|
92
|
+
; loop is halted and the value of the expression following
|
93
|
+
; the test is returned.
|
94
|
+
(define-syntax do (syntax-rules ()
|
95
|
+
[(do ([variable init step ...] ...) ; Allow 0 or 1 step
|
96
|
+
(test expression ...)
|
97
|
+
command ...)
|
98
|
+
(let loop ([variable init] ...)
|
99
|
+
(if test
|
100
|
+
(begin expression ...)
|
101
|
+
(begin
|
102
|
+
command ...
|
103
|
+
(loop (do "step" variable step ...) ...))))]
|
104
|
+
[(do "step" variable)
|
105
|
+
variable]
|
106
|
+
[(do "step" variable step)
|
107
|
+
step]))
|
108
|
+
|
109
|
+
;----------------------------------------------------------------
|
110
|
+
|
111
|
+
; Boolean combinators
|
112
|
+
|
113
|
+
; (and) returns the first falsey value returned by the list
|
114
|
+
; of expressions, or returns the value of the last expression
|
115
|
+
; if all values are truthy.
|
116
|
+
(define-syntax and (syntax-rules ()
|
117
|
+
[(and test) test]
|
118
|
+
[(and test1 test2 ...)
|
119
|
+
(let ([temp test1])
|
120
|
+
(if (not temp)
|
121
|
+
temp
|
122
|
+
(and test2 ...)))]))
|
123
|
+
|
124
|
+
; (or) returns the first truthy value returned by the list
|
125
|
+
; of expressions, or returns the value of the last expression
|
126
|
+
; if all values are falsey.
|
127
|
+
(define-syntax or (syntax-rules ()
|
128
|
+
[(or test) test]
|
129
|
+
[(or test1 test2 ...)
|
130
|
+
(let ([temp test1])
|
131
|
+
(if temp
|
132
|
+
temp
|
133
|
+
(or test2 ...)))]))
|
134
|
+
|
135
|
+
;----------------------------------------------------------------
|
136
|
+
|
137
|
+
; Delayed evaluation
|
138
|
+
|
139
|
+
; (delay) allows the evaluation of an expression to be delayed
|
140
|
+
; by wrapping it in a promise. Use (force) to evaluate the promise
|
141
|
+
; at a later time. The expression inside a promise is only
|
142
|
+
; ever evaluated once, so a promise can be implemented as a
|
143
|
+
; memoized closure.
|
144
|
+
(define-syntax delay (syntax-rules ()
|
145
|
+
[(delay expression)
|
146
|
+
(let ([forced #f]
|
147
|
+
[memo #f])
|
148
|
+
(lambda ()
|
149
|
+
(if forced
|
150
|
+
memo
|
151
|
+
(begin
|
152
|
+
(set! memo expression)
|
153
|
+
(set! forced #t)
|
154
|
+
memo))))]))
|
155
|
+
|
data/lib/heist.rb
ADDED
@@ -0,0 +1,47 @@
|
|
1
|
+
require 'rubygems'
|
2
|
+
require 'treetop'
|
3
|
+
|
4
|
+
module Heist
|
5
|
+
VERSION = '0.1.0'
|
6
|
+
|
7
|
+
ROOT_PATH = File.expand_path(File.dirname(__FILE__))
|
8
|
+
PARSER_PATH = ROOT_PATH + '/parser/'
|
9
|
+
RUNTIME_PATH = ROOT_PATH + '/runtime/'
|
10
|
+
BUILTIN_PATH = ROOT_PATH + '/builtin/'
|
11
|
+
LIB_PATH = ROOT_PATH + '/stdlib/'
|
12
|
+
|
13
|
+
require PARSER_PATH + 'scheme'
|
14
|
+
require PARSER_PATH + 'nodes'
|
15
|
+
require RUNTIME_PATH + 'runtime'
|
16
|
+
require ROOT_PATH + '/repl'
|
17
|
+
|
18
|
+
LOAD_PATH = [LIB_PATH]
|
19
|
+
FILE_EXT = ".scm"
|
20
|
+
|
21
|
+
class HeistError < StandardError; end
|
22
|
+
class RuntimeError < HeistError; end
|
23
|
+
class UndefinedVariable < RuntimeError; end
|
24
|
+
class SyntaxError < RuntimeError; end
|
25
|
+
class MacroError < SyntaxError; end
|
26
|
+
class MacroTemplateMismatch < MacroError; end
|
27
|
+
|
28
|
+
def self.parse(source)
|
29
|
+
@parser ||= SchemeParser.new
|
30
|
+
@parser.parse(source)
|
31
|
+
end
|
32
|
+
|
33
|
+
def self.evaluate(expression, scope)
|
34
|
+
Runtime::Expression === expression ?
|
35
|
+
expression.eval(scope) :
|
36
|
+
expression
|
37
|
+
end
|
38
|
+
|
39
|
+
def self.info(runtime)
|
40
|
+
puts "Heist Scheme interpreter v. #{ VERSION }"
|
41
|
+
puts "Evaluation mode: #{ runtime.lazy? ? 'LAZY' : 'EAGER' }"
|
42
|
+
puts "Continuations enabled? #{ runtime.stackless? ? 'NO' : 'YES' }"
|
43
|
+
puts "Macros: #{ runtime.hygienic? ? 'HYGIENIC' : 'UNHYGIENIC' }\n\n"
|
44
|
+
end
|
45
|
+
|
46
|
+
end
|
47
|
+
|
data/lib/parser/nodes.rb
ADDED
@@ -0,0 +1,105 @@
|
|
1
|
+
module Heist
|
2
|
+
module Scheme
|
3
|
+
|
4
|
+
SHORTHANDS = {
|
5
|
+
"'" => :quote,
|
6
|
+
"`" => :quasiquote,
|
7
|
+
"," => :unquote,
|
8
|
+
",@" => :'unquote-splicing'
|
9
|
+
}
|
10
|
+
|
11
|
+
class Program < Treetop::Runtime::SyntaxNode
|
12
|
+
def eval(scope)
|
13
|
+
convert!
|
14
|
+
@data.map { |part| Heist.evaluate(part, scope) }.last
|
15
|
+
end
|
16
|
+
|
17
|
+
def convert!
|
18
|
+
return if @data
|
19
|
+
@data = []
|
20
|
+
elements.each_with_index { |cell, i| self[i] = cell.eval }
|
21
|
+
end
|
22
|
+
|
23
|
+
def [](index)
|
24
|
+
@data[index]
|
25
|
+
end
|
26
|
+
|
27
|
+
def []=(index, value)
|
28
|
+
value.exists_at!(self, index) if Runtime::Expression === value
|
29
|
+
@data[index] = value
|
30
|
+
end
|
31
|
+
end
|
32
|
+
|
33
|
+
module List
|
34
|
+
def eval
|
35
|
+
list = Runtime::List.new
|
36
|
+
cells.each { |c| list << c.eval }
|
37
|
+
list
|
38
|
+
end
|
39
|
+
|
40
|
+
def cells
|
41
|
+
@cells ||= elements[1].elements
|
42
|
+
end
|
43
|
+
end
|
44
|
+
|
45
|
+
class Cell < Treetop::Runtime::SyntaxNode
|
46
|
+
def eval
|
47
|
+
result = elements[3].eval
|
48
|
+
string = elements[1].text_value
|
49
|
+
SHORTHANDS.has_key?(string) ?
|
50
|
+
Runtime::List.new([Runtime::Identifier.new(SHORTHANDS[string]), result]) :
|
51
|
+
result
|
52
|
+
end
|
53
|
+
end
|
54
|
+
|
55
|
+
class Datum < Treetop::Runtime::SyntaxNode
|
56
|
+
def eval
|
57
|
+
elements[0].eval
|
58
|
+
end
|
59
|
+
end
|
60
|
+
|
61
|
+
module Boolean
|
62
|
+
def eval
|
63
|
+
@value ||= (text_value == "#t")
|
64
|
+
end
|
65
|
+
end
|
66
|
+
|
67
|
+
class Complex < Treetop::Runtime::SyntaxNode
|
68
|
+
def eval
|
69
|
+
# TODO
|
70
|
+
end
|
71
|
+
end
|
72
|
+
|
73
|
+
class Real < Treetop::Runtime::SyntaxNode
|
74
|
+
def eval
|
75
|
+
@value ||= Kernel.eval(text_value).to_f
|
76
|
+
end
|
77
|
+
end
|
78
|
+
|
79
|
+
class Rational < Treetop::Runtime::SyntaxNode
|
80
|
+
def eval
|
81
|
+
@value ||= numerator.eval.to_f / denominator.eval
|
82
|
+
end
|
83
|
+
end
|
84
|
+
|
85
|
+
class Integer < Treetop::Runtime::SyntaxNode
|
86
|
+
def eval
|
87
|
+
@value ||= Kernel.eval(text_value).to_i
|
88
|
+
end
|
89
|
+
end
|
90
|
+
|
91
|
+
class String < Treetop::Runtime::SyntaxNode
|
92
|
+
def eval
|
93
|
+
@value ||= Kernel.eval(text_value)
|
94
|
+
end
|
95
|
+
end
|
96
|
+
|
97
|
+
class Identifier < Treetop::Runtime::SyntaxNode
|
98
|
+
def eval
|
99
|
+
Runtime::Identifier.new(text_value)
|
100
|
+
end
|
101
|
+
end
|
102
|
+
|
103
|
+
end
|
104
|
+
end
|
105
|
+
|
@@ -0,0 +1,1081 @@
|
|
1
|
+
module Heist
|
2
|
+
module Scheme
|
3
|
+
include Treetop::Runtime
|
4
|
+
|
5
|
+
def root
|
6
|
+
@root || :program
|
7
|
+
end
|
8
|
+
|
9
|
+
def _nt_program
|
10
|
+
start_index = index
|
11
|
+
if node_cache[:program].has_key?(index)
|
12
|
+
cached = node_cache[:program][index]
|
13
|
+
@index = cached.interval.end if cached
|
14
|
+
return cached
|
15
|
+
end
|
16
|
+
|
17
|
+
s0, i0 = [], index
|
18
|
+
loop do
|
19
|
+
r1 = _nt_cell
|
20
|
+
if r1
|
21
|
+
s0 << r1
|
22
|
+
else
|
23
|
+
break
|
24
|
+
end
|
25
|
+
end
|
26
|
+
r0 = Program.new(input, i0...index, s0)
|
27
|
+
|
28
|
+
node_cache[:program][start_index] = r0
|
29
|
+
|
30
|
+
return r0
|
31
|
+
end
|
32
|
+
|
33
|
+
module Cell0
|
34
|
+
def ignore
|
35
|
+
elements[0]
|
36
|
+
end
|
37
|
+
|
38
|
+
def ignore
|
39
|
+
elements[2]
|
40
|
+
end
|
41
|
+
|
42
|
+
def ignore
|
43
|
+
elements[4]
|
44
|
+
end
|
45
|
+
end
|
46
|
+
|
47
|
+
def _nt_cell
|
48
|
+
start_index = index
|
49
|
+
if node_cache[:cell].has_key?(index)
|
50
|
+
cached = node_cache[:cell][index]
|
51
|
+
@index = cached.interval.end if cached
|
52
|
+
return cached
|
53
|
+
end
|
54
|
+
|
55
|
+
i0, s0 = index, []
|
56
|
+
r1 = _nt_ignore
|
57
|
+
s0 << r1
|
58
|
+
if r1
|
59
|
+
r3 = _nt_quote
|
60
|
+
if r3
|
61
|
+
r2 = r3
|
62
|
+
else
|
63
|
+
r2 = SyntaxNode.new(input, index...index)
|
64
|
+
end
|
65
|
+
s0 << r2
|
66
|
+
if r2
|
67
|
+
r4 = _nt_ignore
|
68
|
+
s0 << r4
|
69
|
+
if r4
|
70
|
+
i5 = index
|
71
|
+
r6 = _nt_list
|
72
|
+
if r6
|
73
|
+
r5 = r6
|
74
|
+
else
|
75
|
+
r7 = _nt_atom
|
76
|
+
if r7
|
77
|
+
r5 = r7
|
78
|
+
else
|
79
|
+
self.index = i5
|
80
|
+
r5 = nil
|
81
|
+
end
|
82
|
+
end
|
83
|
+
s0 << r5
|
84
|
+
if r5
|
85
|
+
r8 = _nt_ignore
|
86
|
+
s0 << r8
|
87
|
+
end
|
88
|
+
end
|
89
|
+
end
|
90
|
+
end
|
91
|
+
if s0.last
|
92
|
+
r0 = (Cell).new(input, i0...index, s0)
|
93
|
+
r0.extend(Cell0)
|
94
|
+
else
|
95
|
+
self.index = i0
|
96
|
+
r0 = nil
|
97
|
+
end
|
98
|
+
|
99
|
+
node_cache[:cell][start_index] = r0
|
100
|
+
|
101
|
+
return r0
|
102
|
+
end
|
103
|
+
|
104
|
+
def _nt_quote
|
105
|
+
start_index = index
|
106
|
+
if node_cache[:quote].has_key?(index)
|
107
|
+
cached = node_cache[:quote][index]
|
108
|
+
@index = cached.interval.end if cached
|
109
|
+
return cached
|
110
|
+
end
|
111
|
+
|
112
|
+
i0 = index
|
113
|
+
if input.index("'", index) == index
|
114
|
+
r1 = (SyntaxNode).new(input, index...(index + 1))
|
115
|
+
@index += 1
|
116
|
+
else
|
117
|
+
terminal_parse_failure("'")
|
118
|
+
r1 = nil
|
119
|
+
end
|
120
|
+
if r1
|
121
|
+
r0 = r1
|
122
|
+
else
|
123
|
+
if input.index("`", index) == index
|
124
|
+
r2 = (SyntaxNode).new(input, index...(index + 1))
|
125
|
+
@index += 1
|
126
|
+
else
|
127
|
+
terminal_parse_failure("`")
|
128
|
+
r2 = nil
|
129
|
+
end
|
130
|
+
if r2
|
131
|
+
r0 = r2
|
132
|
+
else
|
133
|
+
if input.index(",@", index) == index
|
134
|
+
r3 = (SyntaxNode).new(input, index...(index + 2))
|
135
|
+
@index += 2
|
136
|
+
else
|
137
|
+
terminal_parse_failure(",@")
|
138
|
+
r3 = nil
|
139
|
+
end
|
140
|
+
if r3
|
141
|
+
r0 = r3
|
142
|
+
else
|
143
|
+
if input.index(",", index) == index
|
144
|
+
r4 = (SyntaxNode).new(input, index...(index + 1))
|
145
|
+
@index += 1
|
146
|
+
else
|
147
|
+
terminal_parse_failure(",")
|
148
|
+
r4 = nil
|
149
|
+
end
|
150
|
+
if r4
|
151
|
+
r0 = r4
|
152
|
+
else
|
153
|
+
self.index = i0
|
154
|
+
r0 = nil
|
155
|
+
end
|
156
|
+
end
|
157
|
+
end
|
158
|
+
end
|
159
|
+
|
160
|
+
node_cache[:quote][start_index] = r0
|
161
|
+
|
162
|
+
return r0
|
163
|
+
end
|
164
|
+
|
165
|
+
module List0
|
166
|
+
end
|
167
|
+
|
168
|
+
module List1
|
169
|
+
end
|
170
|
+
|
171
|
+
def _nt_list
|
172
|
+
start_index = index
|
173
|
+
if node_cache[:list].has_key?(index)
|
174
|
+
cached = node_cache[:list][index]
|
175
|
+
@index = cached.interval.end if cached
|
176
|
+
return cached
|
177
|
+
end
|
178
|
+
|
179
|
+
i0 = index
|
180
|
+
i1, s1 = index, []
|
181
|
+
if input.index("(", index) == index
|
182
|
+
r2 = (SyntaxNode).new(input, index...(index + 1))
|
183
|
+
@index += 1
|
184
|
+
else
|
185
|
+
terminal_parse_failure("(")
|
186
|
+
r2 = nil
|
187
|
+
end
|
188
|
+
s1 << r2
|
189
|
+
if r2
|
190
|
+
s3, i3 = [], index
|
191
|
+
loop do
|
192
|
+
r4 = _nt_cell
|
193
|
+
if r4
|
194
|
+
s3 << r4
|
195
|
+
else
|
196
|
+
break
|
197
|
+
end
|
198
|
+
end
|
199
|
+
r3 = SyntaxNode.new(input, i3...index, s3)
|
200
|
+
s1 << r3
|
201
|
+
if r3
|
202
|
+
if input.index(")", index) == index
|
203
|
+
r5 = (SyntaxNode).new(input, index...(index + 1))
|
204
|
+
@index += 1
|
205
|
+
else
|
206
|
+
terminal_parse_failure(")")
|
207
|
+
r5 = nil
|
208
|
+
end
|
209
|
+
s1 << r5
|
210
|
+
end
|
211
|
+
end
|
212
|
+
if s1.last
|
213
|
+
r1 = (SyntaxNode).new(input, i1...index, s1)
|
214
|
+
r1.extend(List0)
|
215
|
+
else
|
216
|
+
self.index = i1
|
217
|
+
r1 = nil
|
218
|
+
end
|
219
|
+
if r1
|
220
|
+
r0 = r1
|
221
|
+
r0.extend(List)
|
222
|
+
else
|
223
|
+
i6, s6 = index, []
|
224
|
+
if input.index("[", index) == index
|
225
|
+
r7 = (SyntaxNode).new(input, index...(index + 1))
|
226
|
+
@index += 1
|
227
|
+
else
|
228
|
+
terminal_parse_failure("[")
|
229
|
+
r7 = nil
|
230
|
+
end
|
231
|
+
s6 << r7
|
232
|
+
if r7
|
233
|
+
s8, i8 = [], index
|
234
|
+
loop do
|
235
|
+
r9 = _nt_cell
|
236
|
+
if r9
|
237
|
+
s8 << r9
|
238
|
+
else
|
239
|
+
break
|
240
|
+
end
|
241
|
+
end
|
242
|
+
r8 = SyntaxNode.new(input, i8...index, s8)
|
243
|
+
s6 << r8
|
244
|
+
if r8
|
245
|
+
if input.index("]", index) == index
|
246
|
+
r10 = (SyntaxNode).new(input, index...(index + 1))
|
247
|
+
@index += 1
|
248
|
+
else
|
249
|
+
terminal_parse_failure("]")
|
250
|
+
r10 = nil
|
251
|
+
end
|
252
|
+
s6 << r10
|
253
|
+
end
|
254
|
+
end
|
255
|
+
if s6.last
|
256
|
+
r6 = (SyntaxNode).new(input, i6...index, s6)
|
257
|
+
r6.extend(List1)
|
258
|
+
else
|
259
|
+
self.index = i6
|
260
|
+
r6 = nil
|
261
|
+
end
|
262
|
+
if r6
|
263
|
+
r0 = r6
|
264
|
+
r0.extend(List)
|
265
|
+
else
|
266
|
+
self.index = i0
|
267
|
+
r0 = nil
|
268
|
+
end
|
269
|
+
end
|
270
|
+
|
271
|
+
node_cache[:list][start_index] = r0
|
272
|
+
|
273
|
+
return r0
|
274
|
+
end
|
275
|
+
|
276
|
+
def _nt_atom
|
277
|
+
start_index = index
|
278
|
+
if node_cache[:atom].has_key?(index)
|
279
|
+
cached = node_cache[:atom][index]
|
280
|
+
@index = cached.interval.end if cached
|
281
|
+
return cached
|
282
|
+
end
|
283
|
+
|
284
|
+
i0 = index
|
285
|
+
r1 = _nt_datum
|
286
|
+
if r1
|
287
|
+
r0 = r1
|
288
|
+
else
|
289
|
+
r2 = _nt_identifier
|
290
|
+
if r2
|
291
|
+
r0 = r2
|
292
|
+
else
|
293
|
+
self.index = i0
|
294
|
+
r0 = nil
|
295
|
+
end
|
296
|
+
end
|
297
|
+
|
298
|
+
node_cache[:atom][start_index] = r0
|
299
|
+
|
300
|
+
return r0
|
301
|
+
end
|
302
|
+
|
303
|
+
module Datum0
|
304
|
+
end
|
305
|
+
|
306
|
+
module Datum1
|
307
|
+
end
|
308
|
+
|
309
|
+
def _nt_datum
|
310
|
+
start_index = index
|
311
|
+
if node_cache[:datum].has_key?(index)
|
312
|
+
cached = node_cache[:datum][index]
|
313
|
+
@index = cached.interval.end if cached
|
314
|
+
return cached
|
315
|
+
end
|
316
|
+
|
317
|
+
i0, s0 = index, []
|
318
|
+
i1 = index
|
319
|
+
r2 = _nt_boolean
|
320
|
+
if r2
|
321
|
+
r1 = r2
|
322
|
+
else
|
323
|
+
r3 = _nt_number
|
324
|
+
if r3
|
325
|
+
r1 = r3
|
326
|
+
else
|
327
|
+
r4 = _nt_string
|
328
|
+
if r4
|
329
|
+
r1 = r4
|
330
|
+
else
|
331
|
+
self.index = i1
|
332
|
+
r1 = nil
|
333
|
+
end
|
334
|
+
end
|
335
|
+
end
|
336
|
+
s0 << r1
|
337
|
+
if r1
|
338
|
+
i5 = index
|
339
|
+
i6, s6 = index, []
|
340
|
+
i7 = index
|
341
|
+
r8 = _nt_delimiter
|
342
|
+
if r8
|
343
|
+
r7 = nil
|
344
|
+
else
|
345
|
+
self.index = i7
|
346
|
+
r7 = SyntaxNode.new(input, index...index)
|
347
|
+
end
|
348
|
+
s6 << r7
|
349
|
+
if r7
|
350
|
+
if index < input_length
|
351
|
+
r9 = (SyntaxNode).new(input, index...(index + 1))
|
352
|
+
@index += 1
|
353
|
+
else
|
354
|
+
terminal_parse_failure("any character")
|
355
|
+
r9 = nil
|
356
|
+
end
|
357
|
+
s6 << r9
|
358
|
+
end
|
359
|
+
if s6.last
|
360
|
+
r6 = (SyntaxNode).new(input, i6...index, s6)
|
361
|
+
r6.extend(Datum0)
|
362
|
+
else
|
363
|
+
self.index = i6
|
364
|
+
r6 = nil
|
365
|
+
end
|
366
|
+
if r6
|
367
|
+
r5 = nil
|
368
|
+
else
|
369
|
+
self.index = i5
|
370
|
+
r5 = SyntaxNode.new(input, index...index)
|
371
|
+
end
|
372
|
+
s0 << r5
|
373
|
+
end
|
374
|
+
if s0.last
|
375
|
+
r0 = (Datum).new(input, i0...index, s0)
|
376
|
+
r0.extend(Datum1)
|
377
|
+
else
|
378
|
+
self.index = i0
|
379
|
+
r0 = nil
|
380
|
+
end
|
381
|
+
|
382
|
+
node_cache[:datum][start_index] = r0
|
383
|
+
|
384
|
+
return r0
|
385
|
+
end
|
386
|
+
|
387
|
+
def _nt_boolean
|
388
|
+
start_index = index
|
389
|
+
if node_cache[:boolean].has_key?(index)
|
390
|
+
cached = node_cache[:boolean][index]
|
391
|
+
@index = cached.interval.end if cached
|
392
|
+
return cached
|
393
|
+
end
|
394
|
+
|
395
|
+
i0 = index
|
396
|
+
if input.index("#t", index) == index
|
397
|
+
r1 = (SyntaxNode).new(input, index...(index + 2))
|
398
|
+
@index += 2
|
399
|
+
else
|
400
|
+
terminal_parse_failure("#t")
|
401
|
+
r1 = nil
|
402
|
+
end
|
403
|
+
if r1
|
404
|
+
r0 = r1
|
405
|
+
r0.extend(Boolean)
|
406
|
+
else
|
407
|
+
if input.index("#f", index) == index
|
408
|
+
r2 = (SyntaxNode).new(input, index...(index + 2))
|
409
|
+
@index += 2
|
410
|
+
else
|
411
|
+
terminal_parse_failure("#f")
|
412
|
+
r2 = nil
|
413
|
+
end
|
414
|
+
if r2
|
415
|
+
r0 = r2
|
416
|
+
r0.extend(Boolean)
|
417
|
+
else
|
418
|
+
self.index = i0
|
419
|
+
r0 = nil
|
420
|
+
end
|
421
|
+
end
|
422
|
+
|
423
|
+
node_cache[:boolean][start_index] = r0
|
424
|
+
|
425
|
+
return r0
|
426
|
+
end
|
427
|
+
|
428
|
+
def _nt_number
|
429
|
+
start_index = index
|
430
|
+
if node_cache[:number].has_key?(index)
|
431
|
+
cached = node_cache[:number][index]
|
432
|
+
@index = cached.interval.end if cached
|
433
|
+
return cached
|
434
|
+
end
|
435
|
+
|
436
|
+
i0 = index
|
437
|
+
r1 = _nt_complex
|
438
|
+
if r1
|
439
|
+
r0 = r1
|
440
|
+
else
|
441
|
+
r2 = _nt_real
|
442
|
+
if r2
|
443
|
+
r0 = r2
|
444
|
+
else
|
445
|
+
r3 = _nt_rational
|
446
|
+
if r3
|
447
|
+
r0 = r3
|
448
|
+
else
|
449
|
+
r4 = _nt_integer
|
450
|
+
if r4
|
451
|
+
r0 = r4
|
452
|
+
else
|
453
|
+
self.index = i0
|
454
|
+
r0 = nil
|
455
|
+
end
|
456
|
+
end
|
457
|
+
end
|
458
|
+
end
|
459
|
+
|
460
|
+
node_cache[:number][start_index] = r0
|
461
|
+
|
462
|
+
return r0
|
463
|
+
end
|
464
|
+
|
465
|
+
module Complex0
|
466
|
+
def real
|
467
|
+
elements[0]
|
468
|
+
end
|
469
|
+
|
470
|
+
def real
|
471
|
+
elements[2]
|
472
|
+
end
|
473
|
+
|
474
|
+
end
|
475
|
+
|
476
|
+
def _nt_complex
|
477
|
+
start_index = index
|
478
|
+
if node_cache[:complex].has_key?(index)
|
479
|
+
cached = node_cache[:complex][index]
|
480
|
+
@index = cached.interval.end if cached
|
481
|
+
return cached
|
482
|
+
end
|
483
|
+
|
484
|
+
i0, s0 = index, []
|
485
|
+
r1 = _nt_real
|
486
|
+
s0 << r1
|
487
|
+
if r1
|
488
|
+
if input.index("+", index) == index
|
489
|
+
r2 = (SyntaxNode).new(input, index...(index + 1))
|
490
|
+
@index += 1
|
491
|
+
else
|
492
|
+
terminal_parse_failure("+")
|
493
|
+
r2 = nil
|
494
|
+
end
|
495
|
+
s0 << r2
|
496
|
+
if r2
|
497
|
+
r3 = _nt_real
|
498
|
+
s0 << r3
|
499
|
+
if r3
|
500
|
+
if input.index("i", index) == index
|
501
|
+
r4 = (SyntaxNode).new(input, index...(index + 1))
|
502
|
+
@index += 1
|
503
|
+
else
|
504
|
+
terminal_parse_failure("i")
|
505
|
+
r4 = nil
|
506
|
+
end
|
507
|
+
s0 << r4
|
508
|
+
end
|
509
|
+
end
|
510
|
+
end
|
511
|
+
if s0.last
|
512
|
+
r0 = (Complex).new(input, i0...index, s0)
|
513
|
+
r0.extend(Complex0)
|
514
|
+
else
|
515
|
+
self.index = i0
|
516
|
+
r0 = nil
|
517
|
+
end
|
518
|
+
|
519
|
+
node_cache[:complex][start_index] = r0
|
520
|
+
|
521
|
+
return r0
|
522
|
+
end
|
523
|
+
|
524
|
+
module Real0
|
525
|
+
end
|
526
|
+
|
527
|
+
module Real1
|
528
|
+
def integer
|
529
|
+
elements[0]
|
530
|
+
end
|
531
|
+
|
532
|
+
end
|
533
|
+
|
534
|
+
def _nt_real
|
535
|
+
start_index = index
|
536
|
+
if node_cache[:real].has_key?(index)
|
537
|
+
cached = node_cache[:real][index]
|
538
|
+
@index = cached.interval.end if cached
|
539
|
+
return cached
|
540
|
+
end
|
541
|
+
|
542
|
+
i0, s0 = index, []
|
543
|
+
r1 = _nt_integer
|
544
|
+
s0 << r1
|
545
|
+
if r1
|
546
|
+
i2, s2 = index, []
|
547
|
+
if input.index(".", index) == index
|
548
|
+
r3 = (SyntaxNode).new(input, index...(index + 1))
|
549
|
+
@index += 1
|
550
|
+
else
|
551
|
+
terminal_parse_failure(".")
|
552
|
+
r3 = nil
|
553
|
+
end
|
554
|
+
s2 << r3
|
555
|
+
if r3
|
556
|
+
s4, i4 = [], index
|
557
|
+
loop do
|
558
|
+
r5 = _nt_digit
|
559
|
+
if r5
|
560
|
+
s4 << r5
|
561
|
+
else
|
562
|
+
break
|
563
|
+
end
|
564
|
+
end
|
565
|
+
if s4.empty?
|
566
|
+
self.index = i4
|
567
|
+
r4 = nil
|
568
|
+
else
|
569
|
+
r4 = SyntaxNode.new(input, i4...index, s4)
|
570
|
+
end
|
571
|
+
s2 << r4
|
572
|
+
end
|
573
|
+
if s2.last
|
574
|
+
r2 = (SyntaxNode).new(input, i2...index, s2)
|
575
|
+
r2.extend(Real0)
|
576
|
+
else
|
577
|
+
self.index = i2
|
578
|
+
r2 = nil
|
579
|
+
end
|
580
|
+
s0 << r2
|
581
|
+
end
|
582
|
+
if s0.last
|
583
|
+
r0 = (Real).new(input, i0...index, s0)
|
584
|
+
r0.extend(Real1)
|
585
|
+
else
|
586
|
+
self.index = i0
|
587
|
+
r0 = nil
|
588
|
+
end
|
589
|
+
|
590
|
+
node_cache[:real][start_index] = r0
|
591
|
+
|
592
|
+
return r0
|
593
|
+
end
|
594
|
+
|
595
|
+
module Rational0
|
596
|
+
def numerator
|
597
|
+
elements[0]
|
598
|
+
end
|
599
|
+
|
600
|
+
def denominator
|
601
|
+
elements[2]
|
602
|
+
end
|
603
|
+
end
|
604
|
+
|
605
|
+
def _nt_rational
|
606
|
+
start_index = index
|
607
|
+
if node_cache[:rational].has_key?(index)
|
608
|
+
cached = node_cache[:rational][index]
|
609
|
+
@index = cached.interval.end if cached
|
610
|
+
return cached
|
611
|
+
end
|
612
|
+
|
613
|
+
i0, s0 = index, []
|
614
|
+
r1 = _nt_integer
|
615
|
+
s0 << r1
|
616
|
+
if r1
|
617
|
+
if input.index("/", index) == index
|
618
|
+
r2 = (SyntaxNode).new(input, index...(index + 1))
|
619
|
+
@index += 1
|
620
|
+
else
|
621
|
+
terminal_parse_failure("/")
|
622
|
+
r2 = nil
|
623
|
+
end
|
624
|
+
s0 << r2
|
625
|
+
if r2
|
626
|
+
r3 = _nt_integer
|
627
|
+
s0 << r3
|
628
|
+
end
|
629
|
+
end
|
630
|
+
if s0.last
|
631
|
+
r0 = (Rational).new(input, i0...index, s0)
|
632
|
+
r0.extend(Rational0)
|
633
|
+
else
|
634
|
+
self.index = i0
|
635
|
+
r0 = nil
|
636
|
+
end
|
637
|
+
|
638
|
+
node_cache[:rational][start_index] = r0
|
639
|
+
|
640
|
+
return r0
|
641
|
+
end
|
642
|
+
|
643
|
+
module Integer0
|
644
|
+
end
|
645
|
+
|
646
|
+
module Integer1
|
647
|
+
end
|
648
|
+
|
649
|
+
def _nt_integer
|
650
|
+
start_index = index
|
651
|
+
if node_cache[:integer].has_key?(index)
|
652
|
+
cached = node_cache[:integer][index]
|
653
|
+
@index = cached.interval.end if cached
|
654
|
+
return cached
|
655
|
+
end
|
656
|
+
|
657
|
+
i0, s0 = index, []
|
658
|
+
if input.index("-", index) == index
|
659
|
+
r2 = (SyntaxNode).new(input, index...(index + 1))
|
660
|
+
@index += 1
|
661
|
+
else
|
662
|
+
terminal_parse_failure("-")
|
663
|
+
r2 = nil
|
664
|
+
end
|
665
|
+
if r2
|
666
|
+
r1 = r2
|
667
|
+
else
|
668
|
+
r1 = SyntaxNode.new(input, index...index)
|
669
|
+
end
|
670
|
+
s0 << r1
|
671
|
+
if r1
|
672
|
+
i3 = index
|
673
|
+
if input.index("0", index) == index
|
674
|
+
r4 = (SyntaxNode).new(input, index...(index + 1))
|
675
|
+
@index += 1
|
676
|
+
else
|
677
|
+
terminal_parse_failure("0")
|
678
|
+
r4 = nil
|
679
|
+
end
|
680
|
+
if r4
|
681
|
+
r3 = r4
|
682
|
+
else
|
683
|
+
i5, s5 = index, []
|
684
|
+
if input.index(Regexp.new('[1-9]'), index) == index
|
685
|
+
r6 = (SyntaxNode).new(input, index...(index + 1))
|
686
|
+
@index += 1
|
687
|
+
else
|
688
|
+
r6 = nil
|
689
|
+
end
|
690
|
+
s5 << r6
|
691
|
+
if r6
|
692
|
+
s7, i7 = [], index
|
693
|
+
loop do
|
694
|
+
r8 = _nt_digit
|
695
|
+
if r8
|
696
|
+
s7 << r8
|
697
|
+
else
|
698
|
+
break
|
699
|
+
end
|
700
|
+
end
|
701
|
+
r7 = SyntaxNode.new(input, i7...index, s7)
|
702
|
+
s5 << r7
|
703
|
+
end
|
704
|
+
if s5.last
|
705
|
+
r5 = (SyntaxNode).new(input, i5...index, s5)
|
706
|
+
r5.extend(Integer0)
|
707
|
+
else
|
708
|
+
self.index = i5
|
709
|
+
r5 = nil
|
710
|
+
end
|
711
|
+
if r5
|
712
|
+
r3 = r5
|
713
|
+
else
|
714
|
+
self.index = i3
|
715
|
+
r3 = nil
|
716
|
+
end
|
717
|
+
end
|
718
|
+
s0 << r3
|
719
|
+
end
|
720
|
+
if s0.last
|
721
|
+
r0 = (Integer).new(input, i0...index, s0)
|
722
|
+
r0.extend(Integer1)
|
723
|
+
else
|
724
|
+
self.index = i0
|
725
|
+
r0 = nil
|
726
|
+
end
|
727
|
+
|
728
|
+
node_cache[:integer][start_index] = r0
|
729
|
+
|
730
|
+
return r0
|
731
|
+
end
|
732
|
+
|
733
|
+
module String0
|
734
|
+
end
|
735
|
+
|
736
|
+
def _nt_string
|
737
|
+
start_index = index
|
738
|
+
if node_cache[:string].has_key?(index)
|
739
|
+
cached = node_cache[:string][index]
|
740
|
+
@index = cached.interval.end if cached
|
741
|
+
return cached
|
742
|
+
end
|
743
|
+
|
744
|
+
i0, s0 = index, []
|
745
|
+
if input.index('"', index) == index
|
746
|
+
r1 = (SyntaxNode).new(input, index...(index + 1))
|
747
|
+
@index += 1
|
748
|
+
else
|
749
|
+
terminal_parse_failure('"')
|
750
|
+
r1 = nil
|
751
|
+
end
|
752
|
+
s0 << r1
|
753
|
+
if r1
|
754
|
+
s2, i2 = [], index
|
755
|
+
loop do
|
756
|
+
i3 = index
|
757
|
+
if input.index('\\"', index) == index
|
758
|
+
r4 = (SyntaxNode).new(input, index...(index + 2))
|
759
|
+
@index += 2
|
760
|
+
else
|
761
|
+
terminal_parse_failure('\\"')
|
762
|
+
r4 = nil
|
763
|
+
end
|
764
|
+
if r4
|
765
|
+
r3 = r4
|
766
|
+
else
|
767
|
+
if input.index(Regexp.new('[^"]'), index) == index
|
768
|
+
r5 = (SyntaxNode).new(input, index...(index + 1))
|
769
|
+
@index += 1
|
770
|
+
else
|
771
|
+
r5 = nil
|
772
|
+
end
|
773
|
+
if r5
|
774
|
+
r3 = r5
|
775
|
+
else
|
776
|
+
self.index = i3
|
777
|
+
r3 = nil
|
778
|
+
end
|
779
|
+
end
|
780
|
+
if r3
|
781
|
+
s2 << r3
|
782
|
+
else
|
783
|
+
break
|
784
|
+
end
|
785
|
+
end
|
786
|
+
r2 = SyntaxNode.new(input, i2...index, s2)
|
787
|
+
s0 << r2
|
788
|
+
if r2
|
789
|
+
if input.index('"', index) == index
|
790
|
+
r6 = (SyntaxNode).new(input, index...(index + 1))
|
791
|
+
@index += 1
|
792
|
+
else
|
793
|
+
terminal_parse_failure('"')
|
794
|
+
r6 = nil
|
795
|
+
end
|
796
|
+
s0 << r6
|
797
|
+
end
|
798
|
+
end
|
799
|
+
if s0.last
|
800
|
+
r0 = (String).new(input, i0...index, s0)
|
801
|
+
r0.extend(String0)
|
802
|
+
else
|
803
|
+
self.index = i0
|
804
|
+
r0 = nil
|
805
|
+
end
|
806
|
+
|
807
|
+
node_cache[:string][start_index] = r0
|
808
|
+
|
809
|
+
return r0
|
810
|
+
end
|
811
|
+
|
812
|
+
module Identifier0
|
813
|
+
end
|
814
|
+
|
815
|
+
def _nt_identifier
|
816
|
+
start_index = index
|
817
|
+
if node_cache[:identifier].has_key?(index)
|
818
|
+
cached = node_cache[:identifier][index]
|
819
|
+
@index = cached.interval.end if cached
|
820
|
+
return cached
|
821
|
+
end
|
822
|
+
|
823
|
+
s0, i0 = [], index
|
824
|
+
loop do
|
825
|
+
i1, s1 = index, []
|
826
|
+
i2 = index
|
827
|
+
r3 = _nt_delimiter
|
828
|
+
if r3
|
829
|
+
r2 = nil
|
830
|
+
else
|
831
|
+
self.index = i2
|
832
|
+
r2 = SyntaxNode.new(input, index...index)
|
833
|
+
end
|
834
|
+
s1 << r2
|
835
|
+
if r2
|
836
|
+
if index < input_length
|
837
|
+
r4 = (SyntaxNode).new(input, index...(index + 1))
|
838
|
+
@index += 1
|
839
|
+
else
|
840
|
+
terminal_parse_failure("any character")
|
841
|
+
r4 = nil
|
842
|
+
end
|
843
|
+
s1 << r4
|
844
|
+
end
|
845
|
+
if s1.last
|
846
|
+
r1 = (SyntaxNode).new(input, i1...index, s1)
|
847
|
+
r1.extend(Identifier0)
|
848
|
+
else
|
849
|
+
self.index = i1
|
850
|
+
r1 = nil
|
851
|
+
end
|
852
|
+
if r1
|
853
|
+
s0 << r1
|
854
|
+
else
|
855
|
+
break
|
856
|
+
end
|
857
|
+
end
|
858
|
+
if s0.empty?
|
859
|
+
self.index = i0
|
860
|
+
r0 = nil
|
861
|
+
else
|
862
|
+
r0 = Identifier.new(input, i0...index, s0)
|
863
|
+
end
|
864
|
+
|
865
|
+
node_cache[:identifier][start_index] = r0
|
866
|
+
|
867
|
+
return r0
|
868
|
+
end
|
869
|
+
|
870
|
+
def _nt_digit
|
871
|
+
start_index = index
|
872
|
+
if node_cache[:digit].has_key?(index)
|
873
|
+
cached = node_cache[:digit][index]
|
874
|
+
@index = cached.interval.end if cached
|
875
|
+
return cached
|
876
|
+
end
|
877
|
+
|
878
|
+
if input.index(Regexp.new('[0-9]'), index) == index
|
879
|
+
r0 = (SyntaxNode).new(input, index...(index + 1))
|
880
|
+
@index += 1
|
881
|
+
else
|
882
|
+
r0 = nil
|
883
|
+
end
|
884
|
+
|
885
|
+
node_cache[:digit][start_index] = r0
|
886
|
+
|
887
|
+
return r0
|
888
|
+
end
|
889
|
+
|
890
|
+
def _nt_delimiter
|
891
|
+
start_index = index
|
892
|
+
if node_cache[:delimiter].has_key?(index)
|
893
|
+
cached = node_cache[:delimiter][index]
|
894
|
+
@index = cached.interval.end if cached
|
895
|
+
return cached
|
896
|
+
end
|
897
|
+
|
898
|
+
i0 = index
|
899
|
+
if input.index(Regexp.new('[\\(\\)\\[\\]]'), index) == index
|
900
|
+
r1 = (SyntaxNode).new(input, index...(index + 1))
|
901
|
+
@index += 1
|
902
|
+
else
|
903
|
+
r1 = nil
|
904
|
+
end
|
905
|
+
if r1
|
906
|
+
r0 = r1
|
907
|
+
else
|
908
|
+
r2 = _nt_space
|
909
|
+
if r2
|
910
|
+
r0 = r2
|
911
|
+
else
|
912
|
+
self.index = i0
|
913
|
+
r0 = nil
|
914
|
+
end
|
915
|
+
end
|
916
|
+
|
917
|
+
node_cache[:delimiter][start_index] = r0
|
918
|
+
|
919
|
+
return r0
|
920
|
+
end
|
921
|
+
|
922
|
+
def _nt_space
|
923
|
+
start_index = index
|
924
|
+
if node_cache[:space].has_key?(index)
|
925
|
+
cached = node_cache[:space][index]
|
926
|
+
@index = cached.interval.end if cached
|
927
|
+
return cached
|
928
|
+
end
|
929
|
+
|
930
|
+
if input.index(Regexp.new('[\\s\\n\\r\\t]'), index) == index
|
931
|
+
r0 = (SyntaxNode).new(input, index...(index + 1))
|
932
|
+
@index += 1
|
933
|
+
else
|
934
|
+
r0 = nil
|
935
|
+
end
|
936
|
+
|
937
|
+
node_cache[:space][start_index] = r0
|
938
|
+
|
939
|
+
return r0
|
940
|
+
end
|
941
|
+
|
942
|
+
module Ignore0
|
943
|
+
end
|
944
|
+
|
945
|
+
def _nt_ignore
|
946
|
+
start_index = index
|
947
|
+
if node_cache[:ignore].has_key?(index)
|
948
|
+
cached = node_cache[:ignore][index]
|
949
|
+
@index = cached.interval.end if cached
|
950
|
+
return cached
|
951
|
+
end
|
952
|
+
|
953
|
+
i0, s0 = index, []
|
954
|
+
s1, i1 = [], index
|
955
|
+
loop do
|
956
|
+
r2 = _nt_space
|
957
|
+
if r2
|
958
|
+
s1 << r2
|
959
|
+
else
|
960
|
+
break
|
961
|
+
end
|
962
|
+
end
|
963
|
+
r1 = SyntaxNode.new(input, i1...index, s1)
|
964
|
+
s0 << r1
|
965
|
+
if r1
|
966
|
+
r4 = _nt_comment
|
967
|
+
if r4
|
968
|
+
r3 = r4
|
969
|
+
else
|
970
|
+
r3 = SyntaxNode.new(input, index...index)
|
971
|
+
end
|
972
|
+
s0 << r3
|
973
|
+
end
|
974
|
+
if s0.last
|
975
|
+
r0 = (SyntaxNode).new(input, i0...index, s0)
|
976
|
+
r0.extend(Ignore0)
|
977
|
+
else
|
978
|
+
self.index = i0
|
979
|
+
r0 = nil
|
980
|
+
end
|
981
|
+
|
982
|
+
node_cache[:ignore][start_index] = r0
|
983
|
+
|
984
|
+
return r0
|
985
|
+
end
|
986
|
+
|
987
|
+
module Comment0
|
988
|
+
end
|
989
|
+
|
990
|
+
module Comment1
|
991
|
+
def ignore
|
992
|
+
elements[2]
|
993
|
+
end
|
994
|
+
end
|
995
|
+
|
996
|
+
def _nt_comment
|
997
|
+
start_index = index
|
998
|
+
if node_cache[:comment].has_key?(index)
|
999
|
+
cached = node_cache[:comment][index]
|
1000
|
+
@index = cached.interval.end if cached
|
1001
|
+
return cached
|
1002
|
+
end
|
1003
|
+
|
1004
|
+
i0, s0 = index, []
|
1005
|
+
if input.index(";", index) == index
|
1006
|
+
r1 = (SyntaxNode).new(input, index...(index + 1))
|
1007
|
+
@index += 1
|
1008
|
+
else
|
1009
|
+
terminal_parse_failure(";")
|
1010
|
+
r1 = nil
|
1011
|
+
end
|
1012
|
+
s0 << r1
|
1013
|
+
if r1
|
1014
|
+
s2, i2 = [], index
|
1015
|
+
loop do
|
1016
|
+
i3, s3 = index, []
|
1017
|
+
i4 = index
|
1018
|
+
if input.index(Regexp.new('[\\n\\r]'), index) == index
|
1019
|
+
r5 = (SyntaxNode).new(input, index...(index + 1))
|
1020
|
+
@index += 1
|
1021
|
+
else
|
1022
|
+
r5 = nil
|
1023
|
+
end
|
1024
|
+
if r5
|
1025
|
+
r4 = nil
|
1026
|
+
else
|
1027
|
+
self.index = i4
|
1028
|
+
r4 = SyntaxNode.new(input, index...index)
|
1029
|
+
end
|
1030
|
+
s3 << r4
|
1031
|
+
if r4
|
1032
|
+
if index < input_length
|
1033
|
+
r6 = (SyntaxNode).new(input, index...(index + 1))
|
1034
|
+
@index += 1
|
1035
|
+
else
|
1036
|
+
terminal_parse_failure("any character")
|
1037
|
+
r6 = nil
|
1038
|
+
end
|
1039
|
+
s3 << r6
|
1040
|
+
end
|
1041
|
+
if s3.last
|
1042
|
+
r3 = (SyntaxNode).new(input, i3...index, s3)
|
1043
|
+
r3.extend(Comment0)
|
1044
|
+
else
|
1045
|
+
self.index = i3
|
1046
|
+
r3 = nil
|
1047
|
+
end
|
1048
|
+
if r3
|
1049
|
+
s2 << r3
|
1050
|
+
else
|
1051
|
+
break
|
1052
|
+
end
|
1053
|
+
end
|
1054
|
+
r2 = SyntaxNode.new(input, i2...index, s2)
|
1055
|
+
s0 << r2
|
1056
|
+
if r2
|
1057
|
+
r7 = _nt_ignore
|
1058
|
+
s0 << r7
|
1059
|
+
end
|
1060
|
+
end
|
1061
|
+
if s0.last
|
1062
|
+
r0 = (SyntaxNode).new(input, i0...index, s0)
|
1063
|
+
r0.extend(Comment1)
|
1064
|
+
else
|
1065
|
+
self.index = i0
|
1066
|
+
r0 = nil
|
1067
|
+
end
|
1068
|
+
|
1069
|
+
node_cache[:comment][start_index] = r0
|
1070
|
+
|
1071
|
+
return r0
|
1072
|
+
end
|
1073
|
+
|
1074
|
+
end
|
1075
|
+
|
1076
|
+
class SchemeParser < Treetop::Runtime::CompiledParser
|
1077
|
+
include Scheme
|
1078
|
+
end
|
1079
|
+
|
1080
|
+
end
|
1081
|
+
|