def main():
grammar = AttributeGrammar([Parent, Child])
from pprint import pprint
pprint(grammar.grammar_info())
pprint("Local Functional Dependencies")
for i, j in grammar.local_functional_dependence.items():
pprint(i)
for jj in j:
pprint(jj, indent=2)
print()
pprint("Lower Dependencies")
pprint(grammar.lower_dependence)
print()
print(grammar.is_acyclic)
print(grammar.is_absolutely_acyclic)
array = [4, 8, 2, 24, 32]
root = Parent(*map(Child, array))
root = StaticEvaluator(grammar).for_tree(root)
expected = []
tmp = max(array)
for a in array:
tmp = tmp / 2 + a
expected.append(tmp)
print(root.attenuated_sums)
print(expected)
class EvaluatorStaticTest(unittest.TestCase, EvaluatorTestCases):
grammar_scopes = AttributeGrammar.from_modules(scopes, rule_extractor=Parser())
grammar_arithmetic = AttributeGrammar.from_modules(arithmetic, rule_extractor=Parser())
evaluator_scopes = StaticEvaluator(grammar_scopes)
evaluator_arithmetic = StaticEvaluator(grammar_arithmetic)
def test_arithmetic(self):
for e, r, t, d in self.expressions:
ast = arithmetic.parse_rpn(e)
ast.depth = 0
ast.index = None
ast = self.evaluator_arithmetic.for_tree(ast).content
self.assertEqual(ast.value, r)
self.assertEqual(ast.type, t)
self.assertEqual(ast.subtree_depth, d)
def test_scopes(self):
for e in self.ok:
ast = scopes_parser.parse(e)
ast.same = []
ast.env = {}
self.assertTrue(self.evaluator_scopes.for_tree(ast).ok)
for e in self.not_ok:
ast = scopes_parser.parse(e)
ast.same = []
ast.env = {}
self.assertFalse(self.evaluator_scopes.for_tree(ast).ok, e)
def main():
from securify.grammar.attributes.evaluators.evaluator import DemandDrivenRecursive
grammar = AttributeGrammar([
ASTNode,
Root,
# Other,
Term,
Addition,
Multiplication,
Constant,
Sum,
], rule_extractor=Parser())
from pprint import pprint
info = grammar.grammar_info()
pprint(grammar.grammar_info(), width=120, indent=2)
root = Sum(
Multiplication(Addition(Constant(1), Constant(2)), Constant(2.5)),
Constant(2),
Constant(2),
Constant(2),
Constant(5)
)
root.implicit_pushdown = "Works!"
root.depth = 0
root.index = None
root = DemandDrivenRecursive(grammar).for_tree(root)
print()
print("Results:")
print("Root value", root.value)
print("Root string", root.string)
print("Root string", root.subtree_depth)
print("Root lhs depth", root.addends[1].depth)
print("Root lhs depth", root.addends[0].lhs.depth)
print("Root lhs max subtree", root.subtree_depth)
print("Implicit Attribute", root.addends[0].implicit_pushdown)
print(DemandDrivenRecursive(grammar).for_tree(Root(Constant(1))).content.depth)
# print(DemandDriven(grammar).for_tree(Root(Other())).content.comment)
print("Index", root.addends[0].index)
print("Index", root.addends[1].index)
print("Index", root.addends[2].index)
print("Index", root.addends[3].index)
print("Index", root.addends[4].index)
print(root.set_in_module)
def main():
grammar = AttributeGrammar([
NodeBase,
NodeA,
NodeB,
NodeC,
NodeD
], Parser())
from pprint import pprint
pprint(grammar.grammar_info())
class AttributeDecoratorsTest(unittest.TestCase):
grammar = AttributeGrammar([Rule, Child], rule_extractor=Parser())
# pprint(grammar.grammar_info())
def test(self):
rules_s = self.grammar.synthesized_rules[Rule]
self.assertEqual(rules_s[("self", "attr1")][0].arguments[0].node,
"self")
self.assertEqual(rules_s[("self", "attr2")][0].arguments[0].node,
"self")
self.assertEqual(rules_s[("self", "attr3")][0].arguments[0].node,
"self")
self.assertEqual(rules_s[("self", "attr4")][0].arguments[0].node,
"self")
self.assertIn(("self", "attr1"),
rules_s[("self", "attr2")][0].dependencies)
self.assertIn(("self", "attr2"),
rules_s[("self", "attr3")][0].dependencies)
self.assertIn(("self", "attr3"),
rules_s[("self", "attr4")][0].dependencies)
self.assertEqual(len(rules_s[("self", "attr4")][0].arguments), 3)
self.assertEqual(len(rules_s[("self", "attr4")][0].dependencies), 2)
self.assertIn(("self", "attr3"),
rules_s[("self", "attr4")][0].dependencies)
self.assertIn(("node", "some_attribute"),
rules_s[("self", "attr4")][0].dependencies)
class DefaultAttributesTest(unittest.TestCase, EvaluatorTestCases):
grammar = AttributeGrammar.from_modules(defaults, rule_extractor=Parser())
def test(self):
ast = Parent(ChildA(ChildB()), ChildA(None))
ast = StaticEvaluator(self.grammar).for_tree(ast)
self.assertEqual(ast.default, "Default Synth")
self.assertEqual(ast.child1.attr, "Success")
self.assertEqual(ast.child1.child.attr, "Success")
class AttributeVisitorTest(unittest.TestCase):
grammar = AttributeGrammar.from_modules(arithmetic,
rule_extractor=Parser())
visitor = grammar.attribute_visitor()
def test_attribute_visitor(self):
tree = arithmetic.parse_rpn("1 2 + 2.5 * 2 5 SUM")
tree.depth = 0
tree.index = None
tree = DemandDrivenRecursive(self.grammar).for_tree(tree)
def print_attribute(node, attribute):
getattr(node, attribute)
self.visitor.visit(tree, print_attribute)
class AttributeDecoratorsTest(unittest.TestCase):
grammar = AttributeGrammar([SymbolRule], rule_extractor=Parser())
# pprint(grammar.grammar_info())
def test(self):
rules_i = self.grammar.inheritable_rules[SymbolRule]
rules_s = self.grammar.synthesized_rules[SymbolRule]
self.assertEqual(rules_i[("child", "attr3")][0].arguments[0].node, "self")
self.assertEqual(rules_i[("child", "attr3")][0].arguments[1].node, "node")
self.assertIn(("node", "attr1"), rules_i[("child", "attr3")][0].dependencies)
self.assertIn(("node", "attr2"), rules_i[("child", "attr3")][0].dependencies)
self.assertEqual(rules_i[("child", "attr3")][0].target, ("child", "attr3"))
self.assertEqual(rules_s[("self", "test_synthesized")][0].arguments[0].node, "self")
self.assertEqual(rules_s[("self", "test_synthesized")][0].arguments[1].node, "node")
self.assertIn(("node", "attr1"), rules_s[("self", "test_synthesized")][0].dependencies)
self.assertIn(("node", "attr2"), rules_s[("self", "test_synthesized")][0].dependencies)
def main():
from tests.grammar.grammars import scopes
grammar = AttributeGrammar.from_modules(scopes, rule_extractor=Parser())
# print(grammar.synthesized_attributes)
# print(grammar.inheritable_attributes)
from tests.grammar.grammars.scopes_parser import parse
ast = parse(program)
# dump_ast(grammar.grammar_info())
grammar.traverse(ast, lambda n, a, c: setattr(n, "_id", id(n)))
ast.same = []
ast.env = {}
ast_original = ast
ast = DemandDrivenIterative(grammar).for_tree(ast)
print(ast)
print(ast.ok)
print(ast.procs)
from pprint import pprint
pprint(grammar.grammar_info())
print()
print("# Local Functional Dependencies")
pprint({
a.__name__: set(b)
for a, b in grammar.local_functional_dependence.items()
})
print()
print("# Lower Dependence Relations")
pprint({a.__name__: set(b) for a, b in grammar.lower_dependence.items()})
print()
print("# Lower Dependence All")
pprint({
a.__name__: set(b)
for a, b in grammar.lower_dependence_combined.items()
})
print()
# DictTransformer(grammar)
#
#
# ast.env = {}
# ast.same = []
# ast = DemandDriven(ast).root
# print(ast.ok)
evaluated = StaticEvaluator(grammar).for_tree(ast_original)
def attribute_dict(tree):
result = {}
def fill_dict(node, attribute):
result[(node._id, attribute)] = getattr(node, attribute)
grammar.attribute_visitor().visit(tree, fill_dict)
return result
for a in attribute_dict(evaluated):
print(attribute_dict(ast)[a])
print(attribute_dict(evaluated)[a])
pprint(attribute_dict(evaluated) == attribute_dict(ast))
pass
from __future__ import annotations
from securify.grammar import production
from securify.grammar.attributes import AttributeGrammar
from securify.grammar.attributes.annotations3 import synthesized, Parser
from securify.grammar.attributes.evaluators import DemandDrivenRecursive
@production
class Test:
print = synthesized()
test = synthesized()
@synthesized
def print(self):
print("this should be printed once!")
return 0
@synthesized
def test(self: {Test.print}):
return "this should be printed after the above string"
grammar = AttributeGrammar([Test], Parser())
root = DemandDrivenRecursive(grammar).for_tree(Test())
print(root.test)
print(root.print)
class EvaluatorConsistencyTest(unittest.TestCase, EvaluatorTestCases):
grammar_scopes = AttributeGrammar.from_modules(scopes, rule_extractor=Parser())
grammar_arithmetic = AttributeGrammar.from_modules(arithmetic, rule_extractor=Parser())
evaluator_scopes_1 = StaticEvaluator(grammar_scopes)
evaluator_arithmetic_1 = StaticEvaluator(grammar_arithmetic)
evaluator_scopes_2 = DemandDrivenRecursive(grammar_scopes)
evaluator_arithmetic_2 = DemandDrivenRecursive(grammar_arithmetic)
def test_arithmetic(self):
for e, r, t, d in self.expressions:
ast = arithmetic.parse_rpn(e)
ast.depth = 0
ast.index = None
self.mark_nodes(self.grammar_arithmetic, ast)
self.same_evaluations(ast,
self.evaluator_arithmetic_1,
self.evaluator_arithmetic_2)
def test_scopes(self):
for e in self.ok:
ast = scopes_parser.parse(e)
ast.same = []
ast.env = {}
self.mark_nodes(self.grammar_scopes, ast)
self.same_evaluations(ast,
self.evaluator_scopes_1,
self.evaluator_scopes_2)
for e in self.not_ok:
ast = scopes_parser.parse(e)
ast.same = []
ast.env = {}
self.mark_nodes(self.grammar_scopes, ast)
self.same_evaluations(ast,
self.evaluator_scopes_1,
self.evaluator_scopes_2)
def same_evaluations(self, tree, evaluator1, evaluator2):
evaluated1 = evaluator1.for_tree(tree)
evaluated2 = evaluator2.for_tree(tree)
d1 = self.attribute_dict(evaluator1.grammar, evaluated1)
d2 = self.attribute_dict(evaluator2.grammar, evaluated2)
self.assertEqual(d1, d2)
@staticmethod
def mark_nodes(grammar, tree):
# Required bc. node ids change after being passed through evaluators
grammar.traverse(tree, lambda n, c, a: setattr(n, "node_id", id(n)))
@staticmethod
def attribute_dict(grammar, tree):
result = {}
def fill_dict(node, attribute):
result[(node.node_id, attribute)] = getattr(node, attribute)
grammar.attribute_visitor().visit(tree, fill_dict)
return result
@dataclass(eq=False)
class ChildA:
child: Optional[ChildB]
attr = inherited(default="Success")
listA = inherited(default=[])
listB = inherited(default=lambda: [])
@production
@dataclass(eq=False)
class ChildB:
attr = inherited()
if __name__ == '__main__':
grammar = AttributeGrammar([Parent, ChildA, ChildB],
rule_extractor=Parser())
ast = Parent(ChildA(ChildB()), ChildA(None))
ast = StaticEvaluator(grammar).for_tree(ast)
print(ast.default)
print(ast.child1.attr)
print(ast.child1.child.attr)
print(ast.child1.listA, ast.child1.listB)
ast.child1.listA.append(1)
ast.child1.listB.append(1)
print(ast.child1.listA, ast.child1.listB)
print(ast.child2.listA, ast.child2.listB)