def create_named_fp(smt2file, ctx=None, pp=False, engine='pdr', validate=False): given_fp = z3.Fixedpoint(ctx=ctx) q = given_fp.parse_file(smt2file) given_preds = get_preds(given_fp) fp = z3.Fixedpoint(ctx=ctx) rules = dict() # map from names to rules if not pp: print 'No pre-processing' fp.set(slice=False) fp.set(inline_linear=False) fp.set(inline_eager=False) fp.set(validate_result=validate) fp.set(engine=engine, use_farkas=True, generate_proof_trace=False) for pred in given_preds.itervalues(): fp.register_relation(pred) for i, rule in enumerate(given_fp.get_rules()): name = 'r' + str(i) fp.add_rule(rule, name=name) rules[name] = rule return (q, fp, rules)
def main(): # get optional file name fname = None if len (sys.argv) >= 2: fname = sys.argv[1] # create a fixedpoint object fp = z3.Fixedpoint () fp.set (engine='spacer') # optionally disable pre-processing # comment this out for faster solving, but less readable output fp.set ('fp.xform.slice', False) fp.set ('fp.xform.inline_eager', False) fp.set ('fp.xform.inline_linear', False) query = None if fname is not None: q = fp.parse_file (fname) query = q[0] if query is None: print( 'Dumping fp, nothing to solve') print( fp ) return print ('Solving for query', query) res = fp.query (query) print (res) if res == z3.sat: print (fp.get_ground_sat_answer ()) elif res == z3.unsat: print (fp.get_answer ())
def fixedpoint(M, bad): fp = z3.Fixedpoint() options = {'engine':'spacer'} fp.set(**options) xs = M.variables() xsp = M.variables('prime') sorts = M.sorts() + [z3.BoolSort()] inv = z3.Function('inv', *sorts) err = z3.Function('err', z3.BoolSort()) fp.register_relation(inv) fp.register_relation(err) for zi in xs + xsp: fp.declare_var(zi) inv_xs = inv(*xs) inv_xsp = inv(*xsp) fp.rule(inv_xs, M.init(xs)) fp.rule(inv_xsp, M.tr(xs, xsp) + [inv_xs]) fp.rule(err(), bad(xs) + [inv_xs]) if fp.query(err) == z3.unsat: inv = fp.get_answer() assert inv.is_forall() body = inv.body() assert z3.is_eq(body) fapp = body.arg(0) assert (z3.is_app(fapp)) args = [fapp.arg(i) for i in range(body.num_args())] assert len(args) == len(xs) expr = (body.arg(1)) return (z3.unsat, args, expr) else: return (z3.sat, None, None)
def chc_solve_with_fp(db, args, opts): if args.fresh: ctx = z3.Context() else: ctx = db.get_ctx() fp = z3.Fixedpoint(ctx=ctx) db.mk_fixedpoint(fp=fp) if args.st: fp.set("print_statistics", True) if args.pp: fp.set("xform.slice", True) fp.set("xform.inline_linear", True) fp.set("xform.inline_eager", True) else: fp.set("xform.slice", False) fp.set("xform.inline_linear", False) fp.set("xform.inline_eager", False) if args.spctr is not None: fp.set("spacer.trace_file", args.spctr) for k, v in opts.items(): fp.set(k, v) for q in db.get_queries(): qf = q.mk_query() if qf.ctx != ctx: qf = qf.translate(ctx) res = fp.query(qf) return res
def checkLength(M, bad, count): fp = z3.Fixedpoint() options = {'engine': 'spacer'} fp.set(**options) addCounter(M) xs = M.variables sorts = M.sorts + [z3.BoolSort()] inv = z3.Function('inv', *sorts) err = z3.Bool('err') fp.register_relation(inv) fp.register_relation(err.decl()) fp.declare_var(*xs) bad_state = [z3.And(bad(xs) + [xs[-1] == count])] fp.rule(inv(*xs), M.init) fp.rule(inv(*M.tr), inv(*xs)) fp.rule(err, bad_state + [inv(*xs)]) r = fp.query(err) if r == z3.unsat: return (z3.unsat, None) else: return (z3.sat, len(inv.children()))
def getLength(M, bad): fp = z3.Fixedpoint() options = {'engine':'spacer'} fp.set(**options) xs = M.variables sorts = M.sorts + [z3.BoolSort()] inv = z3.Function('inv', *sorts) err = z3.Bool('err') fp.register_relation(inv) fp.register_relation(err.decl()) fp.declare_var(*xs) fp.rule(inv(*xs), M.init) fp.rule(inv(*M.tr), inv(*xs)) fp.rule(err, bad(xs) + [inv(*xs)]) r = fp.query(err) if r == z3.unsat: return (z3.unsat, None) else: return (z3.sat, len(fp.get_answer().children()))
def test_translate(self): fp = z3.Fixedpoint() atom1 = ast.Atom('p', [ ast.NumConstant(2, 'int4'), ast.NumConstant(3, 'int4'), ast.Variable('X', 'int4') ]) atom2 = ast.Atom('p', [ ast.NumConstant(2, 'int4'), ast.NumConstant(3, 'int4'), ast.Variable('Y', 'int4') ]) int4 = z3.BitVecSort(4) p = z3.Function('p', int4, int4, int4, z3.BoolSort()) a0 = z3.BitVecVal(2, int4) a1 = z3.BitVecVal(3, int4) a2 = z3.Const('X', int4) a3 = z3.Const('Y', int4) args1 = [a0, a1, a2] args2 = [a0, a1, a3] project = projection.Projection([], None) project.grounded = {'p': (0, 1)} project.items = {'p': {}} project.relations = {'p': p} result = project.translate(fp, atom1, args1) self.assertIn((0, 1), project.items['p']) self.assertIn((a0, a1), project.items['p'][(0, 1)]) p0 = project.items['p'][(0, 1)][(a0, a1)] self.assertIs(True, z3.is_true(z3.simplify(p0(a2) == result))) result2 = project.translate(fp, atom2, args2) self.assertIs(True, z3.is_true(z3.simplify(p0(a3) == result2)))
def main(argv): fp = z3.Fixedpoint() fp.set(engine='spacer') fp.set('xform.inline_eager', False) fp.set('xform.slice', False) fp.set('xform.inline_linear', False) fp.set('pdr.utvpi', False) fp.set('xform.karr', True) query = fp.parse_file(argv[1]) # proving termination... if len(argv) < 3: print('please choose a ranking function template:') print(' max\t\t(piecewise)') print(' lex\t\t(lexicographic)') else: if argv[2] == 'max': # start = time.time() piecewise(fp) # end = time.time() # print 'Time: %.2fs' % (end - start) elif argv[2] == 'lex': # start = time.time() lexicographic(fp) # end = time.time() # print 'Time: %.2fs' % (end - start) elif argv[2] == 'mul': # start = time.time() multiphase(fp) # end = time.time() # print 'Time: %.2fs' % (end - start) else: print('unknown ranking function template')
def __init__(self, args): ctx = z3.Context() self.fp = z3.Fixedpoint(ctx=ctx) self.args = args self.log = LoggingManager.get_logger(__name__) self.prdes = None return
def parallelRun(self, smt2_file): """ Job spanner """ ctx = z3.Context() fp = z3.Fixedpoint(ctx=ctx) jobs = [] with stats.timer('Parse'): self.log.info('Parsing ... ' + str(smt2_file)) queries = fp.parse_file(smt2_file) stats.stop('Parse') self.log.info("Parsing time ... " + str(stats.get('Parse')) + " ms") n_function = len(queries) n_query = n_function if self.args.func < 0 or self.args.func > n_function else self.args.func self.log.info("Number of functions ... " + str(n_function)) self.log.info("Number of jobs ... " + str(n_query)) all_results = "" pool_jobs = Pool(processes=n_query) try: for q in range(n_query): query = queries[q] function_name = self.getFunctionName(query) self.log.info("Checking feasibility of ... " + str(function_name)) #job_result = pool_jobs.apply_async(jobStarter, (self.args, qi, smt2_file, ), callback=self.onReturn) job_result = pool_jobs.apply_async(jobStarter, ( self.args, q, smt2_file, )) job_result.wait(timeout=self.args.timeout) if job_result.ready(): out = "" try: out = job_result.get() if bench: print out except Exception as e: print str(e) continue all_results += out + "\n-----------------------\n" else: out = out_message % (function_name, "TIMEOUT", "", "", "", "", "") out = bcolors.WARNING + out + bcolors.ENDC if bench: print out all_results += out + "\n------- ----------------\n" pool_jobs.close() pool_jobs.terminate() pool_jobs.join() if self.args.save: f_name = ntpath.basename(smt2_file) + "_feas.txt" with open(f_name, "w") as f: f.write(all_results) else: print "\n\t ========= SUMMARY SEAHORN INCONSISTENCY CHECKS ========" print all_results except Exception as e: self.log.exception(str(e))
def pp_chc_as_smt(db, out): fp = z3.Fixedpoint() db.mk_fixedpoint(fp=fp) fp.set('print_fixedpoint_extensions', False) out.write(fp.sexpr()) for q in db.get_queries(): fml = q.mk_formula() out.write('(assert {})\n'.format(fml.sexpr())) out.write('(check-sat)\n')
def create_empty_fp(ctx=None, pp=False, engine='pdr', validate=False): fp = z3.Fixedpoint(ctx=ctx) if not pp: fp.set(slice=False) fp.set(inline_linear=False) fp.set(inline_eager=False) fp.set(validate_result=validate) fp.set(engine=engine, use_farkas=True, generate_proof_trace=False) return fp
def main(argv): args = parseArgs(argv[1:]) stat('Result', 'UNKNOWN') ctx = z3.Context() fp = z3.Fixedpoint(ctx=ctx) zus = Zustre(args, ctx, fp) if args.no_solving: zus.encode() else: zus.encodeAndSolve()
def __init__(self, args): verbose = args.verbose self.args = args self.ctx = z3.Context() self.fp = z3.Fixedpoint(ctx=self.ctx) self.preds = [] self.ee_idx = [] #entry/exit vars self.feasible_flag = [] # keep track of the feasible path self.non_feasible_flag = [] # keep track of the infesible path return
def pp_chc_as_rules(db, out): if db.has_fixedpoint(): fp = db.get_fixedpoint() else: fp = z3.Fixedpoint(ctx=db.get_ctx()) db.mk_fixedpoint(fp=fp) fp.set('print_fixedpoint_extensions', True) print('(set-logic ALL)', file=out) out.write(fp.sexpr()) for q in db.get_queries(): fml = q.mk_query() out.write('(query {})\n'.format(fml.sexpr()))
def create_fp(smt2file, ctx=None, pp=False, engine='pdr', validate=False): fp = z3.Fixedpoint(ctx=ctx) if not pp: print 'No pre-processing' fp.set(slice=False) fp.set(inline_linear=False) fp.set(inline_eager=False) fp.set(validate_result=validate) fp.set(engine=engine, use_farkas=True, generate_proof_trace=False) q = fp.parse_file(smt2file) return (q, fp)
def mk_fixedpoint(self, fp=None): if fp is None: self._fp = z3.Fixedpoint() fp = self._fp for rel in self._rels: fp.register_relation(rel) for r in self._rules: if r.has_formula(): fp.add_rule(r.get_formula()) else: fp.add_rule(r.mk_formula()) return fp
def singleRun(self, smt2_file): """ Single run """ ctx = z3.Context() fp = z3.Fixedpoint(ctx=ctx) with stats.timer('Parse'): self.log.info('Parsing ... ' + str(smt2_file)) queries = fp.parse_file(smt2_file) stats.stop('Parse') self.log.info("Parsing time ... " + str(stats.get('Parse')) + " ms") n_function = len(queries) n_query = n_function if self.args.func < 0 or self.args.func > n_function else self.args.func self.log.info("Number of functions ... " + str(n_function)) self.log.info("Number of jobs ... " + str(n_query)) all_results = "" try: for q in range(n_query): query = queries[q] function_name = self.getFunctionName(query) self.log.info("Checking feasibility of ... " + str(function_name)) out = "" try: p = multiprocessing.Process(target=checkFeas, args=( self.args, q, smt2_file, )) p.start() p.join(self.args.timeout) if p.is_alive(): out = out_message % (function_name, "TIMEOUT", "", "", "", "", "") out = bcolors.WARNING + out + bcolors.ENDC p.terminate() p.join() except Exception as e: self.log.exception(str(e)) continue all_results += out + "\n-----------------------\n" if self.args.save: f_name = ntpath.basename(smt2_file) + "_feas.txt" with open(f_name, "w") as f: f.write(all_results) except Exception as e: self.log.exception(str(e))
def __init__(self, args, smt2_file): log = 3 if verbose else 0 self.log = LoggingManager.get_logger(__name__, log) self.smt2_file = smt2_file self.args = args self.ctx = z3.Context() self.fp = z3.Fixedpoint(ctx=self.ctx) self.ee_idx = list() #entry/exit vars self.feasible_flag = set() # keep track of the feasible path self.non_feasible_flag = set() # keep track of the infesible path self.timeout = args.timeout # timeout per function self.flags = None self.preds = None self.function_name = None self.query_times = list()
def getLength1(M, bad): fp = z3.Fixedpoint() options = {'engine':'spacer'} fp.set(**options) Mp = TransitionSystem('prime') # addCounter(M) # addCounter(Mp) xs = M.variables xsp = Mp.variables trx = [xsp[i]==M.tr[i] for i in range(len(xs))] sorts = M.sorts + [z3.BoolSort()] inv = z3.Function('inv', *sorts) err = z3.Function('err', z3.BoolSort()) fp.register_relation(inv) fp.register_relation(err) for x in xs + xsp: fp.declare_var(x) inv_xs = inv(*xs) inv_xsp = inv(*xsp) fp.rule(inv_xs, M.init) fp.rule(inv_xsp, trx + [inv_xs]) fp.rule(err(), bad(xs) + [inv_xs]) r = fp.query(err) == z3.unsat if r: inv = fp.get_answer() print("INV:") print(inv) assert inv.is_forall() body = inv.body() # assert z3.is_eq(body) print("BODY:", body) fapp = body.arg(0) print("FAPP: ", fapp) assert (z3.is_app(fapp)) args = [fapp.arg(i) for i in range(body.num_args())] assert len(args) == len(xs) expr = (body.arg(1)) print(z3.unsat, args, expr) return (z3.unsat, args, expr) else: return (z3.sat, len(fp.get_answer().children()), None) # Are you sure this is the correct length?
def output (decls, rules, ctx, q, filename): fp = z3.Fixedpoint (ctx=ctx) fp.set (slice=False) fp.set (inline_linear=False) fp.set (inline_eager=False) for name,decl in decls.iteritems (): fp.register_relation (decl) for r in rules: fp.add_rule (r.rule_exp) if filename is None: f = sys.stdout else: f = open (filename, 'w') f.write (repr (fp)) f.write ('(query {})\n'.format (q [0]))
def test_reconciliate(self): fp = z3.Fixedpoint() int4 = z3.BitVecSort(4) p = z3.Function('p', int4, int4, int4, z3.BoolSort()) p_0 = z3.Function('p_0', int4, z3.BoolSort()) p_1 = z3.Function('p_1', int4, z3.BoolSort()) p_2 = z3.Function('p_2', int4, z3.BoolSort()) p_3 = z3.Function('p_3', int4, int4, z3.BoolSort()) for r in [p, p_0, p_1, p_2, p_3]: fp.register_relation(r) def n(v): return z3.BitVecVal(v, int4) project = projection.Projection([], None) project.relations = {'p': p} project.grounded = {'p': (0, 1)} project.items = { 'p': { (): { (): p }, (0, 1): { (n(2), n(2)): p_0, (n(1), n(2)): p_1, (n(1), n(3)): p_2 }, (0, ): { (n(1), ): p_3 } } } project.reconciliate(fp) result = fp.get_rules() self.assertEqual(5, len(result)) for f in result: self.assertIs(True, f.is_forall()) imp = f.children()[0] self.assertEqual("=>", imp.decl().name()) [le, ri] = imp.children() self.assertIn(le.decl(), [p_0, p_1, p_2]) self.assertIn(ri.decl(), [p, p_3])
def checkLength1(M, bad, count): fp = z3.Fixedpoint() options = {'engine': 'spacer'} fp.set(**options) addCounter(M) xs = M.variables sorts = M.sorts + [z3.BoolSort()] inv = z3.Function('inv', *sorts) err = z3.Bool('err') fp.register_relation(inv) fp.register_relation(err.decl()) fp.declare_var(*xs) bad_state = [z3.And(bad(xs) + [xs[-1] == count])] fp.rule(inv(*xs), M.init) fp.rule(inv(*M.tr), inv(*xs)) fp.rule(err, bad_state + [inv(*xs)]) r = fp.query(err) if r == z3.unsat: inv = fp.get_answer() print("INV:") print(inv) assert inv.is_forall() body = inv.body() assert z3.is_eq(body) print("BODY:", body) fapp = body.arg(0) assert (z3.is_app(fapp)) args = [fapp.arg(i) for i in range(body.num_args())] assert len(args) == len(xs) expr = (body.arg(1)) print(z3.unsat, args, expr) return (z3.unsat, args, expr) else: return (z3.sat, len(inv.children()), None)
def test_plan_to_program_idb(self): rules = parser.wrapped_parse(prog0) # arbitrary not really used rules[0].id = 0 fp = z3.Fixedpoint() datasource = source.Datasource(primitives.TYPES) octant_type = datasource.types["int4"] z3_type = octant_type.type() def mkv(v): return z3.BitVecVal(v, z3_type) p = z3.Function('p', z3_type, z3_type, z3.BoolSort()) q = z3.Function('q', z3_type, z3_type, z3.BoolSort()) content = { 'p': [(mkv(3), mkv(0)), (mkv(4), mkv(1))] } for (x, y) in [(5, 0), (6, 1)]: fp.add_rule(q(mkv(x), mkv(y))) relations = {'p': p, 'q': q} x = ast.Variable("X", "int4") y = ast.Variable("Y", "int4") z = ast.Variable("Z", "int4") for f in [p, q]: fp.register_relation(f) unfold_plan = unfolding.UnfoldPlan( {0: [((('p', [1, 0]),), [x, y]), ((('q', [0, 1]),), [z, x])]}, content) records = unfolding.plan_to_program( unfold_plan, fp, datasource, relations, rules) self.assertIn(0, records) trimmed = sorted([ sorted((var, val.as_long()) for ((var, _), val) in rec.items()) for rec in records[0] ], key=lambda t: t[0]) expected = [ [('X', 0), ('Y', 3), ('Z', 5)], [('X', 1), ('Y', 4), ('Z', 6)] ] self.assertEqual(expected, trimmed)
def mk_fixedpoint(self, fp=None): if fp is None: self._fp = z3.Fixedpoint(ctx=self._ctx) fp = self._fp fp_ctx = fp.ctx if fp_ctx == self._ctx: def trans(x): return x else: def trans(x): return x.translate(fp_ctx) for rel in self._rels_set: fp.register_relation(trans(rel)) for r in self._rules: if r.has_formula(): fp.add_rule(trans(r.get_formula())) else: fp.add_rule(trans(r.mk_formula())) return fp
def __init__(self, rules): self.rules = rules self.datasource = source.Datasource(primitives.TYPES) openstack_source.register(self.datasource) skydive_source.register(self.datasource) file.register(self.datasource) self.compiler = ( compiler.Z3Compiler(rules, primitives.CONSTANTS, self.datasource)) def constant_compiler(expr): return self.datasource.types[expr.type].to_z3(expr.val) self.compiler.compile(constant_compiler) self.relations = {} context = z3.Fixedpoint() z3_config = {"engine": "datalog"} if cfg.CONF.doc: z3_config["datalog.default_relation"] = "doc" context.set(**z3_config) self.context = context
def seaTerm(smt_file, rank_function): try: stat('Result', 'UNKNOWN') stat('Ranking_Function', rank_function) fp = z3.Fixedpoint() fp.set(engine='spacer') fp.set('xform.inline_eager', False) fp.set('xform.slice', False) fp.set('xform.inline_linear', False) fp.set('pdr.utvpi', False) fp.set('xform.karr', True) query = fp.parse_file(smt_file) with stats.timer('Termination'): if rank_function == 'max': piecewise(fp) elif rank_function == 'lex': lexicographic(fp) else: raise IOError('unknown ranking function template') except Exception as e: raise IOError(str(e)) finally: stats.brunch_print()
def main(argv): args = parseArgs(argv[1:]) stat('Result', 'UNKNOWN') z3.set_option(verbose=args.verbose) ctx = z3.Context() fp = z3.Fixedpoint(ctx=ctx) if not args.slice: print 'No slicing' fp.set(slice=False) if not args.inline: print 'No inlining' fp.set(inline_linear=False) fp.set(inline_eager=False) print 'Engine: ', args.engine fp.set(validate_result=args.validate) fp.set(engine=args.engine, use_farkas=True, generate_proof_trace=False) fp.set(use_utvpi=args.use_utvpi) fp.set(eager_reach_check=args.eager_reach_check) fp.set(validate_theory_core=args.validate_theory_core) fp.set(print_statistics=args.print_stats) fp.set(bit_blast=args.bit_blast) if args.dfs: fp.set(bfs_model_search=False) fp.set(order_children=int(args.order_children)) if args.array_blast: fp.set(array_blast=True) if args.array_blast_full: fp.set(array_blast_full=True) if args.use_heavy_mev: fp.set(use_heavy_mev=True) with stats.timer('Parse'): q = fp.parse_file(args.file) if len(args.trace) > 0: print 'Enable trace: ', for t in args.trace.split(':'): print t, z3.enable_trace(t) print stats.put('Trace', args.trace) #print fp with stats.timer('Query'): res = fp.query_from_lvl(args.from_lvl, q[0]) if res == z3.sat: stat('Result', 'CEX') elif res == z3.unsat: stat('Result', 'SAFE') if args.answer: print 'The answer is:' print fp.get_answer() if res == z3.sat: if args.ground_answer: print 'A ground answer:' print fp.get_ground_sat_answer() if args.rules_along_trace: print 'Rules along trace:' print fp.get_rules_along_trace()
def parse_with_z3(file, out_dir, check_only, split_queries, simplify, skip_err, datalog): if check_only: assertions = z3.parse_smt2_file(file) check.check_chcs(assertions.children()) print("success") return lst = file.split('/') tmp = lst.pop() lst = tmp.split('.') base_name = lst[0] assert len(lst) > 0 if len(lst) > 1: for stuff in lst[1:-1]: base_name = base_name + '.' + stuff # Check if the file is actually in datalog. engine = z3.Fixedpoint() engine.set("xform.inline_eager", simplify, "xform.inline_linear", simplify, "xform.slice", simplify, "xform.coi", simplify, "xform.compress_unbound", simplify, "xform.subsumption_checker", simplify, "xform.tail_simplifier_pve", simplify) try: queries = engine.parse_file(file) except z3.Z3Exception as e: raise Exc('Parse error on file {}'.format(file)) assertions = engine.get_assertions() for rule in engine.get_rules(): assertions.push(rule) for query in queries: assertions.push(z3.Implies(query, False)) # engine.get_assertions() goals = z3.Goal() goals.add(assertions) #non_lin = z3.Probe('arith-max-deg') #if non_lin(goals) > 1: # raise Skip( # 'found non-linear expressions' # ) # if simplify: tactic = z3.Tactic("horn-simplify") simplified = tactic(goals, "xform.inline_eager", simplify, "xform.inline_linear", simplify, "xform.slice", simplify, "xform.coi", simplify, "xform.compress_unbound", simplify, "xform.subsumption_checker", simplify, "xform.tail_simplifier_pve", simplify) # else: # simplified = [goals] clauses = [] queries = [] if len(simplified) == 0: #raise Skip( # 'empty benchmark (possibly because of pre-processing)' #) print('') pred_decls = set() for index, clause in enumerate(simplified[0]): try: clause, is_query = fix.fix_clause(clause, pred_decls) if is_query: queries.append(clause) else: clauses.append(clause) except Exc as e: raise Exc('While fixing clause {}:\n{}'.format(index, e.value)) if len(queries) < 1: # raise Skip('no query clause (possibly because of pre-processing)') print('') separated_clauses = [] if split_queries: for cnt, query in enumerate(queries): these_clauses = [] for clause in clauses: these_clauses.append(clause) these_clauses.append(query) separated_clauses.append(these_clauses) else: for query in queries: clauses.append(query) separated_clauses.append(clauses) cnt = 0 for clauses in separated_clauses: if out_dir is not None: out_file = "{}/{}_{:0>3}.smt2".format(out_dir, base_name, cnt) cnt += 1 print('Writing to {}'.format(out_file)) writer = open(out_file, mode='w') else: writer = sys.stdout if split_queries: try: check.check_chcs(clauses) except Exc as e: exc = Exc('Result of formatting is ill-formed:\n{}'.format( e.value)) if skip_err: eprint('Error on file {}'.format(file)) eprint(exc.value) continue else: raise exc if datalog: write_clauses_datalog(pred_decls, clauses, writer) else: write_clauses_smt2(pred_decls, clauses, writer)
def main (argv): args = parseArgs (argv[1:]) ctx = z3.Context () fp = z3.Fixedpoint (ctx=ctx) fp.set (slice=False) fp.set (inline_linear=False) fp.set (inline_eager=False) q = fp.parse_file (args.file) decls = dict () rules = list () self_loops = dict () preds = dict () succs = dict () parse (fp, decls, rules, self_loops, preds, succs) print 'After parsing:' print 'Rules:' for r in rules: print repr (r) print '\nSelf Loops:' for key,val in self_loops.iteritems (): print key, ': ', for r in val: print repr (r), ',', print print '\nPreds:' for key,val in preds.iteritems (): print key, ': ', for r in val: print repr (r), ',', print print '\nSuccs:' for key,val in succs.iteritems (): print key, ': ', for r in val: print repr (r), ',', print print # find init pred init_pred_name = None for key,val in preds.iteritems (): for rule in val: if not rule.has_body_pred (): init_pred_name = key break if init_pred_name is not None: break assert init_pred_name is not None # get dfs numbering numbers = dfs_number (decls, init_pred_name, succs) # outline loops in reverse order of dfs numbers names = sorted (numbers.keys (), key=lambda n: numbers [n], reverse=True) print 'Dfs ordering (reverse):', names, '\n' for name in names: if name not in self_loops: continue print 'Factoring out loop on:', name outline_loop (name, decls, rules, self_loops, preds, succs) print #print 'Rule Exps:' #for r in rules: #print repr (r.rule_exp) output (decls, rules, fp.ctx, q, args.out)