def __init__(self):
super().__init__('*', -1, (exprtypes.IntType(), ), exprtypes.IntType())
self.eval_children = lambda *cs: functools.reduce(
lambda x, y: x * y, cs, 1)
self.smt_function = z3.Product
self.commutative = True
self.associative = True
def make_linear_term(syn_ctx, v, c, consts, neg, constant_multiplication):
if c == 1:
return v
if c in consts and constant_multiplication:
return syn_ctx.make_function_expr(
'*', v,
exprs.ConstantExpression(exprs.Value(c, exprtypes.IntType())))
if neg and 0 in consts and (-c) in consts and constant_multiplication:
return syn_ctx.make_function_expr(
'-', exprs.ConstantExpression(exprs.Value(0, exprtypes.IntType())),
syn_ctx.make_function_expr(
'*', v,
exprs.ConstantExpression(exprs.Value(-c,
exprtypes.IntType()))))
if neg and c < 0:
return syn_ctx.make_function_expr(
'-', exprs.ConstantExpression(exprs.Value(0, exprtypes.IntType())),
make_linear_term(syn_ctx, v, -c, consts, neg,
constant_multiplication))
if c > 0:
ret = v
for x in range(1, c):
ret = syn_ctx.make_function_expr('+', v, ret)
return ret
return None
def __init__(self):
super().__init__('slia')
self.lia_instantiator = semantics_lia.LIAInstantiator()
self.function_types = {
'str.++': (exprtypes.StringType(), exprtypes.StringType()),
'str.replace': (exprtypes.StringType(), exprtypes.StringType(),
exprtypes.StringType()),
'str.at': (exprtypes.StringType(), exprtypes.IntType()),
'int.to.str': (exprtypes.IntType(), ),
'str.substr':
(exprtypes.StringType(), exprtypes.IntType(), exprtypes.IntType()),
'str.len': (exprtypes.StringType(), ),
'str.to.int': (exprtypes.StringType(), ),
'str.indexof': (exprtypes.StringType(), exprtypes.StringType(),
exprtypes.IntType()),
'str.prefixof': (exprtypes.StringType(), exprtypes.StringType()),
'str.suffixof': (exprtypes.StringType(), exprtypes.StringType()),
'str.contains': (exprtypes.StringType(), exprtypes.StringType())
}
self.function_instances = {
'str.++': StrConcat(),
'str.replace': StrReplace(),
'str.at': StrAt(),
'int.to.str': IntToStr(),
'str.substr': Substr(),
'str.len': StrLen(),
'str.to.int': StrToInt(),
'str.indexof': StrIndexOf(),
'str.prefixof': StrPrefixOf(),
'str.suffixof': StrSuffixOf(),
'str.contains': StrContains()
}
def __init__(self):
super().__init__(
'str.substr', 3,
(exprtypes.StringType(), exprtypes.IntType(), exprtypes.IntType()),
exprtypes.StringType())
# self.smt_function = z3.Extract
self.eval_children = lambda a, b, c: a[b:(c + b)] if 0 <= b and len(
a) >= (c + b) >= b else ''
def _trivial_solve(self):
ret = exprs.ConstantExpression(exprs.Value(0, exprtypes.IntType()))
if len(self.synth_funs) > 1:
domain_types = tuple([exprtypes.IntType()] * len(self.synth_funs))
ret = exprs.FunctionExpression(semantics_core.CommaFunction(domain_types),
tuple([ret] * len(self.synth_funs)))
self.signature_to_term = {None:ret}
return True
def __init__(self):
super().__init__('mod', 2, (exprtypes.IntType(), exprtypes.IntType()),
exprtypes.IntType())
def eval_c(a, b):
if b != 0:
return a % b if b > 0 else (-a) % (-b)
else:
raise basetypes.PartialFunctionError
self.eval_children = eval_c
self.smt_function = lambda a, b: a % b
def term_to_expr(var, coeff):
if var == 1:
term = exprs.ConstantExpression(
exprs.Value(coeff, exprtypes.IntType()))
else:
if coeff == 1:
term = var
else:
coeff_expr = exprs.ConstantExpression(
exprs.Value(coeff, exprtypes.IntType()))
term = syn_ctx.make_function_expr('mul', var, coeff_expr)
return term
def make_constant_rules(constraints):
constants = set()
for constraint in constraints:
constants |= exprs.get_all_constants(constraint)
constants.add(exprs.ConstantExpression(exprs.Value(1, exprtypes.IntType(), -1)))
constants.add(exprs.ConstantExpression(exprs.Value(0, exprtypes.IntType(), -1)))
const_templates = []
for const in constants:
const_template = grammars.ExpressionRewrite(const)
const_templates.append(const_template)
return const_templates
def z3value_to_value(value, var_info):
if (var_info.variable_type == exprtypes.BoolType()):
return exprs.Value(bool(value), exprtypes.BoolType())
elif (var_info.variable_type == exprtypes.IntType()):
# TODO: Why are these int(str(value)) instead of value.as_long()
return exprs.Value(int(str(value)), exprtypes.IntType())
elif (var_info.variable_type.type_code ==
exprtypes.TypeCodes.bit_vector_type):
return exprs.Value(
BitVector(int(str(value)), var_info.variable_type.size),
var_info.variable_type)
else:
raise basetypes.UnhandledCaseError('solvers.In model_to_point')
def __init__(self, term_signature, spec):
super().__init__()
self.term_signature = term_signature
self.synth_funs = spec.synth_funs
self.spec = spec
self.syn_ctx = self.spec.syn_ctx
self.point_var_exprs = [ exprs.VariableExpression(v) for v in spec.point_vars ]
self.smt_ctx = z3smt.Z3SMTContext()
self.eval_ctx = evaluation.EvaluationContext()
self.canon_apps = [ self.spec.canon_application[sf] for sf in self.synth_funs ]
self.outvars = []
for fn in self.synth_funs:
self.outvars.append(
exprs.VariableExpression(exprs.VariableInfo(
exprtypes.IntType(), 'outvar_' + fn.function_name,
len(self.point_var_exprs) + len(self.outvars))))
self.all_vars = self.point_var_exprs + self.outvars
self.all_vars_z3 = [ _expr_to_smt(v, self.smt_ctx) for v in self.all_vars ]
# self.clauses = spec.get_canon_clauses()
self.lia_clauses = [ [
LIAInequality.from_expr(exprs.substitute_all(disjunct, list(zip(self.canon_apps, self.outvars))))
for disjunct in clause ]
for clause in spec.get_canon_clauses() ]
self.rewritten_spec = exprs.substitute_all(
self.spec.get_canonical_specification(),
list(zip(self.canon_apps, self.outvars)))
def to_expr(self, syn_ctx):
def term_to_expr(var, coeff):
if var == 1:
term = exprs.ConstantExpression(
exprs.Value(coeff, exprtypes.IntType()))
else:
if coeff == 1:
term = var
else:
coeff_expr = exprs.ConstantExpression(
exprs.Value(coeff, exprtypes.IntType()))
term = syn_ctx.make_function_expr('mul', var, coeff_expr)
return term
terms = [
term_to_expr(var, coeff) for var, coeff in self.coeffs.items()
if coeff != 0
]
if len(terms) == 0:
return exprs.ConstantExpression(exprs.Value(
0, exprtypes.IntType()))
else:
return reduce(lambda a, b: syn_ctx.make_function_expr('+', a, b),
terms)
def lia_unification_solver(theory, syn_ctx, synth_funs, grammar_map, specification, verifier):
if theory != 'LIA':
raise UnsuitableSolverException('LIA Unification Solver: Not LIA theory')
if any([sf.range_type != exprtypes.IntType() for sf in synth_funs ]):
raise UnsuitableSolverException('LIA Unification Solver: Cannot handle bool return values yet')
if not specification.is_pointwise():
raise UnsuitableSolverException('LIA Unification Solver: Not pointwise spec')
okay, massaging = full_lia_grammars(grammar_map)
if not okay:
raise UnsuitableSolverException('LIA Unification Solver: Could not get LIA full grammar')
term_solver = termsolvers_lia.SpecAwareLIATermSolver(specification.term_signature, specification)
unifier = unifiers_lia.SpecAwareLIAUnifier(None, term_solver, synth_funs, syn_ctx, specification)
solver = solvers.Solver(syn_ctx)
solutions = solver.solve(
enumerators.NullGeneratorFactory(),
term_solver,
unifier,
verifier,
verify_term_solve=False
)
solution = next(solutions)
final_solution = rewrite_solution(synth_funs, solution, reverse_mapping=None)
final_solution = lia_massager.massage_full_lia_solution(syn_ctx, synth_funs, final_solution, massaging)
if final_solution is None:
raise UnsuitableSolverException('LIA Unification Solver: Could not massage back solution')
return final_solution
def __init__(self):
super().__init__(
'str.substr', 3,
(exprtypes.StringType(), exprtypes.IntType(), exprtypes.IntType()),
exprtypes.StringType())
# self.smt_function = z3.Extract
def substr(string, start, offset):
if start < 0 or offset < 0:
return ''
elif start + offset > len(string):
return string[start:]
else:
return string[start:(start + offset)]
self.eval_children = lambda a, b, c: substr(a, b, c)
def _constant_to_string(constant_type, constant_value):
if constant_type == exprtypes.BoolType():
return str(constant_value).lower()
elif constant_type == exprtypes.IntType():
return str(constant_value)
elif constant_type == exprtypes.StringType():
return '"%s"' % constant_value
else:
return utils.bitvector_to_string(constant_value, constant_type.size)
def solve(self):
if len(self.points) == 0:
print("Trivial solve!")
return self._trivial_solve()
print("-----------------")
print("Nontrivial solve!")
for point in self.points:
print("POINT:", [ p.value_object for p in point])
for sig, term in self.signature_to_term.items():
print('SIGTOTERM:', str(sig), _expr_to_str(term))
intro_var_signature = []
for point in self.points:
ivs = point[:len(self.spec.intro_vars)]
intro_var_signature.append((ivs, point))
# Nobody can understand what python groupby returns!!!
# ivs_groups = itertools.groupby(
# sorted(intro_var_signature, key=lambda a: a[0]),
# key=lambda a: a[0])
curr_ivs = None
ivs_groups = []
for ivs, point in intro_var_signature:
if ivs == curr_ivs:
ivs_groups[-1][1].append(point)
else:
ivs_groups.append((ivs, [point]))
curr_ivs = ivs
for ivs, points in ivs_groups:
print("A:")
terms = self._single_solve(ivs, points)
print("C:", [ exprs.expression_to_string(t) for t in terms ])
new_terms = []
for term, sf in zip(terms, self.synth_funs):
new_terms.append(exprs.substitute_all(term,
list(zip(self.spec.intro_vars, self.spec.formal_params[sf]))))
terms = new_terms
print([ _expr_to_str(t) for t in terms ])
sig = self.signature_factory()
if len(self.synth_funs) > 1:
domain_types = tuple([exprtypes.IntType()] * len(self.synth_funs))
single_term = exprs.FunctionExpression(semantics_core.CommaFunction(domain_types),
tuple(terms))
else:
single_term = terms[0]
for i, t in enumerate(self.term_signature(single_term, self.points)):
if t:
sig.add(i)
self.signature_to_term[sig] = single_term
print("-----------------")
return True
def sexp_to_type(sexp):
if type(sexp) == list and sexp[0] == 'BitVec':
assert type(sexp[1]) == tuple and sexp[1][0] == 'Int'
length = sexp[1][1]
return exprtypes.BitVectorType(length)
elif sexp == 'Int':
return exprtypes.IntType()
elif sexp == 'Bool':
return exprtypes.BoolType()
elif sexp == 'String':
return exprtypes.StringType()
else:
raise Exception("Unknown type: %s" % str(sexp))
def solve_inequalities_one_outvar(model, outvar, inequalities, syn_ctx):
if len(inequalities) == 0:
return [exprs.ConstantExpression(exprs.Value(0, exprtypes.IntType()))]
bounds = [ineq.get_bounds(outvar) for ineq in inequalities]
eqs = [(c, eq_exp) for (c, (_, eq_exp, _)) in bounds if eq_exp is not None]
lbs = [(c, lb_exp) for (c, (lb_exp, _, _)) in bounds if lb_exp is not None]
ubs = [(c, ub_exp) for (c, (_, _, ub_exp)) in bounds if ub_exp is not None]
# Equalities
if len(eqs) > 0:
rhs = eqs[0][1].to_expr(syn_ctx)
if eqs[0][0] == 1:
return [rhs]
else:
return [
syn_ctx.make_function_expr(
'div', rhs,
exprs.ConstantExpression(
exprs.Value(eqs[0][0], exprtypes.IntType())))
]
# Upper bounds
if len(ubs) > 0:
tightest_ub = min(ubs, key=lambda a: a[1].eval(model) / a[0])
if tightest_ub is not None:
coeff = tighest_ub[0]
rhs = tightest_ub[1].to_expr(syn_ctx)
if coeff == 1:
return [rhs]
else:
return [
syn_ctx.make_function_expr(
'div', rhs,
exprs.ConstantExpression(
exprs.Value(coeff, exprtypes.IntType())))
]
# Lower bounds
if len(lbs) > 0:
tightest_lb = max(lbs, key=lambda a: a[1].eval(model) / a[0])
if tightest_lb is not None:
coeff = tightest_lb[0]
rhs = tightest_lb[1].to_expr(syn_ctx)
if coeff == 1:
return [rhs]
return [
syn_ctx.make_function_expr(
'div',
syn_ctx.make_function_expr(
'add', rhs,
exprs.ConstantExpression(
exprs.Value(1, exprtypes.IntType()))),
exprs.ConstantExpression(
exprs.Value(coeff, exprtypes.IntType())))
]
return exprs.ConstantExpression(exprs.Value(0, exprtypes.IntType()))
def test_cnf_conversion():
from core import synthesis_context
from semantics import semantics_core
from semantics import semantics_lia
syn_ctx = synthesis_context.SynthesisContext(
semantics_core.CoreInstantiator(), semantics_lia.LIAInstantiator())
var_exprs = [
syn_ctx.make_variable_expr(exprtypes.IntType(), 'x%d' % i)
for i in range(10)
]
max_fun = syn_ctx.make_synth_function('max', [exprtypes.IntType()] * 10,
exprtypes.IntType())
max_app = syn_ctx.make_function_expr(max_fun, *var_exprs)
max_ge_vars = [
syn_ctx.make_function_expr('ge', max_app, var_expr)
for var_expr in var_exprs
]
max_eq_vars = [
syn_ctx.make_function_expr('eq', max_app, var_expr)
for var_expr in var_exprs
]
formula1 = syn_ctx.make_ac_function_expr('or', *max_eq_vars)
formula2 = syn_ctx.make_ac_function_expr('and', *max_ge_vars)
formula = syn_ctx.make_ac_function_expr('and', formula1, formula2)
cnf_converter = CNFConverter()
cnf_clauses, cnf_expr = cnf_converter.apply(formula, syn_ctx)
# print(exprs.expression_to_string(cnf_expr))
# print([exprs.expression_to_string(cnf_clause) for cnf_clause in cnf_clauses])
# print(check_single_invocation_property(formula, syn_ctx))
binary_max = syn_ctx.make_synth_function(
'max2', [exprtypes.IntType(), exprtypes.IntType()],
exprtypes.IntType())
binary_max_app = syn_ctx.make_function_expr(binary_max, var_exprs[0],
var_exprs[1])
binary_max_app_rev = syn_ctx.make_function_expr(binary_max, var_exprs[1],
var_exprs[0])
# non_separable = syn_ctx.make_function_expr('eq', binary_max_app, binary_max_app_rev)
# print(check_single_invocation_property(non_separable, syn_ctx))
# max_rec = syn_ctx.make_function_expr(binary_max, binary_max_app, binary_max_app)
# non_separable2 = syn_ctx.make_function_expr('eq', max_rec, binary_max_app)
# print(check_single_invocation_property(non_separable2, syn_ctx))
canonicalize_specification(formula, syn_ctx)
separable1 = syn_ctx.make_function_expr('ge', binary_max_app, var_exprs[0])
separable2 = syn_ctx.make_function_expr('ge', binary_max_app_rev,
var_exprs[0])
separable3 = syn_ctx.make_ac_function_expr(
'or', syn_ctx.make_function_expr('eq', binary_max_app, var_exprs[0]),
syn_ctx.make_function_expr('eq', binary_max_app, var_exprs[1]))
separable = syn_ctx.make_ac_function_expr('and', separable1, separable2,
separable3)
# print(check_single_invocation_property(separable, syn_ctx))
canonicalize_specification(separable, syn_ctx)
def __init__(self):
super().__init__('str.to.int', 1, (exprtypes.StringType(), ),
exprtypes.IntType())
# self.smt_function = z3.Stoi
def eval_c(a):
try:
if all(map(lambda x: '0' <= x <= '9', a)):
return int(a)
else:
return -1
except ValueError:
return -1
self.eval_children = eval_c
def string_to_constant_rewrite(topsymb):
if topsymb.isdigit() or (topsymb.startswith('-') and len(topsymb) >= 2
and topsymb[1:].isdigit):
num = -1 * int(topsymb[1:]) if topsymb.startswith('-') else int(
topsymb)
return grammars.ExpressionRewrite(
exprs.ConstantExpression(exprs.Value(num,
exprtypes.IntType())))
elif topsymb.startswith('#x'): # bitvector
num = int('0' + topsymb[1:], 16)
bitsize = (len(topsymb) - 2) * 4
return grammars.ExpressionRewrite(
exprs.ConstantExpression(
exprs.Value(num, exprtypes.BitVectorType(bitsize))))
else: # boolean
return grammars.ExpressionRewrite(
exprs.ConstantExpression(
exprs.Value(bool(topsymb), exprtypes.BoolType())))
def rewrite_lia_term(syn_ctx, lia_term, neg, consts, constant_multiplication):
c = lia_term.get_const()
linear_terms = [
make_linear_term(syn_ctx, v, coeff, consts, neg,
constant_multiplication)
for (v, coeff) in lia_term.get_var_coeff_pairs()
]
if c != 0:
new_term = make_constant(syn_ctx, c, consts, neg)
if new_term is None:
return None
elif len(linear_terms) > 0:
new_term = linear_terms[0]
linear_terms = linear_terms[1:]
else:
if 0 in consts:
return exprs.ConstantExpression(exprs.Value(
0, exprtypes.IntType()))
else:
return None
for nt in linear_terms:
new_term = syn_ctx.make_function_expr('+', nt, new_term)
return new_term
def make_constant(syn_ctx, c, consts, neg):
if c in consts:
return exprs.ConstantExpression(exprs.Value(c, exprtypes.IntType()))
if -c in consts and neg and 0 in consts:
return syn_ctx.make_function_expr(
'-', exprs.ConstantExpression(exprs.Value(0, exprtypes.IntType())),
exprs.ConstantExpression(exprs.Value(-c, exprtypes.IntType())))
if c > 0:
ret = exprs.ConstantExpression(exprs.Value(1, exprtypes.IntType()))
for x in range(1, c):
ret = syn_ctx.make_function_expr(
'+', ret,
exprs.ConstantExpression(exprs.Value(1, exprtypes.IntType())))
return ret
elif c < 0 and neg and 0 in consts:
return syn_ctx.make_function_expr(
'-', exprs.ConstantExpression(exprs.Value(0, exprtypes.IntType())),
make_constant(syn_ctx, -c, consts, neg))
return None
def unify(self):
term_solver = self.term_solver
sig_to_term = term_solver.get_signature_to_term()
# print([ f.function_name for f in self.synth_funs])
# for point in self.points:
# print([ c.value_object for c in point])
# for (sig, term) in sig_to_term.items():
# print(str(sig), exprs.expression_to_string(term))
eval_ctx = self.eval_ctx
self.last_dt_size = 0
triv = self._try_trivial_unification()
if triv is not None:
yield ("TERM", triv)
return
# print([ [ pi.value_object for pi in p ] for p in self.points])
pred_terms = []
# Pick terms which cover maximum number of points
sigs = [(s, s) for s in sig_to_term.keys()]
while True:
full_sig, curr_sig = max(sigs, key=lambda fc: len(fc[1]))
# We have covered all points
if len(curr_sig) == 0:
break
term = sig_to_term[full_sig]
pred = self._compute_pre_condition(full_sig, curr_sig, term)
pred_terms.append((pred, term))
pred_sig = BitSet(len(self.points))
for i in curr_sig:
eval_ctx.set_valuation_map(self.points[i])
if evaluation.evaluate_expression_raw(pred, eval_ctx):
pred_sig.add(i)
assert not pred_sig.is_empty()
# Remove newly covered points from all signatures
sigs = [(f, c.difference(pred_sig)) for (f, c) in sigs]
# for pred, term in pred_terms:
# print(_expr_to_str(pred), ' ====> ', _expr_to_str(term))
e = self._pred_term_list_to_expr(pred_terms)
if len(self.synth_funs) == 1:
act_params = self.spec.canon_application[
self.synth_funs[0]].children
form_params = self.spec.formal_params[self.synth_funs[0]]
e = exprs.substitute_all(e, list(zip(act_params, form_params)))
else:
es = []
for ep, sf in zip(e, self.synth_funs):
act_params = self.spec.canon_application[sf].children
form_params = self.spec.formal_params[sf]
es.append(
exprs.substitute_all(ep, list(zip(act_params,
form_params))))
domain_types = tuple([exprtypes.IntType()] * len(self.synth_funs))
e = exprs.FunctionExpression(
semantics_core.CommaFunction(domain_types), tuple(es))
yield ('TERM', e)
def make_default_grammar(syn_ctx, theory, return_type, args):
int_type = exprtypes.IntType()
bool_type = exprtypes.BoolType()
if theory == 'LIA':
[start, start_bool,
const] = ['Start', 'StartBool', 'ConstantIntegerType']
nts = [start, start_bool, const]
nt_type = {start: int_type, start_bool: bool_type, const: int_type}
rules = {start: [], start_bool: [], const: []}
ntr_start = NTRewrite(start, int_type)
ntr_startbool = NTRewrite(start_bool, bool_type)
ntr_const = NTRewrite(const, int_type)
[ add_func, sub_func, mul_func, div_func, mod_func ] = \
[ syn_ctx.make_function(name, int_type, int_type)
for name in [ 'add', 'sub', 'mul', 'div', 'mod' ] ]
ite_func = syn_ctx.make_function('ite', bool_type, int_type, int_type)
[ and_func, or_func ] = \
[ syn_ctx.make_function(name, bool_type, bool_type)
for name in [ 'and', 'or' ] ]
not_func = syn_ctx.make_function('not', bool_type)
[ eq_func, ne_func, le_func, lt_func, ge_func, gt_func ] = \
[ syn_ctx.make_function(name, int_type, int_type)
for name in [ '=', 'ne', '<=', '<', '>=', '>' ] ]
# Start rules:
# Args
for arg in args:
if exprs.get_expression_type(arg) == int_type:
rules[start].append(ExpressionRewrite(arg))
elif exprs.get_expression_type(arg) == bool_type:
rules[start_bool].append(ExpressionRewrite(arg))
# Constants
rules[start].append(
ExpressionRewrite(
exprs.ConstantExpression(exprs.Value(1, int_type))))
rules[start].append(
ExpressionRewrite(
exprs.ConstantExpression(exprs.Value(0, int_type))))
rules[start].append(ntr_const)
# Start + Start, Start - Start,
rules[start].append(FunctionRewrite(add_func, ntr_start, ntr_start))
rules[start].append(FunctionRewrite(sub_func, ntr_start, ntr_start))
# Start * Constant, Start / Constant, Start mod Constant
rules[start].append(FunctionRewrite(mul_func, ntr_start, ntr_start))
rules[start].append(FunctionRewrite(div_func, ntr_start, ntr_start))
rules[start].append(FunctionRewrite(mod_func, ntr_start, ntr_start))
# ITE
rules[start].append(
FunctionRewrite(ite_func, ntr_startbool, ntr_start, ntr_start))
# Start bool rules
# And, or, not
rules[start_bool].append(
ExpressionRewrite(
exprs.ConstantExpression(exprs.Value(False, bool_type))))
rules[start_bool].append(
ExpressionRewrite(
exprs.ConstantExpression(exprs.Value(True, bool_type))))
rules[start_bool].append(
FunctionRewrite(and_func, ntr_startbool, ntr_startbool))
rules[start_bool].append(
FunctionRewrite(or_func, ntr_startbool, ntr_startbool))
rules[start_bool].append(FunctionRewrite(not_func, ntr_startbool))
# comparison ops
rules[start_bool].append(FunctionRewrite(eq_func, ntr_start,
ntr_start))
rules[start_bool].append(FunctionRewrite(ne_func, ntr_start,
ntr_start))
rules[start_bool].append(FunctionRewrite(le_func, ntr_start,
ntr_start))
rules[start_bool].append(FunctionRewrite(lt_func, ntr_start,
ntr_start))
rules[start_bool].append(FunctionRewrite(ge_func, ntr_start,
ntr_start))
rules[start_bool].append(FunctionRewrite(gt_func, ntr_start,
ntr_start))
# Constant rules
rules[const].append(
ExpressionRewrite(
exprs.ConstantExpression(exprs.Value(1, int_type))))
rules[const].append(
ExpressionRewrite(
exprs.ConstantExpression(exprs.Value(0, int_type))))
rules[const].append(FunctionRewrite(add_func, ntr_const, ntr_const))
rules[const].append(FunctionRewrite(add_func, ntr_const, ntr_const))
rules[const].append(FunctionRewrite(sub_func, ntr_const, ntr_const))
if return_type == int_type:
ret = Grammar(nts, nt_type, rules, start)
elif return_type == bool_type:
ret = Grammar(nts, nt_type, rules, start_bool)
else:
raise NotImplementedError
ret.from_default = True
return ret
elif theory == 'BV':
from semantics import semantics_bv
from semantics import semantics_core
print("ARSAYS: Default bit-vec grammar shouldn't be used!")
(start, start_bool) = ('Start', 'StartBool')
bv_size = 64
nts = [start, start_bool]
(bv_type, bool_type) = (exprtypes.BitVectorType(bv_size),
exprtypes.BoolType())
nt_type = {start: bv_type, start_bool: bool_type}
rules = {start: [], start_bool: []}
ntr_start = NTRewrite(start, bv_type)
ntr_start_bool = NTRewrite(start_bool, bool_type)
rules[start].extend(
map(
lambda x: ExpressionRewrite(
exprs.ConstantExpression(exprs.Value(x, bv_type))),
[0, 1]))
for func in [
semantics_bv.BVNot(bv_size),
semantics_bv.BVAdd(bv_size),
semantics_bv.BVAnd(bv_size),
semantics_bv.BVOr(bv_size),
semantics_bv.BVNeg(bv_size),
semantics_bv.BVAdd(bv_size),
semantics_bv.BVMul(bv_size),
semantics_bv.BVSub(bv_size),
semantics_bv.BVUDiv(bv_size),
semantics_bv.BVSDiv(bv_size),
semantics_bv.BVSRem(bv_size),
semantics_bv.BVURem(bv_size),
semantics_bv.BVShl(bv_size),
semantics_bv.BVLShR(bv_size),
semantics_bv.BVAShR(bv_size),
semantics_bv.BVUlt(bv_size),
semantics_bv.BVUle(bv_size),
semantics_bv.BVUge(bv_size),
semantics_bv.BVUgt(bv_size),
semantics_bv.BVSle(bv_size),
semantics_bv.BVSlt(bv_size),
semantics_bv.BVSge(bv_size),
semantics_bv.BVSgt(bv_size),
semantics_bv.BVXor(bv_size),
semantics_bv.BVXNor(bv_size),
semantics_bv.BVNand(bv_size),
semantics_bv.BVNor(bv_size),
# semantics_bv.BVComp(bv_size)
semantics_core.EqFunction(bv_type)
]:
assert all([t == bv_type for t in func.domain_types])
args = [ntr_start] * len(func.domain_types)
if func.range_type == bv_type:
rules[start].append(FunctionRewrite(func, *args))
elif func.range_type == bool_type:
rules[start_bool].append(FunctionRewrite(func, *args))
else:
assert False
ite_func = semantics_core.IteFunction(bv_type)
rules[start].append(
FunctionRewrite(ite_func, ntr_start_bool, ntr_start, ntr_start))
if return_type == bv_type:
ret = Grammar(nts, nt_type, rules, start)
elif return_type == bool_type:
ret = Grammar(nts, nt_type, rules, start_bool)
else:
raise NotImplementedError
ret.from_default = True
return ret
elif theory == 'SLIA':
raise NotImplementedError
else:
raise NotImplementedError
def __init__(self):
super().__init__('-', 1, (exprtypes.IntType(), ), exprtypes.IntType())
self.eval_children = lambda x: -x
self.smt_function = lambda x: -x
def _generate_test_generators():
from core import synthesis_context
from semantics import semantics_core
from semantics import semantics_lia
syn_ctx = synthesis_context.SynthesisContext(
semantics_core.CoreInstantiator(), semantics_lia.LIAInstantiator())
var_a_info = syn_ctx.make_variable(exprtypes.IntType(), 'varA', 0)
var_b_info = syn_ctx.make_variable(exprtypes.IntType(), 'varB', 1)
var_c_info = syn_ctx.make_variable(exprtypes.IntType(), 'varC', 2)
var_a = exprs.VariableExpression(var_a_info)
var_b = exprs.VariableExpression(var_b_info)
var_c = exprs.VariableExpression(var_c_info)
zero_value = exprs.Value(0, exprtypes.IntType())
one_value = exprs.Value(1, exprtypes.IntType())
zero_exp = exprs.ConstantExpression(zero_value)
one_exp = exprs.ConstantExpression(one_value)
var_generator = LeafGenerator([var_a, var_b, var_c], 'Variable Generator')
const_generator = LeafGenerator([zero_exp, one_exp], 'Constant Generator')
leaf_generator = AlternativesGenerator([var_generator, const_generator],
'Leaf Term Generator')
generator_factory = RecursiveGeneratorFactory()
start_generator_ph = generator_factory.make_placeholder('Start')
start_bool_generator_ph = generator_factory.make_placeholder('StartBool')
add_fun = syn_ctx.make_function('add', exprtypes.IntType(),
exprtypes.IntType())
sub_fun = syn_ctx.make_function('sub', exprtypes.IntType(),
exprtypes.IntType())
ite_fun = syn_ctx.make_function('ite', exprtypes.BoolType(),
exprtypes.IntType(), exprtypes.IntType())
and_fun = syn_ctx.make_function('and', exprtypes.BoolType(),
exprtypes.BoolType())
or_fun = syn_ctx.make_function('or', exprtypes.BoolType(),
exprtypes.BoolType())
not_fun = syn_ctx.make_function('not', exprtypes.BoolType())
le_fun = syn_ctx.make_function('le', exprtypes.IntType(),
exprtypes.IntType())
ge_fun = syn_ctx.make_function('ge', exprtypes.IntType(),
exprtypes.IntType())
eq_fun = syn_ctx.make_function('eq', exprtypes.IntType(),
exprtypes.IntType())
start_generator = \
generator_factory.make_generator('Start',
AlternativesGenerator,
([leaf_generator] +
[FunctionalGenerator(add_fun,
[start_generator_ph,
start_generator_ph]),
FunctionalGenerator(sub_fun,
[start_generator_ph,
start_generator_ph]),
FunctionalGenerator(ite_fun,
[start_bool_generator_ph,
start_generator_ph,
start_generator_ph])],))
generator_factory.make_generator('StartBool', AlternativesGenerator, ([
FunctionalGenerator(
and_fun, [start_bool_generator_ph, start_bool_generator_ph]),
FunctionalGenerator(
or_fun, [start_bool_generator_ph, start_bool_generator_ph]),
FunctionalGenerator(not_fun, [start_bool_generator_ph]),
FunctionalGenerator(le_fun, [start_generator_ph, start_generator_ph]),
FunctionalGenerator(eq_fun, [start_generator_ph, start_generator_ph]),
FunctionalGenerator(ge_fun, [start_generator_ph, start_generator_ph])
], ))
return start_generator
def __init__(self):
super().__init__('int.to.str', 1, (exprtypes.IntType(), ),
exprtypes.StringType())
# self.smt_function = z3.Itos
self.eval_children = lambda a: str(a) if a >= 0 else ''
def __init__(self):
super().__init__('str.at', 2,
(exprtypes.StringType(), exprtypes.IntType()),
exprtypes.StringType())
# self.smt_function = lambda a,b: a[b]
self.eval_children = lambda a, b: a[b] if 0 <= b < len(a) else ''
def __init__(self):
super().__init__('str.len', 1, (exprtypes.StringType(), ),
exprtypes.IntType())
# self.smt_function = z3.Length
self.eval_children = lambda a: len(a)
def __init__(self):
super().__init__('str.indexof', 3,
(exprtypes.StringType(), exprtypes.StringType(),
exprtypes.IntType()), exprtypes.IntType())
# self.smt_function = z3.IndexOf
self.eval_children = str.find
