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)