def match(target_str, pattern_str): 'Apply all pre-processing, then pattern matcher' target_ast = ast.parse(target_str, mode="eval").body target_ast = pre_processing.all_preprocessings(target_ast) target_ast = asttools.LevelOperators(ast.Add).visit(target_ast) pattern_ast = ast.parse(pattern_str, mode="eval").body pattern_ast = pre_processing.all_preprocessings(pattern_ast) pattern_ast = asttools.LevelOperators(ast.Add).visit(pattern_ast) return PatternMatcher(target_ast).visit(target_ast, pattern_ast)
def replace(target_str, pattern_str, replacement_str): 'Apply pre-processing and replace' target_ast = ast.parse(target_str, mode="eval").body target_ast = pre_processing.all_preprocessings(target_ast) target_ast = asttools.LevelOperators(ast.Add).visit(target_ast) patt_ast = ast.parse(pattern_str, mode="eval").body patt_ast = pre_processing.all_preprocessings(patt_ast) patt_ast = asttools.LevelOperators(ast.Add).visit(patt_ast) rep_ast = ast.parse(replacement_str) rep = PatternReplacement(patt_ast, target_ast, rep_ast) return rep.visit(target_ast)
def test_afterSubMult(self): 'Tests after SubToMult pre-processing' tests = [("1 + 2 - 3", ast.BoolOp(ast.Add(), [ ast.Num(1), ast.Num(2), ast.BinOp(ast.Num(-1), ast.Mult(), ast.Num(3)) ])), ("1 + 2 - 3 + 4", ast.BoolOp(ast.Add(), [ ast.Num(1), ast.Num(2), ast.BinOp(ast.Num(-1), ast.Mult(), ast.Num(3)), ast.Num(4) ])), ("(1 + 2) - (3 + 4)", ast.BoolOp(ast.Add(), [ ast.Num(1), ast.Num(2), ast.BinOp(ast.Num(-1), ast.Mult(), ast.BinOp(ast.Num(3), ast.Add(), ast.Num(4))) ]))] for teststring, ref_ast in tests: test_ast = ast.parse(teststring, mode="eval").body test_ast = pre_processing.all_preprocessings(test_ast) test_ast = Flattening(ast.Add).visit(test_ast) self.assertTrue(Comparator().visit(test_ast, ref_ast))
def test_differentops(self): 'Test with other types of operators' tests = [("(3 & 5 & 6)", ast.BoolOp(ast.BitAnd(), [ast.Num(3), ast.Num(5), ast.Num(6)])), ("(1 ^ 2 ^ 3) - 4", ast.BinOp(ast.BoolOp(ast.BitXor(), [ast.Num(1), ast.Num(2), ast.Num(3)]), ast.Add(), ast.BinOp(ast.Num(-1), ast.Mult(), ast.Num(4)))), ("((1 + 2 + 3) & (4 + 5))", ast.BinOp(ast.BoolOp(ast.Add(), [ast.Num(1), ast.Num(2), ast.Num(3)]), ast.BitAnd(), ast.BinOp(ast.Num(4), ast.Add(), ast.Num(5)))), ("(1 & 2 & 3) - (4 & 5)", ast.BinOp(ast.BoolOp(ast.BitAnd(), [ast.Num(1), ast.Num(2), ast.Num(3)]), ast.Add(), ast.BinOp(ast.Num(-1), ast.Mult(), ast.BinOp(ast.Num(4), ast.BitAnd(), ast.Num(5))))), ("(1 & 2 & 3) << (4 & 5)", ast.BinOp(ast.BoolOp(ast.BitAnd(), [ast.Num(1), ast.Num(2), ast.Num(3)]), ast.LShift(), ast.BinOp(ast.Num(4), ast.BitAnd(), ast.Num(5))))] for teststring, ref_ast in tests: test_ast = ast.parse(teststring, mode="eval").body test_ast = pre_processing.all_preprocessings(test_ast) test_ast = asttools.LevelOperators().visit(test_ast) self.assertTrue(asttools.Comparator().visit(test_ast, ref_ast))
def test_leveled(self): 'Test positive matchings for leveled ast' pattern_string = "A + 2*B + 3*C" test_pos = ["x + 2*y + 3*z", "3*z + 2*y + x", "2*y + 3*z + x"] for input_string in test_pos: self.generic_test_positive(input_string, pattern_string, True) # actual pre-processing only level ADD nodes, but this test is # for code coverage test_neg = ast.parse("x ^ 2*y ^ 2*z") test_neg = pre_processing.all_preprocessings(ast.parse(test_neg)) test_neg = asttools.LevelOperators().visit(test_neg) patt_ast = ast.parse(pattern_string) patt_ast = pre_processing.all_preprocessings(patt_ast) patt_ast = asttools.LevelOperators(ast.Add).visit(patt_ast) pat = pattern_matcher.PatternMatcher(test_neg) self.assertFalse(pat.visit(test_neg, patt_ast))
def __init__(self, nbits, rules_list=DEFAULT_RULES): 'Init context : correspondance between variables and values' # pylint: disable=dangerous-default-value self.context = {} self.nbits = nbits self.patterns = [] for pattern, replace in rules_list: patt_ast = ast.parse(pattern, mode="eval").body patt_ast = all_preprocessings(patt_ast, self.nbits) patt_ast = Flattening(ast.Add).visit(patt_ast) rep_ast = ast.parse(replace, mode="eval").body self.patterns.append((patt_ast, rep_ast))
def simplify(self, expr_ast, nbits): 'Apply pattern matching and arithmetic simplification' expr_ast = arithm_simpl.run(expr_ast, nbits) expr_ast = asttools.GetConstMod(self.nbits).visit(expr_ast) if DEBUG: print "arithm simpl: " print unparse(expr_ast) if DEBUG: print "before matching: " print unparse(expr_ast) expr_ast = all_preprocessings(expr_ast, self.nbits) # only flattening ADD nodes because of traditionnal MBA patterns expr_ast = Flattening(ast.Add).visit(expr_ast) for pattern, repl in self.patterns: rep = pattern_matcher.PatternReplacement(pattern, expr_ast, repl) new_ast = rep.visit(deepcopy(expr_ast)) if not asttools.Comparator().visit(new_ast, expr_ast): if DEBUG: print "replaced! " dispat = deepcopy(pattern) dispat = Unflattening().visit(dispat) print "pattern: ", unparse(dispat) disnew = deepcopy(new_ast) disnew = Unflattening().visit(disnew) print "after: ", unparse(disnew) print "" expr_ast = new_ast break # bitwise simplification: this is a ugly hack, should be # "generalized" expr_ast = Flattening(ast.BitXor).visit(expr_ast) expr_ast = asttools.ConstFolding(expr_ast, self.nbits).visit(expr_ast) expr_ast = Unflattening().visit(expr_ast) if DEBUG: print "after PM: " print unparse(expr_ast) return expr_ast