def ast_to_actions_seq(node, rule_names, file_id, parent_id: int, action_id):
global rules_dict, actions_dict, action_counter, rules_in_files, actions_in_files
rule_name = Trees.getNodeText(node, rule_names)
if rule_name not in rules_dict:
rules_dict[rule_name] = (len(rules_dict), 1, 1)
rules_in_files[rule_name] = {file_id}
else:
rules_in_files[rule_name].add(file_id)
rules_dict[rule_name] = (rules_dict[rule_name][0],
len(rules_in_files[rule_name]),
rules_dict[rule_name][2] + 1)
action_str = rule_name
rule_seq = [[
action_id, file_id, rules_dict[rule_name][0], parent_id, action_counter
]]
action_counter += 1
if not isinstance(node, antlr4.tree.Tree.TerminalNodeImpl):
next_action_id = action_id
for child in node.getChildren():
child_subtree_seq = ast_to_actions_seq(child, rule_names, file_id,
action_id,
next_action_id + 1)
rule_seq.extend(child_subtree_seq)
action_str += '##' + Trees.getNodeText(child, rule_names)
next_action_id = rule_seq[-1][0]
if action_str not in actions_dict:
actions_dict[action_str] = (len(actions_dict), 1, 1)
actions_in_files[action_str] = {file_id}
else:
actions_in_files[action_str].add(file_id)
actions_dict[action_str] = (actions_dict[action_str][0],
len(actions_in_files[action_str]),
actions_dict[action_str][2] + 1)
rule_seq[0].append(actions_dict[action_str][0])
return rule_seq
def traverse(tree: Tree, file, dot, node_name):
children = Trees.getChildren(tree)
for child in children:
node = Trees.getNodeText(tree, DbQlGrammarParser.ruleNames)
child_node = Trees.getNodeText(child, DbQlGrammarParser.ruleNames)
child_name = get_node_name()
dot.node(node_name, node)
dot.node(child_name, child_node)
dot.edge(node_name, child_name)
traverse(child, file, dot, child_name)
def process(t, ruleNames):
global level
if t.getChildCount() == 0:
return escapeWhitespace(Trees.getNodeText(t, ruleNames), False)
sb = ""
sb += lead(level)
level += 1
s = escapeWhitespace(Trees.getNodeText(t, ruleNames), False)
sb += (s + ' ')
for i in range(t.getChildCount()):
sb += process(t.getChild(i), ruleNames)
level -= 1
# sb += lead(level)
return sb
def __traverse(self, tree, counter):
root = Trees.getNodeText(tree, DbQLGrammarParser.ruleNames)
root_name = str(counter)
for child in Trees.getChildren(tree):
child_node = Trees.getNodeText(child, DbQLGrammarParser.ruleNames)
new_counter = counter + 1
child_name = str(new_counter)
self.dot.node(root_name, root)
self.dot.node(child_name, child_node)
self.dot.edge(root_name, child_name)
counter = self.__traverse(child, new_counter)
return counter
def get_pretty_tree(
tree: "ParseTree", rule_names: list = None, parser: Parser = None, level: int = 0
) -> str:
"""Take antlr ``ParseTree`` and return indented tree format for test comparison.
Adapted from ``antrl4.tree.Trees.toStringTree()`` method.
Args:
tree: The antlr parse tree.
rule_names: Names of parser rules.
parser: The parser used to generated the tree.
level: Level of tree (used for indentation).
Returns:
Pretty tree format (indents of one space at each level).
"""
indent_value = " " # indent using two spaces to match ``yaml`` reference files
if parser is not None:
rule_names = parser.ruleNames
node_text = Trees.getNodeText(tree, rule_names)
pretty_tree = level * indent_value + node_text + "\n"
if tree.getChildCount() > 0:
for i in range(0, tree.getChildCount()):
pretty_tree += get_pretty_tree(tree.getChild(i), rule_names=rule_names, level=level + 1)
return pretty_tree
def traverse(self, tree):
parent_label = Trees.getNodeText(tree, self.parser.ruleNames)
self.nodes.append((self.stack[-1], parent_label))
for child in Trees.getChildren(tree):
self.cnt += 1
self.edges.append((self.stack[-1], self.cnt))
self.stack.append(self.cnt)
self.traverse(child)
self.stack.pop()
def treeDesc(t: Tree, p, indent=0):
ruleNames = p.ruleNames
s = escapeWhitespace(Trees.getNodeText(t, ruleNames), False)
if t.getChildCount() == 0:
return s
with StringIO() as buf:
buf.write(s + "\n")
indent += 2
for i in range(0, t.getChildCount()):
buf.write(' ' * indent)
buf.write(treeDesc(t.getChild(i), p, indent) + "\n")
return buf.getvalue()
def iterate_over_tree(node, rule_names):
name = Trees.getNodeText(node, ruleNames=rule_names)
if node.getChildCount() == 0:
return name
children = []
for c in node.getChildren():
children.append(iterate_over_tree(c, rule_names))
if node.getChildCount() > 1:
return {name: children}
else:
return {name: children[0]}
def _pretty_tree_inner(parse_tree: ParseTree, rule_names: list,
level: int) -> str:
"""Internal recursive routine used in pretty-printing the parse tree.
Args:
parse_tree: a node in the parse tree of the output of the ANTLR parser.
rule_names: the ANTLR-generated list of rule names in the grammar.
level: the current indentation level.
Returns:
the pretty-printed tree starting from this node, indented correctly.
"""
indent = " " * level
tree = indent + Trees.getNodeText(parse_tree, rule_names) + "\n"
return tree + "".join(
_pretty_tree_inner(parse_tree.getChild(i), rule_names, level + 1)
for i in range(parse_tree.getChildCount()))
def process(tree: ParserRuleContext,
level: int,
ruleNames: list[str] = None,
recog: Parser = None) -> str:
s = Utils.escapeWhitespace(
Trees.getNodeText(tree, ruleNames=ruleNames, recog=recog), False)
sb = StringIO()
sb.write(lead(level))
if isinstance(tree, TerminalNode):
sb.write('"')
sb.write(s)
sb.write('"')
else:
sb.write(s)
sb.write(' ')
for child in tree.children:
sb.write(process(child, level + 1, ruleNames, recog))
return sb.getvalue()
def getTreeString(self, t, ruleNames=None, parser=None):
if parser is not None:
ruleNames = parser.ruleNames
s = self.escapeWhitespace(Trees.getNodeText(t, ruleNames), False)
c = t.__class__.__name__
if c.endswith("Context"):
s = c[:-7]
if t.getChildCount() == 0:
return s
with StringIO() as buf:
buf.write(u"\n")
buf.write(u" " * self.printDepth)
buf.write(u"")
buf.write(s)
buf.write(u' ')
self.printDepth += 1
for i in range(0, t.getChildCount()):
if i > 0:
buf.write(u' ')
buf.write(self.getTreeString(t.getChild(i), ruleNames, parser))
self.printDepth -= 1
buf.write(u"")
return buf.getvalue()
from antlr4.tree.Trees import Trees
from antlr4.Utils import escapeWhitespace
# from analyzer.solParser import solParser
results = []
test_tree = list(Trees.getChildren(tree))[6:7][0]
builded = build_tree(Trees, test_tree, parser)
print(builded)
for line in list(Trees.getChildren(tree))[6:7]:
res = child_pairs(line)
res_pairs = [('program', 'line')]
for r in res:
if escapeWhitespace(Trees.getNodeText(r[1], None, recog=parser),
False) == '\\r\\n':
continue
parent = escapeWhitespace(
Trees.getNodeText(r[0], None, recog=parser), False)
child = escapeWhitespace(
Trees.getNodeText(r[1], None, recog=parser), False)
print(parent, str(r[0]))
print(child, str(r[1]))
if parent in ('positive_number', 'row_of_numbers',
'natural_number'):
continue
