antlr3 1.2.4 → 1.3.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/bin/antlr4ruby +1 -13
- data/java/RubyTarget.java +8 -125
- data/java/antlr-full-3.2.1.jar +0 -0
- data/lib/antlr3/constants.rb +2 -0
- data/lib/antlr3/dfa.rb +18 -15
- data/lib/antlr3/error.rb +3 -3
- data/lib/antlr3/main.rb +8 -9
- data/lib/antlr3/modes/ast-builder.rb +24 -4
- data/lib/antlr3/recognizers.rb +17 -16
- data/lib/antlr3/task.rb +13 -0
- data/lib/antlr3/token.rb +53 -17
- data/lib/antlr3/tree.rb +491 -561
- data/lib/antlr3/tree/wizard.rb +139 -127
- data/lib/antlr3/util.rb +7 -1
- data/lib/antlr3/version.rb +4 -4
- data/samples/{Cpp.g → CPP.g} +1 -1
- data/templates/AST.stg +1 -1
- data/templates/Ruby.stg +29 -42
- data/test/functional/ast-output/auto-ast.rb +3 -3
- data/test/functional/ast-output/tree-rewrite.rb +1 -1
- data/test/functional/debugging/debug-mode.rb +2 -2
- data/test/unit/test-tree-wizard.rb +115 -156
- data/test/unit/test-trees.rb +66 -77
- metadata +4 -5
- data/lib/antlr3/test/config.rb +0 -23
- data/lib/antlr3/test/diff.rb +0 -165
data/lib/antlr3/task.rb
ADDED
data/lib/antlr3/token.rb
CHANGED
@@ -472,14 +472,17 @@ class TokenScheme < ::Module
|
|
472
472
|
tk_class ||= Class.new(::ANTLR3::CommonToken)
|
473
473
|
self.token_class = tk_class
|
474
474
|
|
475
|
-
const_set(:TOKEN_NAMES, ::ANTLR3::Constants::BUILT_IN_TOKEN_NAMES.clone)
|
475
|
+
const_set( :TOKEN_NAMES, ::ANTLR3::Constants::BUILT_IN_TOKEN_NAMES.clone )
|
476
|
+
|
477
|
+
@types = ::ANTLR3::Constants::BUILT_IN_TOKEN_NAMES.invert
|
478
|
+
@unused = ::ANTLR3::Constants::MIN_TOKEN_TYPE
|
476
479
|
|
477
480
|
scheme = self
|
478
|
-
define_method(:token_scheme) { scheme }
|
479
|
-
define_method(:token_names)
|
480
|
-
define_method(:token_name) do |type|
|
481
|
+
define_method( :token_scheme ) { scheme }
|
482
|
+
define_method( :token_names ) { scheme::TOKEN_NAMES }
|
483
|
+
define_method( :token_name ) do |type|
|
481
484
|
begin
|
482
|
-
token_names[type] or super
|
485
|
+
token_names[ type ] or super
|
483
486
|
rescue NoMethodError
|
484
487
|
::ANTLR3::CommonToken.token_name(type)
|
485
488
|
end
|
@@ -492,31 +495,64 @@ class TokenScheme < ::Module
|
|
492
495
|
end
|
493
496
|
end
|
494
497
|
|
498
|
+
def self.build( *token_names )
|
499
|
+
token_names = [ token_names ].flatten!
|
500
|
+
token_names.compact!
|
501
|
+
token_names.uniq!
|
502
|
+
tk_class = Class === token_names.first ? token_names.shift : nil
|
503
|
+
value_maps, names = token_names.partition { |i| Hash === i }
|
504
|
+
new( tk_class ) do
|
505
|
+
for value_map in value_maps
|
506
|
+
define_tokens( value_map )
|
507
|
+
end
|
508
|
+
|
509
|
+
for name in names
|
510
|
+
define_token( name )
|
511
|
+
end
|
512
|
+
end
|
513
|
+
end
|
514
|
+
|
515
|
+
|
495
516
|
def included(mod)
|
496
517
|
super
|
497
518
|
mod.extend(self)
|
498
519
|
end
|
499
520
|
private :included
|
521
|
+
attr_reader :unused, :types
|
500
522
|
|
501
|
-
def define_tokens(token_map = {})
|
523
|
+
def define_tokens( token_map = {} )
|
502
524
|
for token_name, token_value in token_map
|
503
525
|
define_token(token_name, token_value)
|
504
526
|
end
|
505
527
|
return self
|
506
528
|
end
|
507
529
|
|
508
|
-
def define_token(name, value)
|
509
|
-
|
510
|
-
|
530
|
+
def define_token( name, value = nil )
|
531
|
+
name = name.to_s
|
532
|
+
|
533
|
+
if current_value = @types[ name ]
|
534
|
+
# token type has already been defined
|
535
|
+
# raise an error unless value is the same as the current value
|
536
|
+
value ||= current_value
|
511
537
|
unless current_value == value
|
512
|
-
|
513
|
-
"
|
514
|
-
|
538
|
+
raise NameError.new(
|
539
|
+
"new token type definition ``#{name} = #{value}'' conflicts " <<
|
540
|
+
"with existing type definition ``#{name} = #{current_value}''", name
|
541
|
+
)
|
515
542
|
end
|
516
543
|
else
|
517
|
-
|
544
|
+
value ||= @unused
|
545
|
+
if name =~ /^[A-Z]\w*$/
|
546
|
+
const_set( name, @types[ name ] = value )
|
547
|
+
else
|
548
|
+
constant = "T__#{ value }"
|
549
|
+
const_set( constant, @types[ constant ] = value )
|
550
|
+
@types[ name ] = value
|
551
|
+
end
|
552
|
+
register_name( value, name ) unless built_in_type?( value )
|
518
553
|
end
|
519
|
-
|
554
|
+
|
555
|
+
value >= @unused and @unused = value + 1
|
520
556
|
return self
|
521
557
|
end
|
522
558
|
|
@@ -533,13 +569,13 @@ class TokenScheme < ::Module
|
|
533
569
|
end
|
534
570
|
end
|
535
571
|
|
536
|
-
def register_name(type_value, name)
|
572
|
+
def register_name( type_value, name )
|
537
573
|
name = name.to_s.freeze
|
538
574
|
if token_names.has_key?(type_value)
|
539
575
|
current_name = token_names[type_value]
|
540
576
|
current_name == name and return name
|
541
577
|
|
542
|
-
if current_name == "T__#{type_value}"
|
578
|
+
if current_name == "T__#{ type_value }"
|
543
579
|
# only an anonymous name is registered -- upgrade the name to the full literal name
|
544
580
|
token_names[type_value] = name
|
545
581
|
elsif name == "T__#{type_value}"
|
@@ -583,7 +619,7 @@ class TokenScheme < ::Module
|
|
583
619
|
Class === klass or raise(TypeError, "token_class must be a Class")
|
584
620
|
Util.silence_warnings do
|
585
621
|
klass < self or klass.send(:include, self)
|
586
|
-
const_set(:Token, klass)
|
622
|
+
const_set( :Token, klass )
|
587
623
|
end
|
588
624
|
end
|
589
625
|
|
data/lib/antlr3/tree.rb
CHANGED
@@ -102,132 +102,84 @@ See Tree and TreeAdaptor for more information.
|
|
102
102
|
=end
|
103
103
|
|
104
104
|
class TreeParser < BaseRecognizer
|
105
|
-
def self.main(argv = ARGV, options = {})
|
106
|
-
if
|
105
|
+
def self.main( argv = ARGV, options = {} )
|
106
|
+
if ::Hash === argv then argv, options = ARGV, argv end
|
107
107
|
main = ANTLR3::Main::WalkerMain.new(self, options)
|
108
|
-
block_given? ? yield(main) : main.execute(argv)
|
108
|
+
block_given? ? yield( main ) : main.execute( argv )
|
109
109
|
end
|
110
110
|
|
111
|
-
def initialize(input, options = {})
|
112
|
-
super(options)
|
111
|
+
def initialize( input, options = {} )
|
112
|
+
super( options )
|
113
113
|
@input = input
|
114
114
|
end
|
115
115
|
|
116
116
|
alias tree_node_stream input
|
117
117
|
alias tree_node_stream= input=
|
118
|
+
|
118
119
|
def source_name
|
119
120
|
@input.source_name
|
120
121
|
end
|
121
122
|
|
122
|
-
def
|
123
|
-
@input.look
|
124
|
-
end
|
125
|
-
|
126
|
-
def missing_symbol(error, expected_token_type, follow)
|
123
|
+
def missing_symbol( error, expected_token_type, follow )
|
127
124
|
name = token_name(expected_token_type).to_s
|
128
125
|
text = "<missing " << name << '>'
|
129
126
|
tk = create_token do |t|
|
130
127
|
t.text = text
|
131
128
|
t.type = expected_token_type
|
132
129
|
end
|
133
|
-
return(CommonTree.new(tk))
|
134
|
-
end
|
135
|
-
|
136
|
-
DOT_DOT_PATTERN = /.*[^\.]\\.{2}[^\.].*/
|
137
|
-
DOUBLE_ETC_PATTERN = /.*\.{3}\s+\.{3}.*/
|
138
|
-
|
139
|
-
def in_context?(context)
|
140
|
-
self.class.in_context?(
|
141
|
-
@input.tree_adaptor, token_names, @input.look, context)
|
130
|
+
return( CommonTree.new( tk ) )
|
142
131
|
end
|
143
132
|
|
144
|
-
def
|
145
|
-
case context
|
146
|
-
when DOT_DOT_PATTERN then raise ArgumentError, "invalid syntax: .."
|
147
|
-
when DOUBLE_ETC_PATTERN then raise ArgumentError, "invalid syntax: ... ..."
|
148
|
-
end
|
149
|
-
|
150
|
-
context = context.gsub(/([^\.\s])\.{3}([^\.])/, '\1 ... \2')
|
151
|
-
context.strip!
|
152
|
-
nodes = context.split(/\s+/)
|
153
|
-
|
154
|
-
ni = nodes.length.pred
|
155
|
-
tree = adaptor.parent(tree)
|
156
|
-
while ni >= 0 and tree
|
157
|
-
if nodes[ni] == '...'
|
158
|
-
ni.zero? and return true
|
159
|
-
goal = nodes[ni.pred]
|
160
|
-
ancestor = ancestor(adaptor, token_names, tree, goal) or return false
|
161
|
-
tree = ancestor
|
162
|
-
ni -= 1
|
163
|
-
end
|
164
|
-
name = token_names[adaptor.type_of(tree)]
|
165
|
-
name == nodes[ni] or return false
|
166
|
-
ni -= 1
|
167
|
-
tree = adaptor.parent(tree)
|
168
|
-
end
|
169
|
-
|
170
|
-
tree.nil? && ni >= 0 and return false
|
171
|
-
return true
|
172
|
-
end
|
173
|
-
|
174
|
-
def self.ancestor(adaptor, token_names, tree, goal)
|
175
|
-
while tree
|
176
|
-
name = token_names[adaptor.type_of(tree)]
|
177
|
-
name == goal and return tree
|
178
|
-
tree = adaptor.parent(tree)
|
179
|
-
end
|
180
|
-
return nil
|
181
|
-
end
|
182
|
-
|
183
|
-
def match_any(ignore = nil)
|
133
|
+
def match_any( ignore = nil )
|
184
134
|
@state.error_recovery = false
|
185
|
-
|
186
|
-
look = @input.look
|
187
|
-
if
|
135
|
+
|
136
|
+
look, adaptor = @input.look, @input.tree_adaptor
|
137
|
+
if adaptor.child_count( look ) == 0
|
188
138
|
@input.consume
|
189
139
|
return
|
190
140
|
end
|
141
|
+
|
191
142
|
level = 0
|
192
|
-
|
193
|
-
|
143
|
+
while type = @input.peek and type != EOF
|
144
|
+
#token_type == EOF or ( token_type == UP && level == 0 )
|
194
145
|
@input.consume
|
195
|
-
|
196
|
-
case token_type = @input.tree_adaptor.type_of(look)
|
146
|
+
case type
|
197
147
|
when DOWN then level += 1
|
198
|
-
when UP
|
148
|
+
when UP
|
149
|
+
level -= 1
|
150
|
+
level.zero? and break
|
199
151
|
end
|
200
152
|
end
|
201
|
-
@input.consume # consume UP
|
202
153
|
end
|
203
154
|
|
204
155
|
def mismatch(input, type, follow = nil)
|
205
|
-
raise MismatchedTreeNode.new(type, input)
|
156
|
+
raise MismatchedTreeNode.new( type, input )
|
206
157
|
end
|
207
158
|
|
208
|
-
def error_header(
|
209
|
-
|
210
|
-
#{
|
211
|
-
|
212
|
-
} line #{
|
159
|
+
def error_header( e )
|
160
|
+
<<-END.strip!
|
161
|
+
#{ grammar_file_name }: node from #{
|
162
|
+
e.approximate_line_info? ? 'after ' : ''
|
163
|
+
} line #{ e.line }:#{ e.column }
|
213
164
|
END
|
214
165
|
end
|
215
166
|
|
216
|
-
def error_message(e)
|
217
|
-
adaptor = e.input.
|
218
|
-
e.token = adaptor.token(e.node)
|
219
|
-
e.token ||= create_token do |tok|
|
220
|
-
tok.type = adaptor.type_of(e.node)
|
221
|
-
tok.text = adaptor.text_of(e.node)
|
167
|
+
def error_message( e )
|
168
|
+
adaptor = e.input.adaptor
|
169
|
+
e.token = adaptor.token( e.node )
|
170
|
+
e.token ||= create_token do | tok |
|
171
|
+
tok.type = adaptor.type_of( e.node )
|
172
|
+
tok.text = adaptor.text_of( e.node )
|
222
173
|
end
|
223
|
-
return super(e)
|
174
|
+
return super( e )
|
224
175
|
end
|
225
176
|
|
226
|
-
def trace_in(rule_name, rule_index)
|
227
|
-
super(rule_name, rule_index, @input.look)
|
177
|
+
def trace_in( rule_name, rule_index )
|
178
|
+
super( rule_name, rule_index, @input.look )
|
228
179
|
end
|
229
|
-
|
230
|
-
|
180
|
+
|
181
|
+
def trace_out( rule_name, rule_index )
|
182
|
+
super( rule_name, rule_index, @input.look )
|
231
183
|
end
|
232
184
|
end
|
233
185
|
|
@@ -267,116 +219,116 @@ throughout the AST library:
|
|
267
219
|
=end
|
268
220
|
|
269
221
|
module Tree
|
270
|
-
attr_accessor :parent
|
271
|
-
attr_accessor :
|
272
|
-
attr_accessor :
|
222
|
+
#attr_accessor :parent
|
223
|
+
attr_accessor :start_index
|
224
|
+
attr_accessor :stop_index
|
273
225
|
attr_accessor :child_index
|
274
226
|
attr_reader :type
|
275
227
|
attr_reader :text
|
276
228
|
attr_reader :line
|
277
229
|
attr_reader :column
|
278
|
-
attr_reader :children
|
230
|
+
#attr_reader :children
|
279
231
|
attr_reader :token
|
280
232
|
|
281
|
-
def [](index, length = nil) # getChild(index)
|
282
|
-
|
283
|
-
end
|
284
|
-
|
285
|
-
alias child []
|
286
|
-
|
287
|
-
def child_count # getChildCount
|
288
|
-
|
289
|
-
end
|
290
|
-
|
291
|
-
def push(node, *nodes)
|
292
|
-
|
293
|
-
end
|
294
|
-
|
295
|
-
alias << push
|
296
|
-
|
297
|
-
def shift
|
298
|
-
|
299
|
-
end
|
300
|
-
|
301
|
-
def unshift(node, *nodes)
|
302
|
-
|
303
|
-
end
|
304
|
-
|
305
|
-
alias add_child shift
|
306
|
-
|
307
|
-
def set_child(index, tree)
|
308
|
-
|
309
|
-
end
|
310
|
-
|
311
|
-
alias []= set_child
|
312
|
-
|
313
|
-
def delete_child(index)
|
314
|
-
|
315
|
-
end
|
316
|
-
|
317
|
-
def replace_children(start, stop, trees)
|
318
|
-
|
319
|
-
end
|
320
|
-
|
321
|
-
def to_a
|
322
|
-
|
323
|
-
|
324
|
-
end
|
325
|
-
|
326
|
-
include Enumerable
|
327
|
-
|
328
|
-
def each_child
|
329
|
-
|
330
|
-
|
331
|
-
end
|
332
|
-
|
333
|
-
def each_ancestor
|
334
|
-
|
335
|
-
|
336
|
-
end
|
337
|
-
|
338
|
-
def walk
|
339
|
-
|
340
|
-
|
341
|
-
|
342
|
-
|
343
|
-
|
344
|
-
|
345
|
-
|
346
|
-
|
347
|
-
|
348
|
-
|
349
|
-
|
350
|
-
|
351
|
-
|
352
|
-
|
353
|
-
|
354
|
-
|
355
|
-
end
|
356
|
-
|
357
|
-
def prune
|
358
|
-
|
359
|
-
end
|
360
|
-
|
361
|
-
alias :each :walk
|
362
|
-
|
363
|
-
def root?
|
364
|
-
|
365
|
-
end
|
366
|
-
|
367
|
-
def leaf?
|
368
|
-
|
369
|
-
end
|
370
|
-
|
371
|
-
def ancestors
|
372
|
-
|
373
|
-
|
374
|
-
|
375
|
-
|
376
|
-
|
377
|
-
|
378
|
-
|
379
|
-
end
|
233
|
+
#def [](index, length = nil) # getChild(index)
|
234
|
+
# length.nil? ? self.children[index] : self.children[index, length]
|
235
|
+
#end
|
236
|
+
#
|
237
|
+
#alias child []
|
238
|
+
#
|
239
|
+
#def child_count # getChildCount
|
240
|
+
# self.children.length
|
241
|
+
#end
|
242
|
+
#
|
243
|
+
#def push(node, *nodes)
|
244
|
+
# self.children.push(node, *nodes)
|
245
|
+
#end
|
246
|
+
#
|
247
|
+
#alias << push
|
248
|
+
#
|
249
|
+
#def shift
|
250
|
+
# self.children.shift
|
251
|
+
#end
|
252
|
+
#
|
253
|
+
#def unshift(node, *nodes)
|
254
|
+
# self.children.unshift(node, *nodes)
|
255
|
+
#end
|
256
|
+
#
|
257
|
+
#alias add_child shift
|
258
|
+
|
259
|
+
#def set_child(index, tree)
|
260
|
+
# self.children[index] = tree
|
261
|
+
#end
|
262
|
+
|
263
|
+
#alias []= set_child
|
264
|
+
|
265
|
+
#def delete_child(index)
|
266
|
+
# self.children.delete(index)
|
267
|
+
#end
|
268
|
+
#
|
269
|
+
#def replace_children(start, stop, trees)
|
270
|
+
# self.children[start..stop] = trees
|
271
|
+
#end
|
272
|
+
#
|
273
|
+
#def to_a
|
274
|
+
# child_arrays = children.map { |child| child.to_a }
|
275
|
+
# [token, *child_arrays]
|
276
|
+
#end
|
277
|
+
|
278
|
+
#include Enumerable
|
279
|
+
#
|
280
|
+
#def each_child
|
281
|
+
# block_given? or return enum_for(__method__)
|
282
|
+
# self.children.each { |child| yield(child) }
|
283
|
+
#end
|
284
|
+
#
|
285
|
+
#def each_ancestor
|
286
|
+
# block_given? or return enum_for(__method__)
|
287
|
+
# self.ancestors.each { |anc| yield(anc) }
|
288
|
+
#end
|
289
|
+
|
290
|
+
#def walk
|
291
|
+
# block_given? or return( enum_for( :walk ) )
|
292
|
+
# stack = []
|
293
|
+
# cursor = self
|
294
|
+
# loop do
|
295
|
+
# begin
|
296
|
+
# yield(cursor)
|
297
|
+
# stack.push(cursor.children.clone) unless cursor.leaf?
|
298
|
+
# rescue StopIteration
|
299
|
+
# # skips adding children to prune the node
|
300
|
+
# ensure
|
301
|
+
# break if stack.empty?
|
302
|
+
# cursor = stack.last.shift
|
303
|
+
# stack.pop if stack.last.empty?
|
304
|
+
# end
|
305
|
+
# end
|
306
|
+
# return self
|
307
|
+
#end
|
308
|
+
|
309
|
+
#def prune
|
310
|
+
# raise StopIteration
|
311
|
+
#end
|
312
|
+
|
313
|
+
#alias :each :walk
|
314
|
+
#
|
315
|
+
#def root?
|
316
|
+
# parent.nil?
|
317
|
+
#end
|
318
|
+
#
|
319
|
+
#def leaf?
|
320
|
+
# children.empty?
|
321
|
+
#end
|
322
|
+
#
|
323
|
+
#def ancestors
|
324
|
+
# a = []
|
325
|
+
# cursor = self
|
326
|
+
# until cursor.root?
|
327
|
+
# a.push(cursor.parent)
|
328
|
+
# cursor = cursor.parent
|
329
|
+
# end
|
330
|
+
# return a
|
331
|
+
#end
|
380
332
|
end
|
381
333
|
|
382
334
|
|
@@ -389,79 +341,77 @@ a node's token <i>payload</i>.
|
|
389
341
|
|
390
342
|
=end
|
391
343
|
|
392
|
-
class BaseTree
|
344
|
+
class BaseTree < ::Array
|
345
|
+
attr_accessor :parent
|
393
346
|
extend ClassMacros
|
394
347
|
include Tree
|
395
|
-
|
396
|
-
def initialize(node = nil)
|
397
|
-
|
348
|
+
|
349
|
+
def initialize( node = nil )
|
350
|
+
super()
|
398
351
|
@parent = nil
|
399
352
|
@child_index = 0
|
400
353
|
end
|
401
354
|
|
402
|
-
def
|
403
|
-
@children[index]
|
404
|
-
end
|
355
|
+
def children() self end
|
405
356
|
|
406
|
-
|
407
|
-
|
408
|
-
end
|
357
|
+
alias child at
|
358
|
+
alias child_count length
|
409
359
|
|
410
|
-
def
|
411
|
-
|
360
|
+
def first_with_type( tree_type )
|
361
|
+
find { | child | child.type == tree_type }
|
412
362
|
end
|
413
363
|
|
414
|
-
def add_child(child_tree)
|
364
|
+
def add_child( child_tree )
|
415
365
|
child_tree.nil? and return
|
416
366
|
if child_tree.flat_list?
|
417
|
-
if
|
367
|
+
if equal?( child_tree.children )
|
418
368
|
raise ArgumentError, "attempt to add child list to itself"
|
419
369
|
end
|
420
|
-
child_tree.
|
370
|
+
child_tree.each_with_index do | child, index |
|
421
371
|
child.parent = self
|
422
|
-
child.child_index =
|
372
|
+
child.child_index = length + index
|
423
373
|
end
|
424
|
-
|
374
|
+
concat( child_tree )
|
425
375
|
else
|
426
|
-
|
376
|
+
child_tree.child_index = length
|
427
377
|
child_tree.parent = self
|
428
|
-
|
378
|
+
self << child_tree
|
429
379
|
end
|
380
|
+
return( self )
|
430
381
|
end
|
431
382
|
|
432
|
-
def
|
433
|
-
@
|
383
|
+
def detach
|
384
|
+
@parent = nil
|
385
|
+
@child_index = -1
|
386
|
+
return( self )
|
434
387
|
end
|
435
388
|
|
436
|
-
|
389
|
+
alias add_children concat
|
390
|
+
|
391
|
+
def set_child( index, tree )
|
437
392
|
return if tree.nil?
|
438
393
|
tree.flat_list? and raise ArgumentError, "Can't set single child to a list"
|
439
394
|
tree.parent = self
|
440
395
|
tree.child_index = index
|
441
|
-
|
396
|
+
self[ index ] = tree
|
442
397
|
end
|
443
398
|
|
444
|
-
def delete_child(index)
|
445
|
-
|
446
|
-
@children[index, 1] = nil
|
447
|
-
@children[index..-1].each_with_index do |child, i|
|
448
|
-
child.child_index = index + i
|
449
|
-
end
|
450
|
-
end
|
399
|
+
def delete_child( index )
|
400
|
+
killed = delete_at( index ) and freshen( index )
|
451
401
|
return killed
|
452
402
|
end
|
453
403
|
|
454
|
-
def replace_children(
|
455
|
-
|
404
|
+
def replace_children( start, stop, new_tree )
|
405
|
+
start >= length or stop >= length and
|
456
406
|
raise IndexError, (<<-END).gsub!(/^\s+\| /,'')
|
457
407
|
| indices span beyond the number of children:
|
458
|
-
| children.length = #{
|
408
|
+
| children.length = #{length}
|
459
409
|
| start = #{start_index.inspect}
|
460
410
|
| stop = #{stop_index.inspect}
|
461
411
|
END
|
462
|
-
new_children = new_tree.flat_list? ? new_tree
|
463
|
-
|
464
|
-
|
412
|
+
new_children = new_tree.flat_list? ? new_tree : [ new_tree ]
|
413
|
+
self[ start .. stop ] = new_children
|
414
|
+
freshen(start_index)
|
465
415
|
return self
|
466
416
|
end
|
467
417
|
|
@@ -469,38 +419,35 @@ class BaseTree
|
|
469
419
|
false
|
470
420
|
end
|
471
421
|
|
472
|
-
def
|
473
|
-
|
474
|
-
|
475
|
-
|
422
|
+
def freshen( offset = 0 )
|
423
|
+
for i in offset ... length
|
424
|
+
node = self[ i ]
|
425
|
+
node.child_index = i
|
426
|
+
node.parent = self
|
476
427
|
end
|
477
428
|
end
|
478
429
|
|
479
|
-
|
480
|
-
def sanity_check_parent_and_child_indexes(parent = nil, i = -1)
|
430
|
+
def sanity_check( parent = nil, i = -1 )
|
481
431
|
parent == @parent or
|
482
|
-
raise TreeInconsistency.failed_parent_check!(parent, @parent)
|
432
|
+
raise TreeInconsistency.failed_parent_check!( parent, @parent )
|
483
433
|
i == @child_index or
|
484
|
-
raise TreeInconsistency.failed_index_check!(i, @child_index)
|
485
|
-
|
486
|
-
child.
|
434
|
+
raise TreeInconsistency.failed_index_check!( i, @child_index )
|
435
|
+
each_with_index do | child, index |
|
436
|
+
child.sanity_check( self, index )
|
487
437
|
end
|
488
438
|
end
|
489
|
-
|
490
|
-
def to_string_tree
|
491
|
-
@children.empty? and return self.to_s
|
492
|
-
buffer = []
|
493
|
-
buffer << '(' << self.to_s << ' ' unless self.flat_list?
|
494
|
-
buffer << @children.map { |child| child.to_string_tree }.join(' ')
|
495
|
-
buffer << ' '
|
496
|
-
buffer << ')' unless self.flat_list?
|
497
|
-
return buffer.join
|
498
|
-
end
|
499
439
|
|
500
|
-
def
|
501
|
-
|
440
|
+
def inspect
|
441
|
+
empty? and return to_s
|
442
|
+
buffer = ''
|
443
|
+
buffer << '(' << to_s << ' ' unless flat_list?
|
444
|
+
buffer << map { | c | c.inspect }.join( ' ' )
|
445
|
+
buffer << ')' unless flat_list?
|
446
|
+
return( buffer )
|
447
|
+
end
|
502
448
|
|
503
449
|
abstract :to_s
|
450
|
+
#protected :sanity_check, :freshen
|
504
451
|
end
|
505
452
|
|
506
453
|
|
@@ -529,31 +476,31 @@ the customized lighter-weight trees.
|
|
529
476
|
=end
|
530
477
|
|
531
478
|
class CommonTree < BaseTree
|
532
|
-
def initialize(payload = nil)
|
479
|
+
def initialize( payload = nil )
|
533
480
|
super()
|
534
481
|
@start_index = -1
|
535
482
|
@stop_index = -1
|
536
483
|
@child_index = -1
|
537
484
|
case payload
|
538
|
-
when CommonTree then
|
539
|
-
@token
|
485
|
+
when CommonTree then # copy-constructor style init
|
486
|
+
@token = payload.token
|
540
487
|
@start_index = payload.start_index
|
541
|
-
@stop_index
|
488
|
+
@stop_index = payload.stop_index
|
542
489
|
when nil, Token then @token = payload
|
543
|
-
else raise ArgumentError,
|
490
|
+
else raise ArgumentError,
|
491
|
+
"Invalid argument type: %s (%p)" % [ payload.class, payload ]
|
544
492
|
end
|
545
493
|
end
|
546
494
|
|
547
|
-
def initialize_copy(orig)
|
495
|
+
def initialize_copy( orig )
|
548
496
|
super
|
497
|
+
clear
|
549
498
|
@parent = nil
|
550
|
-
@children = []
|
551
499
|
end
|
552
500
|
|
553
|
-
attr_reader :token
|
554
501
|
|
555
502
|
def copy_node
|
556
|
-
return
|
503
|
+
return self.class.new( @token )
|
557
504
|
end
|
558
505
|
|
559
506
|
def flat_list?
|
@@ -561,7 +508,7 @@ class CommonTree < BaseTree
|
|
561
508
|
end
|
562
509
|
|
563
510
|
def type
|
564
|
-
@token
|
511
|
+
@token ? @token.type : 0
|
565
512
|
end
|
566
513
|
|
567
514
|
def text
|
@@ -570,109 +517,97 @@ class CommonTree < BaseTree
|
|
570
517
|
|
571
518
|
def line
|
572
519
|
if @token.nil? or @token.line == 0
|
573
|
-
return (
|
520
|
+
return ( empty? ? 0 : first.line )
|
574
521
|
end
|
575
522
|
return @token.line
|
576
523
|
end
|
577
524
|
|
578
525
|
def column
|
579
526
|
if @token.nil? or @token.column == -1
|
580
|
-
return(
|
527
|
+
return( empty? ? 0 : first.column )
|
581
528
|
end
|
582
529
|
return @token.column
|
583
530
|
end
|
584
531
|
|
532
|
+
|
585
533
|
def start_index
|
586
|
-
|
534
|
+
@start_index == -1 and @token and return @token.index
|
587
535
|
return @start_index
|
588
536
|
end
|
589
537
|
|
590
538
|
def stop_index
|
591
|
-
|
539
|
+
@stop_index == -1 and @token and return @token.index
|
592
540
|
return @stop_index
|
593
541
|
end
|
594
542
|
|
595
|
-
attr_writer :start_index, :stop_index
|
596
543
|
alias token_start_index= start_index=
|
597
544
|
alias token_stop_index= stop_index=
|
598
545
|
alias token_start_index start_index
|
599
546
|
alias token_stop_index stop_index
|
600
547
|
|
601
548
|
def name
|
602
|
-
@token.
|
549
|
+
@token.name rescue 'INVALID'
|
603
550
|
end
|
604
551
|
|
605
552
|
def token_range
|
606
|
-
|
607
|
-
@start_index
|
553
|
+
unknown_boundaries? and infer_boundaries
|
554
|
+
@start_index .. @stop_index
|
608
555
|
end
|
556
|
+
|
609
557
|
def source_range
|
610
|
-
|
611
|
-
tokens =
|
612
|
-
tk = node.token
|
613
|
-
(tk && tk.index >= 0) ? tk : nil
|
558
|
+
unknown_boundaries? and infer_boundaries
|
559
|
+
tokens = map do | node |
|
560
|
+
tk = node.token and tk.index >= 0 ? tk : nil
|
614
561
|
end
|
615
562
|
tokens.compact!
|
616
|
-
first, last = tokens.minmax_by { |
|
617
|
-
|
563
|
+
first, last = tokens.minmax_by { |t| t.index }
|
564
|
+
first.start .. last.stop
|
618
565
|
end
|
619
566
|
|
620
|
-
def
|
621
|
-
if
|
567
|
+
def infer_boundaries
|
568
|
+
if empty? and @start_index < 0 || @stop_index < 0
|
622
569
|
@start_index = @stop_index = @token.index rescue -1
|
623
570
|
return
|
624
571
|
end
|
625
|
-
for child in
|
572
|
+
for child in self do child.infer_boundaries end
|
626
573
|
return if @start_index >= 0 and @stop_index >= 0
|
627
574
|
|
628
|
-
@start_index =
|
629
|
-
@stop_index
|
575
|
+
@start_index = first.start_index
|
576
|
+
@stop_index = last.stop_index
|
630
577
|
return nil
|
631
578
|
end
|
632
579
|
|
633
|
-
def
|
634
|
-
@start_index < 0
|
580
|
+
def unknown_boundaries?
|
581
|
+
@start_index < 0 or @stop_index < 0
|
635
582
|
end
|
636
583
|
|
637
584
|
def to_s
|
638
585
|
flat_list? ? 'nil' : @token.text.to_s
|
639
586
|
end
|
640
587
|
|
641
|
-
def to_string_tree
|
642
|
-
children.empty? and return self.to_s
|
643
|
-
|
644
|
-
out = ''
|
645
|
-
out << "(#{self} " unless flat_list?
|
646
|
-
|
647
|
-
out << children.map { |child| child.to_string_tree }.join(' ')
|
648
|
-
out << ')' unless flat_list?
|
649
|
-
return out
|
650
|
-
end
|
651
|
-
alias inspect to_string_tree
|
652
|
-
|
653
588
|
def pretty_print(printer)
|
654
|
-
if
|
655
|
-
|
656
|
-
|
657
|
-
printer.text(line)
|
658
|
-
|
659
|
-
|
589
|
+
if empty?
|
590
|
+
to_s.each_line do | line |
|
591
|
+
nl = line.chomp!
|
592
|
+
printer.text( line )
|
593
|
+
if nl
|
594
|
+
printer.text( printer.newline )
|
595
|
+
printer.text( printer.genspace[ printer.indent ] )
|
596
|
+
end
|
660
597
|
end
|
661
|
-
|
662
|
-
|
663
|
-
|
664
|
-
|
665
|
-
|
666
|
-
|
667
|
-
|
668
|
-
printer.pp(child)
|
598
|
+
else
|
599
|
+
endpoints = flat_list? ? ['', ''] : ["(#{self}", ')']
|
600
|
+
printer.group(1, *endpoints) do
|
601
|
+
for child in self
|
602
|
+
printer.breakable
|
603
|
+
printer.pp(child)
|
604
|
+
end
|
669
605
|
end
|
670
606
|
end
|
671
607
|
end
|
672
608
|
|
673
609
|
end
|
674
610
|
|
675
|
-
|
676
611
|
=begin rdoc ANTLR3::AST::CommonErrorNode
|
677
612
|
|
678
613
|
Represents a series of erroneous tokens from a token stream input
|
@@ -685,7 +620,7 @@ class CommonErrorNode < CommonTree
|
|
685
620
|
|
686
621
|
attr_accessor :input, :start, :stop, :error
|
687
622
|
|
688
|
-
def initialize(input, start, stop, error)
|
623
|
+
def initialize( input, start, stop, error )
|
689
624
|
super(nil)
|
690
625
|
stop = start if stop.nil? or
|
691
626
|
(stop.token_index < start.token_index and stop.type != EOF)
|
@@ -708,9 +643,9 @@ class CommonErrorNode < CommonTree
|
|
708
643
|
when Token
|
709
644
|
i = @start.token_index
|
710
645
|
j = (@stop.type == EOF) ? @input.size : @stop.token_index
|
711
|
-
@input.to_s(i,j) # <- the bad text
|
646
|
+
@input.to_s( i, j ) # <- the bad text
|
712
647
|
when Tree
|
713
|
-
@input.to_s(@start, @stop)
|
648
|
+
@input.to_s( @start, @stop ) # <- the bad text
|
714
649
|
else
|
715
650
|
"<unknown>"
|
716
651
|
end
|
@@ -721,18 +656,18 @@ class CommonErrorNode < CommonTree
|
|
721
656
|
when MissingToken
|
722
657
|
"<missing type: #{@error.missing_type}>"
|
723
658
|
when UnwantedToken
|
724
|
-
"<extraneous: #{@error.token.inspect}, resync = #{
|
659
|
+
"<extraneous: #{@error.token.inspect}, resync = #{ text }>"
|
725
660
|
when MismatchedToken
|
726
|
-
"<mismatched token: #{@error.token.inspect}, resync = #{
|
661
|
+
"<mismatched token: #{@error.token.inspect}, resync = #{ text }>"
|
727
662
|
when NoViableAlternative
|
728
|
-
"<unexpected: #{@error.token.inspect}, resync = #{
|
729
|
-
else "<error: #{text}>"
|
663
|
+
"<unexpected: #{@error.token.inspect}, resync = #{ text }>"
|
664
|
+
else "<error: #{ text }>"
|
730
665
|
end
|
731
666
|
end
|
732
667
|
|
733
668
|
end
|
734
669
|
|
735
|
-
Constants::INVALID_NODE = CommonTree.new(ANTLR3::INVALID_TOKEN)
|
670
|
+
Constants::INVALID_NODE = CommonTree.new( ANTLR3::INVALID_TOKEN )
|
736
671
|
|
737
672
|
####################################################################################################
|
738
673
|
########################################### Tree Adaptors ##########################################
|
@@ -762,127 +697,135 @@ module TreeAdaptor
|
|
762
697
|
include TokenFactory
|
763
698
|
include Constants
|
764
699
|
|
765
|
-
def add_child(tree, child)
|
766
|
-
tree.add_child(child) if tree and child
|
700
|
+
def add_child( tree, child )
|
701
|
+
tree.add_child( child ) if tree and child
|
767
702
|
end
|
768
703
|
|
769
|
-
def child_count(tree)
|
704
|
+
def child_count( tree )
|
770
705
|
tree.child_count
|
771
706
|
end
|
772
707
|
|
773
|
-
def child_index(tree)
|
708
|
+
def child_index( tree )
|
774
709
|
tree.child_index rescue 0
|
775
710
|
end
|
776
711
|
|
777
|
-
def child_of(tree, index)
|
778
|
-
tree.nil? ? nil : tree.child(index)
|
712
|
+
def child_of( tree, index )
|
713
|
+
tree.nil? ? nil : tree.child( index )
|
779
714
|
end
|
780
715
|
|
781
|
-
def copy_node(tree_node)
|
782
|
-
tree_node
|
716
|
+
def copy_node( tree_node )
|
717
|
+
tree_node and tree_node.dup
|
783
718
|
end
|
784
719
|
|
785
|
-
def copy_tree(tree, parent = nil)
|
720
|
+
def copy_tree( tree, parent = nil )
|
786
721
|
tree or return nil
|
787
|
-
new_tree = copy_node(tree)
|
788
|
-
set_child_index(new_tree, child_index(tree))
|
789
|
-
set_parent(new_tree, parent)
|
790
|
-
each_child(tree) do |child|
|
791
|
-
new_sub_tree = copy_tree(child,
|
792
|
-
add_child(new_tree, new_sub_tree)
|
722
|
+
new_tree = copy_node( tree )
|
723
|
+
set_child_index( new_tree, child_index( tree ) )
|
724
|
+
set_parent( new_tree, parent )
|
725
|
+
each_child( tree ) do | child |
|
726
|
+
new_sub_tree = copy_tree( child, new_tree )
|
727
|
+
add_child( new_tree, new_sub_tree )
|
793
728
|
end
|
794
729
|
return new_tree
|
795
730
|
end
|
796
731
|
|
797
|
-
def delete_child(tree, index)
|
798
|
-
tree.delete_child(index)
|
732
|
+
def delete_child( tree, index )
|
733
|
+
tree.delete_child( index )
|
799
734
|
end
|
800
735
|
|
801
|
-
|
802
|
-
|
803
|
-
|
804
|
-
|
805
|
-
|
806
|
-
yield child_of(tree, i)
|
807
|
-
i += 1
|
736
|
+
|
737
|
+
def each_child( tree )
|
738
|
+
block_given? or return enum_for( :each_child, tree )
|
739
|
+
for i in 0 ... child_count( tree )
|
740
|
+
yield( child_of( tree, i ) )
|
808
741
|
end
|
742
|
+
return tree
|
809
743
|
end
|
810
744
|
|
811
|
-
def
|
745
|
+
def each_ancestor( tree, include_tree = true )
|
746
|
+
block_given? or return enum_for( :each_ancestor, tree, include_tree )
|
747
|
+
if include_tree
|
748
|
+
begin yield( tree ) end while tree = parent_of( tree )
|
749
|
+
else
|
750
|
+
while tree = parent_of( tree ) do yield( tree ) end
|
751
|
+
end
|
752
|
+
end
|
753
|
+
|
754
|
+
def flat_list?( tree )
|
812
755
|
tree.flat_list?
|
813
756
|
end
|
814
|
-
|
815
|
-
def
|
757
|
+
|
758
|
+
def empty?( tree )
|
759
|
+
child_count( tree ).zero?
|
760
|
+
end
|
761
|
+
|
762
|
+
def parent( tree )
|
816
763
|
tree.parent
|
817
764
|
end
|
818
765
|
|
819
|
-
def replace_children(parent,
|
820
|
-
parent.
|
821
|
-
parent.replace_children(start_index, stop_index, replacement_tree)
|
766
|
+
def replace_children( parent, start, stop, replacement )
|
767
|
+
parent and parent.replace_children( start, stop, replacement )
|
822
768
|
end
|
823
769
|
|
824
|
-
def rule_post_processing(root)
|
770
|
+
def rule_post_processing( root )
|
825
771
|
if root and root.flat_list?
|
826
772
|
case root.child_count
|
827
773
|
when 0 then root = nil
|
828
774
|
when 1
|
829
|
-
root = root.child(0)
|
830
|
-
root.parent = nil
|
831
|
-
root.child_index = -1
|
775
|
+
root = root.child( 0 ).detach
|
832
776
|
end
|
833
777
|
end
|
834
778
|
return root
|
835
779
|
end
|
836
780
|
|
837
|
-
def set_child_index(tree, index)
|
781
|
+
def set_child_index( tree, index )
|
838
782
|
tree.child_index = index
|
839
783
|
end
|
840
784
|
|
841
|
-
def set_parent(tree, parent)
|
785
|
+
def set_parent( tree, parent )
|
842
786
|
tree.parent = parent
|
843
787
|
end
|
844
788
|
|
845
|
-
def set_token_boundaries(tree, start_token = nil, stop_token = nil)
|
846
|
-
return
|
789
|
+
def set_token_boundaries( tree, start_token = nil, stop_token = nil )
|
790
|
+
return unless tree
|
847
791
|
start = stop = 0
|
848
|
-
start = start_token.index
|
849
|
-
stop
|
850
|
-
tree.
|
851
|
-
tree.
|
792
|
+
start_token and start = start_token.index
|
793
|
+
stop_token and stop = stop_token.index
|
794
|
+
tree.start_index = start
|
795
|
+
tree.stop_index = stop
|
852
796
|
return tree
|
853
797
|
end
|
854
798
|
|
855
|
-
def text_of(tree)
|
799
|
+
def text_of( tree )
|
856
800
|
tree.text rescue nil
|
857
801
|
end
|
858
802
|
|
859
|
-
def token(tree)
|
860
|
-
|
803
|
+
def token( tree )
|
804
|
+
CommonTree === tree ? tree.token : nil
|
861
805
|
end
|
862
806
|
|
863
|
-
def token_start_index(tree)
|
864
|
-
tree
|
807
|
+
def token_start_index( tree )
|
808
|
+
tree ? tree.token_start_index : -1
|
865
809
|
end
|
866
810
|
|
867
|
-
def token_stop_index(tree)
|
868
|
-
tree
|
811
|
+
def token_stop_index( tree )
|
812
|
+
tree ? tree.token_stop_index : -1
|
869
813
|
end
|
870
814
|
|
871
|
-
def type_name(tree)
|
872
|
-
tree.
|
815
|
+
def type_name( tree )
|
816
|
+
tree.name rescue 'INVALID'
|
873
817
|
end
|
874
818
|
|
875
|
-
def type_of(tree)
|
876
|
-
tree.
|
819
|
+
def type_of( tree )
|
820
|
+
tree.type rescue INVALID_TOKEN_TYPE
|
877
821
|
end
|
878
822
|
|
879
|
-
def unique_id(node)
|
823
|
+
def unique_id( node )
|
880
824
|
node.hash
|
881
825
|
end
|
826
|
+
|
882
827
|
end
|
883
828
|
|
884
|
-
|
885
|
-
|
886
829
|
=begin rdoc ANTLR3::AST::CommonTreeAdaptor
|
887
830
|
|
888
831
|
The default tree adaptor used by ANTLR-generated tree code. It, of course,
|
@@ -894,65 +837,85 @@ class CommonTreeAdaptor
|
|
894
837
|
include TreeAdaptor
|
895
838
|
include ANTLR3::Constants
|
896
839
|
|
897
|
-
def initialize(token_class = ANTLR3::CommonToken)
|
840
|
+
def initialize( token_class = ANTLR3::CommonToken )
|
898
841
|
@token_class = token_class
|
899
842
|
end
|
900
843
|
|
901
844
|
def create_flat_list!
|
902
|
-
return self.create_with_payload!(nil)
|
845
|
+
return self.create_with_payload!( nil )
|
903
846
|
end
|
904
847
|
|
905
|
-
def become_root(new_root, old_root)
|
906
|
-
new_root = create!(new_root) if new_root.is_a?(Token)
|
907
|
-
old_root
|
848
|
+
def become_root( new_root, old_root )
|
849
|
+
new_root = create!( new_root ) if new_root.is_a?( Token )
|
850
|
+
old_root or return( new_root )
|
908
851
|
|
909
|
-
new_root = create_with_payload!(new_root) unless new_root
|
852
|
+
new_root = create_with_payload!( new_root ) unless CommonTree === new_root
|
910
853
|
if new_root.flat_list?
|
911
854
|
count = new_root.child_count
|
912
855
|
if count == 1
|
913
|
-
new_root = new_root.child(0)
|
856
|
+
new_root = new_root.child( 0 )
|
914
857
|
elsif count > 1
|
915
858
|
raise TreeInconsistency.multiple_roots!
|
916
859
|
end
|
917
860
|
end
|
918
861
|
|
919
|
-
new_root.add_child(old_root)
|
862
|
+
new_root.add_child( old_root )
|
920
863
|
return new_root
|
921
864
|
end
|
922
865
|
|
923
|
-
def create_from_token!(token_type, from_token, text = nil)
|
924
|
-
from_token = from_token.
|
866
|
+
def create_from_token!( token_type, from_token, text = nil )
|
867
|
+
from_token = from_token.dup
|
925
868
|
from_token.type = token_type
|
926
|
-
from_token.text = text
|
927
|
-
tree = create_with_payload!(from_token)
|
869
|
+
from_token.text = text.to_s if text
|
870
|
+
tree = create_with_payload!( from_token )
|
928
871
|
return tree
|
929
872
|
end
|
930
873
|
|
931
|
-
def create_from_type!(token_type, text)
|
932
|
-
from_token = create_token(token_type, DEFAULT_CHANNEL, text)
|
933
|
-
create_with_payload!(from_token)
|
874
|
+
def create_from_type!( token_type, text )
|
875
|
+
from_token = create_token( token_type, DEFAULT_CHANNEL, text )
|
876
|
+
create_with_payload!( from_token )
|
934
877
|
end
|
935
878
|
|
936
|
-
def create_error_node!(input, start, stop, exc)
|
937
|
-
CommonErrorNode.new(input, start, stop, exc)
|
879
|
+
def create_error_node!( input, start, stop, exc )
|
880
|
+
CommonErrorNode.new( input, start, stop, exc )
|
938
881
|
end
|
939
882
|
|
940
|
-
def create_with_payload!(payload)
|
941
|
-
return CommonTree.new(payload)
|
883
|
+
def create_with_payload!( payload )
|
884
|
+
return CommonTree.new( payload )
|
942
885
|
end
|
943
|
-
|
944
|
-
def create!(*args)
|
886
|
+
def create!( *args )
|
945
887
|
n = args.length
|
946
|
-
if n == 1 and args.first.is_a?(Token) then create_with_payload!(args[0])
|
947
|
-
elsif n
|
948
|
-
create_from_token!(*args)
|
949
|
-
elsif n == 2 and args[0].is_a?(Integer) and args[1].is_a?(String)
|
888
|
+
if n == 1 and args.first.is_a?( Token ) then create_with_payload!( args[0] )
|
889
|
+
elsif n == 2 and Integer === args.first and String === args[1]
|
950
890
|
create_from_type!(*args)
|
891
|
+
elsif n >= 2 and Integer === args.first
|
892
|
+
create_from_token!( *args )
|
951
893
|
else
|
952
894
|
sig = args.map { |f| f.class }.join(', ')
|
953
|
-
raise TypeError, "No create method with this signature found: (#{sig})"
|
895
|
+
raise TypeError, "No create method with this signature found: (#{ sig })"
|
896
|
+
end
|
897
|
+
end
|
898
|
+
|
899
|
+
def rule_post_processing( root )
|
900
|
+
if root and root.flat_list?
|
901
|
+
if root.empty? then root = nil
|
902
|
+
elsif root.child_count == 1 then root = root.first.detach
|
903
|
+
end
|
954
904
|
end
|
955
|
-
|
905
|
+
return root
|
906
|
+
end
|
907
|
+
|
908
|
+
def empty?( tree )
|
909
|
+
tree.empty?
|
910
|
+
end
|
911
|
+
|
912
|
+
def each_child( tree )
|
913
|
+
block_given? or return enum_for( __method__, tree )
|
914
|
+
tree.each do | child |
|
915
|
+
yield( child )
|
916
|
+
end
|
917
|
+
end
|
918
|
+
|
956
919
|
end
|
957
920
|
|
958
921
|
|
@@ -1011,82 +974,91 @@ objects. CommonTreeNodeStreams are the default input streams for tree parsers.
|
|
1011
974
|
class CommonTreeNodeStream
|
1012
975
|
include TreeNodeStream
|
1013
976
|
|
977
|
+
attr_accessor :token_stream
|
978
|
+
attr_reader :adaptor, :position
|
979
|
+
|
1014
980
|
def initialize(*args)
|
1015
|
-
|
1016
|
-
case args.length
|
981
|
+
case n = args.length
|
1017
982
|
when 1
|
1018
|
-
adaptor = CommonTreeAdaptor.new
|
1019
|
-
|
983
|
+
@adaptor = CommonTreeAdaptor.new
|
984
|
+
@root = args.first
|
1020
985
|
@nodes = @down = @up = @eof = nil
|
1021
986
|
when 2
|
1022
|
-
adaptor,
|
987
|
+
@adaptor, @root = args
|
1023
988
|
@nodes = @down = @up = @eof = nil
|
1024
989
|
when 3
|
1025
990
|
parent, start, stop = *args
|
1026
|
-
adaptor = parent.adaptor
|
1027
|
-
|
1028
|
-
@nodes = parent.nodes[start...stop]
|
991
|
+
@adaptor = parent.adaptor
|
992
|
+
@root = parent.root
|
993
|
+
@nodes = parent.nodes[ start ... stop ]
|
1029
994
|
@down = parent.down
|
1030
995
|
@up = parent.up
|
1031
996
|
@eof = parent.eof
|
1032
|
-
|
997
|
+
when 0
|
998
|
+
raise ArgumentError, "wrong number of arguments (0 for 1)"
|
999
|
+
else raise ArgumentError, "wrong number of arguments (#{ n } for 3)"
|
1033
1000
|
end
|
1034
|
-
@down ||= adaptor.create_from_type!(DOWN, 'DOWN')
|
1035
|
-
@up ||= adaptor.create_from_type!(UP, 'UP')
|
1036
|
-
@eof ||= adaptor.create_from_type!(EOF, 'EOF')
|
1001
|
+
@down ||= @adaptor.create_from_type!( DOWN, 'DOWN' )
|
1002
|
+
@up ||= @adaptor.create_from_type!( UP, 'UP' )
|
1003
|
+
@eof ||= @adaptor.create_from_type!( EOF, 'EOF' )
|
1037
1004
|
@nodes ||= []
|
1038
|
-
@
|
1039
|
-
|
1040
|
-
@adaptor = adaptor
|
1005
|
+
@token_stream = nil
|
1006
|
+
|
1041
1007
|
@unique_navigation_nodes = false
|
1042
1008
|
@position = -1
|
1043
1009
|
@last_marker = nil
|
1044
1010
|
@calls = []
|
1045
1011
|
end
|
1046
1012
|
|
1047
|
-
def fill_buffer
|
1048
|
-
|
1049
|
-
@
|
1013
|
+
def fill_buffer( tree = @root )
|
1014
|
+
@nodes << tree unless nil_tree = @adaptor.flat_list?( tree )
|
1015
|
+
unless @adaptor.empty?( tree )
|
1016
|
+
add_navigation_node( DOWN ) unless nil_tree
|
1017
|
+
@adaptor.each_child( tree ) { | c | fill_buffer( c ) }
|
1018
|
+
add_navigation_node( UP ) unless nil_tree
|
1019
|
+
end
|
1020
|
+
@position = 0 if tree == @root
|
1021
|
+
return( self )
|
1050
1022
|
end
|
1051
1023
|
|
1052
|
-
def node_index(node)
|
1024
|
+
def node_index( node )
|
1053
1025
|
@position == -1 and fill_buffer
|
1054
|
-
return @nodes.index(node)
|
1026
|
+
return @nodes.index( node )
|
1055
1027
|
end
|
1056
1028
|
|
1057
|
-
def add_navigation_node(type)
|
1029
|
+
def add_navigation_node( type )
|
1058
1030
|
navigation_node =
|
1059
1031
|
case type
|
1060
1032
|
when DOWN
|
1061
|
-
has_unique_navigation_nodes? ? @adaptor.create_from_type!(DOWN, 'DOWN') : @down
|
1033
|
+
has_unique_navigation_nodes? ? @adaptor.create_from_type!( DOWN, 'DOWN' ) : @down
|
1062
1034
|
else
|
1063
|
-
has_unique_navigation_nodes? ? @adaptor.create_from_type!(UP, 'UP') : @up
|
1035
|
+
has_unique_navigation_nodes? ? @adaptor.create_from_type!( UP, 'UP' ) : @up
|
1064
1036
|
end
|
1065
1037
|
@nodes << navigation_node
|
1066
1038
|
end
|
1067
1039
|
|
1068
|
-
def at(index)
|
1040
|
+
def at( index )
|
1069
1041
|
@position == -1 and fill_buffer
|
1070
|
-
@nodes
|
1042
|
+
@nodes.at( index )
|
1071
1043
|
end
|
1072
1044
|
|
1073
|
-
def look(k = 1)
|
1045
|
+
def look( k = 1 )
|
1074
1046
|
@position == -1 and fill_buffer
|
1075
1047
|
k == 0 and return nil
|
1076
|
-
k < 0 and return self.
|
1048
|
+
k < 0 and return self.look_behind( -k )
|
1077
1049
|
|
1078
1050
|
absolute = @position + k - 1
|
1079
|
-
|
1051
|
+
@nodes.fetch( absolute, @eof )
|
1080
1052
|
end
|
1081
1053
|
|
1082
1054
|
def current_symbol
|
1083
1055
|
look
|
1084
1056
|
end
|
1085
1057
|
|
1086
|
-
def
|
1058
|
+
def look_behind( k = 1 )
|
1087
1059
|
k == 0 and return nil
|
1088
1060
|
absolute = @position - k
|
1089
|
-
return(
|
1061
|
+
return( absolute < 0 ? nil : @nodes.fetch( absolute, @eof ) )
|
1090
1062
|
end
|
1091
1063
|
|
1092
1064
|
def tree_source
|
@@ -1097,14 +1069,6 @@ class CommonTreeNodeStream
|
|
1097
1069
|
self.token_stream.source_name
|
1098
1070
|
end
|
1099
1071
|
|
1100
|
-
def token_stream
|
1101
|
-
@tokens
|
1102
|
-
end
|
1103
|
-
|
1104
|
-
def token_stream=(tokens)
|
1105
|
-
@tokens = tokens
|
1106
|
-
end
|
1107
|
-
|
1108
1072
|
def tree_adaptor
|
1109
1073
|
@adaptor
|
1110
1074
|
end
|
@@ -1119,8 +1083,8 @@ class CommonTreeNodeStream
|
|
1119
1083
|
@position += 1
|
1120
1084
|
end
|
1121
1085
|
|
1122
|
-
def peek(i = 1)
|
1123
|
-
@adaptor.type_of
|
1086
|
+
def peek( i = 1 )
|
1087
|
+
@adaptor.type_of look( i )
|
1124
1088
|
end
|
1125
1089
|
|
1126
1090
|
alias >> peek
|
@@ -1130,35 +1094,33 @@ class CommonTreeNodeStream
|
|
1130
1094
|
|
1131
1095
|
def mark
|
1132
1096
|
@position == -1 and fill_buffer
|
1133
|
-
@last_marker =
|
1097
|
+
@last_marker = @position
|
1134
1098
|
return @last_marker
|
1135
1099
|
end
|
1136
1100
|
|
1137
|
-
def release(marker = nil)
|
1101
|
+
def release( marker = nil )
|
1138
1102
|
# do nothing?
|
1139
1103
|
end
|
1140
1104
|
|
1141
|
-
|
1142
|
-
@position
|
1143
|
-
end
|
1105
|
+
alias index position
|
1144
1106
|
|
1145
|
-
def rewind(marker = @last_marker, release = true)
|
1146
|
-
seek(marker)
|
1107
|
+
def rewind( marker = @last_marker, release = true )
|
1108
|
+
seek( marker )
|
1147
1109
|
end
|
1148
1110
|
|
1149
|
-
def seek(index)
|
1111
|
+
def seek( index )
|
1150
1112
|
@position == -1 and fill_buffer
|
1151
1113
|
@position = index
|
1152
1114
|
end
|
1153
1115
|
|
1154
|
-
def push(index)
|
1116
|
+
def push( index )
|
1155
1117
|
@calls << @position
|
1156
|
-
seek(index)
|
1118
|
+
seek( index )
|
1157
1119
|
end
|
1158
1120
|
|
1159
1121
|
def pop
|
1160
|
-
|
1161
|
-
return
|
1122
|
+
pos = @calls.pop and seek( pos )
|
1123
|
+
return pos
|
1162
1124
|
end
|
1163
1125
|
|
1164
1126
|
def reset
|
@@ -1167,10 +1129,8 @@ class CommonTreeNodeStream
|
|
1167
1129
|
@calls = []
|
1168
1130
|
end
|
1169
1131
|
|
1170
|
-
def replace_children(parent,
|
1171
|
-
parent.
|
1172
|
-
@adaptor.replace_children(parent, start_index,
|
1173
|
-
stop_index, replacement_tree)
|
1132
|
+
def replace_children( parent, start, stop, replacement )
|
1133
|
+
parent and @adaptor.replace_children(parent, start, stop, replacement)
|
1174
1134
|
end
|
1175
1135
|
|
1176
1136
|
def size
|
@@ -1180,45 +1140,38 @@ class CommonTreeNodeStream
|
|
1180
1140
|
|
1181
1141
|
def inspect
|
1182
1142
|
@position == -1 and fill_buffer
|
1183
|
-
@nodes.map { |nd| @adaptor.
|
1143
|
+
@nodes.map { |nd| @adaptor.type_name( nd ) }.join(' ')
|
1184
1144
|
end
|
1185
1145
|
|
1186
|
-
def
|
1146
|
+
def extract_text( start = nil, stop = nil )
|
1187
1147
|
start.nil? || stop.nil? and return nil
|
1188
1148
|
@position == -1 and fill_buffer
|
1189
1149
|
|
1190
|
-
|
1191
|
-
|
1192
|
-
|
1193
|
-
|
1194
|
-
|
1195
|
-
|
1196
|
-
|
1197
|
-
|
1198
|
-
|
1199
|
-
return @tokens.to_string(begin_token_index, end_token_index)
|
1150
|
+
if @token_stream
|
1151
|
+
from = @adaptor.token_start_index( start )
|
1152
|
+
to =
|
1153
|
+
case @adaptor.type_of( stop )
|
1154
|
+
when UP then @adaptor.token_stop_index( start )
|
1155
|
+
when EOF then to = @nodes.length - 2
|
1156
|
+
else @adaptor.token_stop_index( stop )
|
1157
|
+
end
|
1158
|
+
return @token_stream.extract_text( from, to )
|
1200
1159
|
end
|
1201
1160
|
|
1202
|
-
|
1203
|
-
|
1204
|
-
|
1205
|
-
|
1206
|
-
|
1207
|
-
buffer << text
|
1208
|
-
ind += 1
|
1209
|
-
t = @nodes[ind]
|
1161
|
+
buffer = ''
|
1162
|
+
for node in @nodes
|
1163
|
+
if node == start ... node == stop # <-- hey look, it's the flip flop operator
|
1164
|
+
buffer << @adaptor.text_of( node ) #|| ' ' << @adaptor.type_of( node ).to_s )
|
1165
|
+
end
|
1210
1166
|
end
|
1211
|
-
|
1212
|
-
text = (@adaptor.text_of(stop) || ' ' << @adaptor.type_of(stop).to_s)
|
1213
|
-
buffer << text
|
1214
|
-
|
1215
|
-
return buffer,join
|
1167
|
+
return( buffer )
|
1216
1168
|
end
|
1217
1169
|
|
1218
1170
|
def each
|
1219
1171
|
@position == -1 and fill_buffer
|
1220
|
-
block_given? or return enum_for(:each)
|
1221
|
-
@nodes
|
1172
|
+
block_given? or return enum_for( :each )
|
1173
|
+
for node in @nodes do yield( node ) end
|
1174
|
+
self
|
1222
1175
|
end
|
1223
1176
|
|
1224
1177
|
include Enumerable
|
@@ -1227,29 +1180,15 @@ class CommonTreeNodeStream
|
|
1227
1180
|
return @nodes.dup
|
1228
1181
|
end
|
1229
1182
|
|
1230
|
-
|
1231
|
-
|
1232
|
-
|
1233
|
-
@
|
1234
|
-
|
1235
|
-
|
1236
|
-
|
1237
|
-
|
1238
|
-
|
1239
|
-
def __fill_buffer__(tree)
|
1240
|
-
nil_tree = @adaptor.flat_list?(tree)
|
1241
|
-
unless nil_tree
|
1242
|
-
@nodes << tree
|
1243
|
-
end
|
1244
|
-
|
1245
|
-
n = @adaptor.child_count(tree)
|
1246
|
-
add_navigation_node(DOWN) if not nil_tree and n > 0
|
1247
|
-
|
1248
|
-
n.times { |c| __fill_buffer__ @adaptor.child_of(tree, c) }
|
1249
|
-
|
1250
|
-
add_navigation_node(UP) if not nil_tree and n > 0
|
1251
|
-
end
|
1252
|
-
|
1183
|
+
#private
|
1184
|
+
#
|
1185
|
+
# def linear_node_index( node )
|
1186
|
+
# @position == -1 and fill_buffer
|
1187
|
+
# @nodes.each_with_index do |n, i|
|
1188
|
+
# node == n and return(i)
|
1189
|
+
# end
|
1190
|
+
# return -1
|
1191
|
+
# end
|
1253
1192
|
end
|
1254
1193
|
|
1255
1194
|
=begin rdoc ANTLR3::AST::RewriteRuleElementStream
|
@@ -1259,22 +1198,21 @@ rewriting parsers.
|
|
1259
1198
|
|
1260
1199
|
=end
|
1261
1200
|
|
1262
|
-
class RewriteRuleElementStream
|
1201
|
+
class RewriteRuleElementStream # < Array
|
1263
1202
|
extend ClassMacros
|
1264
1203
|
include Error
|
1265
1204
|
|
1266
|
-
def initialize(adaptor, element_description, elements = nil)
|
1205
|
+
def initialize( adaptor, element_description, elements = nil )
|
1267
1206
|
@cursor = 0
|
1268
1207
|
@single_element = nil
|
1269
1208
|
@elements = nil
|
1270
1209
|
@dirty = false
|
1271
1210
|
@element_description = element_description
|
1272
1211
|
@adaptor = adaptor
|
1273
|
-
if elements.
|
1274
|
-
@single_element = nil
|
1212
|
+
if elements.instance_of?( Array )
|
1275
1213
|
@elements = elements
|
1276
1214
|
else
|
1277
|
-
add(elements)
|
1215
|
+
add( elements )
|
1278
1216
|
end
|
1279
1217
|
end
|
1280
1218
|
|
@@ -1283,38 +1221,35 @@ class RewriteRuleElementStream
|
|
1283
1221
|
@dirty = true
|
1284
1222
|
end
|
1285
1223
|
|
1286
|
-
def add(el)
|
1287
|
-
return(nil) unless el
|
1288
|
-
|
1289
|
-
|
1290
|
-
|
1291
|
-
|
1292
|
-
|
1293
|
-
@
|
1294
|
-
|
1224
|
+
def add( el )
|
1225
|
+
return( nil ) unless el
|
1226
|
+
case
|
1227
|
+
when ! el then return( nil )
|
1228
|
+
when @elements then @elements << el
|
1229
|
+
when @single_element.nil? then @single_element = el
|
1230
|
+
else
|
1231
|
+
@elements = [ @single_element, el ]
|
1232
|
+
@single_element = nil
|
1233
|
+
return( @elements )
|
1295
1234
|
end
|
1296
|
-
@elements = [@single_element, el]
|
1297
|
-
@single_element = nil
|
1298
|
-
return(@elements)
|
1299
1235
|
end
|
1300
1236
|
|
1301
1237
|
def next_tree
|
1302
|
-
if @dirty or
|
1303
|
-
|
1304
|
-
return self.dup(el)
|
1238
|
+
if @dirty or @cursor >= length && length == 1
|
1239
|
+
return dup( __next__ )
|
1305
1240
|
end
|
1306
|
-
|
1307
|
-
return el
|
1241
|
+
__next__
|
1308
1242
|
end
|
1309
1243
|
|
1310
1244
|
abstract :dup
|
1311
1245
|
|
1312
|
-
def to_tree(el)
|
1246
|
+
def to_tree( el )
|
1313
1247
|
return el
|
1314
1248
|
end
|
1315
1249
|
|
1316
1250
|
def has_next?
|
1317
|
-
return(
|
1251
|
+
return( @single_element && @cursor < 1 or
|
1252
|
+
@elements && @cursor < @elements.length )
|
1318
1253
|
end
|
1319
1254
|
|
1320
1255
|
def size
|
@@ -1322,24 +1257,27 @@ class RewriteRuleElementStream
|
|
1322
1257
|
@elements and return @elements.length
|
1323
1258
|
return 0
|
1324
1259
|
end
|
1260
|
+
|
1325
1261
|
alias length size
|
1326
1262
|
|
1327
|
-
|
1263
|
+
private
|
1264
|
+
|
1328
1265
|
def __next__
|
1329
|
-
|
1330
|
-
|
1331
|
-
|
1332
|
-
|
1333
|
-
|
1334
|
-
|
1335
|
-
|
1336
|
-
|
1266
|
+
l = length
|
1267
|
+
case
|
1268
|
+
when l.zero?
|
1269
|
+
raise Error::RewriteEmptyStream.new( @element_description )
|
1270
|
+
when @cursor >= l
|
1271
|
+
l == 1 and return to_tree( @single_element )
|
1272
|
+
raise RewriteCardinalityError.new( @element_description )
|
1273
|
+
when @single_element
|
1274
|
+
@cursor += 1
|
1275
|
+
return( to_tree( @single_element ) )
|
1276
|
+
else
|
1277
|
+
out = to_tree( @elements.at( @cursor ) )
|
1337
1278
|
@cursor += 1
|
1338
|
-
return
|
1279
|
+
return( out )
|
1339
1280
|
end
|
1340
|
-
out = self.to_tree(@elements[@cursor])
|
1341
|
-
@cursor += 1
|
1342
|
-
return out
|
1343
1281
|
end
|
1344
1282
|
end
|
1345
1283
|
|
@@ -1351,20 +1289,14 @@ rewriting parsers.
|
|
1351
1289
|
|
1352
1290
|
=end
|
1353
1291
|
class RewriteRuleTokenStream < RewriteRuleElementStream
|
1354
|
-
def to_tree(el)
|
1355
|
-
return el
|
1356
|
-
end
|
1357
|
-
|
1358
1292
|
def next_node
|
1359
|
-
|
1360
|
-
return @adaptor.create_with_payload!(t)
|
1293
|
+
return @adaptor.create_with_payload!( __next__ )
|
1361
1294
|
end
|
1362
1295
|
|
1363
|
-
|
1364
|
-
|
1365
|
-
end
|
1296
|
+
alias :next :__next__
|
1297
|
+
public :next
|
1366
1298
|
|
1367
|
-
def dup(el)
|
1299
|
+
def dup( el )
|
1368
1300
|
raise TypeError, "dup can't be called for a token stream"
|
1369
1301
|
end
|
1370
1302
|
end
|
@@ -1378,16 +1310,14 @@ rewriting parsers.
|
|
1378
1310
|
|
1379
1311
|
class RewriteRuleSubtreeStream < RewriteRuleElementStream
|
1380
1312
|
def next_node
|
1381
|
-
if @dirty or
|
1382
|
-
|
1383
|
-
return @adaptor.copy_node(el)
|
1313
|
+
if @dirty or @cursor >= length && length == 1
|
1314
|
+
return @adaptor.copy_node( __next__ )
|
1384
1315
|
end
|
1385
|
-
|
1386
|
-
return el
|
1316
|
+
return __next__
|
1387
1317
|
end
|
1388
1318
|
|
1389
|
-
def dup(el)
|
1390
|
-
@adaptor.copy_tree(el)
|
1319
|
+
def dup( el )
|
1320
|
+
@adaptor.copy_tree( el )
|
1391
1321
|
end
|
1392
1322
|
end
|
1393
1323
|
|
@@ -1399,13 +1329,13 @@ rewriting parsers.
|
|
1399
1329
|
=end
|
1400
1330
|
|
1401
1331
|
class RewriteRuleNodeStream < RewriteRuleElementStream
|
1402
|
-
|
1403
|
-
|
1332
|
+
alias next_node __next__
|
1333
|
+
public :next_node
|
1334
|
+
def to_tree( el )
|
1335
|
+
@adaptor.copy_node( el )
|
1404
1336
|
end
|
1405
|
-
|
1406
|
-
|
1407
|
-
end
|
1408
|
-
def dup(el)
|
1337
|
+
|
1338
|
+
def dup( el )
|
1409
1339
|
raise TypeError, "dup can't be called for a node stream"
|
1410
1340
|
end
|
1411
1341
|
end
|