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)
