Class: Antlr4ruby::Trees

Inherits:
Object
  • Object
show all
Defined in:
lib/antlr4ruby/tree/trees.rb

Class Method Summary collapse

Class Method Details

._find_all_nodes(t, index, find_tokens, nodes) ⇒ Object 



78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/antlr4ruby/tree/trees.rb', line 78

def _find_all_nodes(t, index, find_tokens, nodes)
  if find_tokens && t.instance_of?(TerminalNode)
    nodes.push(t) if t.get_symbol.get_type == index
  elsif !find_tokens && t.instance_of?(ParserRuleContext)
    nodes.push(t) if t.get_rule_index == index
  end

  t.get_child_count.times do |i|
    child = t.get_child(i)
    _find_all_nodes(child, index, find_tokens, nodes) if child
  end
end

.find_all_nodes(t, index, find_tokens) ⇒ Object 



72
73
74
75
76
 
# File 'lib/antlr4ruby/tree/trees.rb', line 72

def find_all_nodes(t, index, find_tokens)
  nodes = []
  _find_all_nodes(t, index, find_tokens, nodes)
  nodes
end

.find_all_rule_nodes(t, rule_index) ⇒ Object 



68
69
70
 
# File 'lib/antlr4ruby/tree/trees.rb', line 68

def find_all_rule_nodes(t, rule_index)
  find_all_nodes(t, rule_index, false)
end

.find_all_token_nodes(t, token_type) ⇒ Object 



64
65
66
 
# File 'lib/antlr4ruby/tree/trees.rb', line 64

def find_all_token_nodes(t, token_type)
  find_all_nodes(t, token_type, true)
end

.find_node_such_that(t, pred) ⇒ Object 



135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
 
# File 'lib/antlr4ruby/tree/trees.rb', line 135

def find_node_such_that(t, pred)
  if pred.test(t)
    return t
  end

  unless t
    return nil
  end

  n = t.get_child_count
  n.times do |i|
    u = find_node_such_that(t.get_child(i), pred)
    if u
      return u
    end
  end
  nil

end

.get_ancestors(tree) ⇒ Object 



43
44
45
46
47
48
49
50
51
52
 
# File 'lib/antlr4ruby/tree/trees.rb', line 43

def get_ancestors(tree)
  return [] if tree.get_parent == nil
  ancestors = []
  tree = tree.get_parent
  while tree
    ancestors.push(tree)
    tree = tree.get_parent
  end
  ancestors
end

.get_children(tree) ⇒ Object 



35
36
37
38
39
40
41
 
# File 'lib/antlr4ruby/tree/trees.rb', line 35

def get_children(tree)
  kids = []
  tree.get_child_count.times do |i|
    kids.push(tree.get_child(i))
  end
  kids
end

.get_descendants(t) ⇒ Object 



91
92
93
94
95
96
97
98
99
 
# File 'lib/antlr4ruby/tree/trees.rb', line 91

def get_descendants(t)
  nodes = [t]
  n = t.get_child_count
  n.times do |i|
    child = t.get_child(i)
    nodes.push(*get_descendants(child)) if child
  end
  nodes
end

.get_node_text(tree, recognizer: nil, rule_names: []) ⇒ Object 



20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/antlr4ruby/tree/trees.rb', line 20

def get_node_text(tree, recognizer: nil, rule_names: [])

  rule_names = recognizer.get_rule_names if recognizer
  if tree.instance_of?(RuleContext)
    rule_index = tree.get_rule_context.get_rule_index
    return rule_names[rule_index]
  elsif tree.instance_of?(ErrorNode)
    return tree.to_s
  elsif tree.instance_of?(TerminalNode)
    symbol = tree.get_symbol
    return symbol.get_text if symbol
  end
  tree.get_payload.to_s
end

.get_root_of_subtree_enclosing_region(t, start_token_index, stop_token_index) ⇒ Object 



101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
 
# File 'lib/antlr4ruby/tree/trees.rb', line 101

def get_root_of_subtree_enclosing_region(t, start_token_index, stop_token_index)
  n = t.get_child_count
  n.times do |i|
    child = t.get_child(i)
    if child
      r = get_root_of_subtree_enclosing_region(child, start_token_index, stop_token_index)
      return r if r
    end

  end
  if t.instance_of?(ParserRuleContext)
    return t if start_token_index >= t.get_start.get_token_index && (t.get_stop == nil || stop_token_index <= t.get_stop.get_token_index)
  end
  nil
end

.is_ancestor_of?(t, u) ⇒ Boolean

Returns:

  • (Boolean) 


54
55
56
57
58
59
60
61
62
 
# File 'lib/antlr4ruby/tree/trees.rb', line 54

def is_ancestor_of?(t, u)
  return false if t == nil || u == nil || t.get_parent == nil
  p = u.get_parent
  while p
    return true if t.equal?(p)
    p = p.get_parent
  end
  false
end

.strip_children_out_of_range(t, root, start_index, stop_index) ⇒ Object 



117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
 
# File 'lib/antlr4ruby/tree/trees.rb', line 117

def strip_children_out_of_range(t, root, start_index, stop_index)
  if t == nil
    return
  end

  t.get_child_count.times do |i|
    child = t.get_child(i, nil )
    if child and child.instance_of?(ParserRuleContext)
      range = child.get_source_interval
      if (range.first < start_index || range.last > stop_index) && is_ancestor_of?(child, root)
        abbrev = CommonToken.new(type: Token::INVALID_TYPE, text: '...')
        t.children[i] = TerminalNode.new(abbrev)
      end
    end

  end
end

.to_string_tree(tree, recognizer: nil, rule_names: []) ⇒ Object 



8
9
10
11
12
13
14
15
16
17
18
 
# File 'lib/antlr4ruby/tree/trees.rb', line 8

def to_string_tree(tree, recognizer: nil, rule_names: [])
  rule_names = recognizer.get_rule_names if recognizer
  # todo 转义处理

  s = get_node_text(tree, rule_names: rule_names)
  return s if tree.get_child_count <= 0
  tree.get_child_count.times do |i|
    child = tree.get_child(i)
    s += ' ' + to_string_tree(child, rule_names: rule_names) if child
  end
  "(#{s})"
end