def preprocess_operators(term_exprs, pred_exprs):
eval_context = evaluation.EvaluationContext()
bitsize = 64
bvlshr = semantics_bv.BVLShR(bitsize)
new_term_exprs = set([])
new_pred_exprs = set([])
for term_expr, f in term_exprs:
subst_pairs = set([])
all_exprs = exprs.get_all_exprs(term_expr)
for e in all_exprs:
if exprs.is_function_expression(e):
if e.function_info.function_name == 'bvudiv':
if exprs.is_constant_expression(e.children[1]):
value = evaluation.evaluate_expression_raw(
e.children[1], eval_context)
new_right_child = exprs.ConstantExpression(
exprs.Value(
BitVector(int(math.log2(value.value)),
bitsize),
exprtypes.BitVectorType(bitsize)))
subst_pairs.add(
(e,
exprs.FunctionExpression(
bvlshr, (e.children[0], new_right_child))))
new_term_expr = term_expr
for (old_term, new_term) in subst_pairs:
new_term_expr = exprs.substitute(new_term_expr, old_term, new_term)
new_term_exprs.add((new_term_expr, f))
for pred_expr, f in pred_exprs:
subst_pairs = set([])
all_exprs = exprs.get_all_exprs(pred_expr)
for e in all_exprs:
if exprs.is_function_expression(e):
if e.function_info.function_name == 'bvudiv':
if exprs.is_constant_expression(e.children[1]):
value = evaluation.evaluate_expression_raw(
e.children[1], eval_context)
new_right_child = exprs.ConstantExpression(
exprs.Value(
BitVector(int(math.log2(value.value)),
bitsize),
exprtypes.BitVectorType(bitsize)))
subst_pairs.add(
(e,
exprs.FunctionExpression(
bvlshr, (e.children[0], new_right_child))))
new_pred_expr = pred_expr
for (old_term, new_term) in subst_pairs:
new_pred_expr = exprs.substitute(new_pred_expr, old_term, new_term)
new_pred_exprs.add((new_pred_expr, f))
return (new_term_exprs, new_pred_exprs)
def fetchop_func_pbe(specification, grammar, expr):
if (exprs.is_constant_expression(expr)):
if specification.theory == 'SLIA':
eval_context = evaluation.EvaluationContext()
value = evaluation.evaluate_expression_raw(expr, eval_context)
if isinstance(value, int):
result = fetchop(expr)
else:
const_category = get_constant_category(
value, specification.valuations)
result = aconst_to_string(const_category)
else:
result = fetchop(expr)
elif (exprs.is_formal_parameter_expression(expr)):
# if isinstance(specification, specifications.PBESpec):
# n_params = len(specification.synth_fun.domain_types)
# else: # formula spec
# n_params = len(specification.synth_funs[0].domain_types)
# param_category = get_parameter_category(expr.parameter_position, n_params)
# # print(exprs.expression_to_string(expr), ' ', param_category)
# only a single parameter
result = aparam_to_string(0)
else:
result = fetchop(expr)
# print(exprs.expression_to_string(expr), ' ', result)
return result
def term_signature(self, term, points):
eval_ctx = self.eval_ctx
if len(self.synth_funs) > 1:
assert exprs.is_application_of(term, ',')
interpretations = term.children
for func, interpretation in zip(self.synth_funs, interpretations):
eval_ctx.set_interpretation(func, interpretation)
else:
eval_ctx.set_interpretation(self.synth_funs[0], term)
retval = []
for point in points:
eval_ctx.set_valuation_map(point)
try:
r = evaluation.evaluate_expression_raw(self.canon_spec,
eval_ctx)
# print(exprs.expression_to_string(term), "is", r, "on", [ p.value_object for p in point ])
# print(eval_ctx.eval_stack_top)
retval.append(r)
except (basetypes.PartialFunctionError,
basetypes.UnboundLetVariableError):
# Exceptions may be raised when applying partial functions like div, mod, etc
retval.append(False)
return retval
def add_point(point, pred_sig_list, term_sig_list):
points.append(point)
eval_ctx.set_valuation_map(point)
solv = evaluation.evaluate_expression_raw(sol, eval_ctx)
new_pred_sig_list = [
utils.bitset_extend(
sig, evaluation.evaluate_expression_raw(pred, eval_ctx))
for (sig, pred) in zip(pred_sig_list, preds)
]
new_term_sig_list = [
utils.bitset_extend(
sig,
solv == evaluation.evaluate_expression_raw(term, eval_ctx))
for (sig, term) in zip(term_sig_list, terms)
]
return (new_pred_sig_list, new_term_sig_list)
def _verify_expr(self, term):
eval_ctx = self.eval_ctx
for point, value in self.valuations.items():
eval_ctx.set_valuation_map(point)
result = evaluation.evaluate_expression_raw(term, eval_ctx)
if result != value:
return [point]
return term
def _initialize_valuations(self, expr_valuations):
eval_ctx = self.eval_ctx
def evaluate(t):
return
self.valuations = {}
for args, value in expr_valuations:
raw_args = tuple([ evaluation.evaluate_expression(a, eval_ctx) for a in args ])
raw_value = evaluation.evaluate_expression_raw(value, eval_ctx)
self.valuations[raw_args] = raw_value
def _verify_guard_term_list(self, guard_term_list, dt_tuple):
eval_ctx = self.eval_ctx
cex_points = []
selected_leaf_terms = []
at_least_one_branch_failed = False
for (pred, term_list) in guard_term_list:
good_terms = term_list.copy()
for point, value in self.spec.valuations.items():
eval_ctx.set_valuation_map(point)
try:
if not evaluation.evaluate_expression_raw(pred, eval_ctx):
continue
next_good_terms = []
for term in good_terms:
curr_value = evaluation.evaluate_expression_raw(
term, eval_ctx)
if curr_value == value:
next_good_terms.append(term)
good_terms = next_good_terms
if len(good_terms) == 0:
at_least_one_branch_failed = True
cex_points.append(point)
break
except:
continue
if len(good_terms) > 0:
selected_leaf_terms.append(good_terms[0])
if at_least_one_branch_failed:
retval = list(set(cex_points))
retval.sort()
return retval
else:
(term_list, term_sig_list, pred_list, pred_sig_list, dt) = dt_tuple
e = decision_tree_to_expr(dt, pred_list, self.syn_ctx,
selected_leaf_terms)
return e
def _compute_signature(self, expr):
if self.applications is None:
# Single invocation (not multifunction)
points = self.points
res = [ None ] * len(points)
for i in range(len(points)):
# Assumes introvars are at the beginning of the point
self.eval_ctx.set_valuation_map(points[i])
res[i] = evaluation.evaluate_expression_raw(expr, self.eval_ctx)
return res
else:
points = self.points
res = [ None ] * len(points)
for i in range(len(points)):
sig = []
for profile in self.point_profiles[i]:
self.eval_ctx.set_valuation_map(profile)
sig.append(evaluation.evaluate_expression_raw(expr, self.eval_ctx))
res[i] = sig
return res
def verify_term_solve(self, terms):
eval_ctx = self.eval_ctx
for point, value in self.valuations.items():
eval_ctx.set_valuation_map(point)
found_one = False
for term in terms:
result = evaluation.evaluate_expression_raw(term, eval_ctx)
if result == value:
found_one = True
if not found_one:
return [point]
return None
def get_pbespec_kind_bv(specification, grammar):
generator_factory = enumerators.RecursiveGeneratorFactory()
term_generator = grammar.to_generator(generator_factory)
max_size = 3
term_generator.set_size(max_size)
smallexprs = [exp for exp in term_generator.generate()]
inputs2values = {}
valuations = specification.valuations
# value : str | int | utils.BitVector | bool
# valuations: exprs.Value tuple -> str | int | utils.BitVector | bool
# we make inputs be of primitive type
flags = set([])
eval_context = evaluation.EvaluationContext()
for inputs, output in valuations.items():
eval_context.set_valuation_map(inputs)
values = []
for se in smallexprs:
try:
values.append(
evaluation.evaluate_expression_raw(se, eval_context))
except:
continue
inputs2values[inputs] = values
if (any(is_sub(v, output) for v in values)):
flags.add(PBESpecKind.SOME_INPUT_BELONG_TO_OUTPUT)
if (any(is_sub(output, v) for v in values)):
flags.add(PBESpecKind.SOME_OUTPUT_BELONG_TO_INPUT)
if (any(is_intersection_nonempty(output, v) for v in values)):
flags.add(PBESpecKind.SOME_INPUT_INTERSECT_OUTPUT)
# if (any(i1 != i2 and is_sub(i1, i2) for (i1, i2) in itertools.product(inputs, inputs))):
# flags.add(PBESpecKind.SOME_INPUT_BELONG_TO_SOME_INPUT)
if (all(
any(is_sub(value, output) for value in inputs2values[inputs])
for inputs, output in valuations.items())):
flags.add(PBESpecKind.ALL_INPUT_BELONG_TO_OUTPUT)
if (all(
any(is_sub(output, value) for value in inputs2values[inputs])
for inputs, output in valuations.items())):
flags.add(PBESpecKind.ALL_OUTPUT_BELONG_TO_INPUT)
if (all(
any(
is_intersection_nonempty(output, value)
for value in inputs2values[inputs])
for inputs, output in valuations.items())):
flags.add(PBESpecKind.ALL_INPUT_INTERSECT_OUTPUT)
if len(flags) == 0:
flags.add(PBESpecKind.NO_INTERSECTION)
return tuple(flags)
def compute_indicator(term, points):
eval_ctx.set_interpretation(func, term)
retval = []
for point in points:
eval_ctx.set_valuation_map(point)
try:
retval.append(
evaluation.evaluate_expression_raw(
indicator_expr, eval_ctx))
except (basetypes.UnboundLetVariableError,
basetypes.PartialFunctionError):
# Can't mess up on predicates
return [False] * len(points)
return retval
def _verify_expr(self, term):
eval_ctx = self.eval_ctx
for point, value in self.valuations.items():
eval_ctx.set_valuation_map(point)
try:
result = evaluation.evaluate_expression_raw(term, eval_ctx)
if result != value:
if options.allex:
return [
point for point, value in self.valuations.items()
]
else:
return [point]
except:
continue
return term
def evaluate(expr, input, synth_file='./euphony/benchmarks/string/test/phone-5-test.sl'):
'''Evaluate an expression for a given input
Arguments:
- expr(FunctionExpression): The expression to evaluate
- input(str): the input to the given expression.
- synth_file(str): path to a synthesis file defining the available
available grammar. This file doesn't need to correspond to the same
file that the expression was generated from. It just needs to have the
same grammar definition. Constraints are not used in any way. It's
required in order to load the proper logic into the expression
evaluator. This is set to a file containing string logic by default.
Returns:
- (str): output from evaluating expression against given input
'''
eval_ctx = EvaluationContext()
val_map = (Value(input, value_type=StringType()),)
eval_ctx.set_valuation_map(val_map)
# print('attempting to eval: {}'.format(expr))
# print('eval ctx: {} -- {}'.format(val_map, type(val_map)))
# This is pretty flow since it needs to re-read the synthesis file to know
# the grammar that it needs to parse. Personally, I am not so concerned
# about performance, but rather just getting it to work in the first place.
file_sexp = parser.sexpFromFile(synth_file)
benchmark_tuple = parser.extract_benchmark(file_sexp)
(
theories,
syn_ctx,
synth_instantiator,
macro_instantiator,
uf_instantiator,
constraints,
grammar_map,
forall_vars_map,
default_grammar_sfs
) = benchmark_tuple
# We should only have one grammar, so just grab the only key to this map.
# The type of the object is a SynthFun
#print(constraints)
synth_fun = list(grammar_map.keys())[0]
# Pass this into the interpretation along with the expression we're
# attempting to evaluate, or else we'll get an UnboundLetException
eval_ctx.set_interpretation(synth_fun, expr)
return evaluate_expression_raw(expr, eval_ctx)
def term_signature(self, term, points):
# try:
eval_ctx = self.eval_ctx
eval_ctx.set_interpretation(self.synth_fun, term)
synth_fun_expr = self.synth_fun_expr
retval = []
for point in points:
if point not in self.valuations:
# print("Something is almost certainly wrong!")
retval.append(True)
continue
eval_ctx.set_valuation_map(point)
try:
retval.append(self.valuations[point] == evaluation.evaluate_expression_raw(synth_fun_expr, eval_ctx))
except (basetypes.PartialFunctionError, basetypes.UnboundLetVariableError):
retval.append(False)
return retval
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 eval_on_relevent_points(pred):
ret = []
for p in relevent_points:
eval_ctx.set_valuation_map(p)
ret.append(evaluation.evaluate_expression_raw(pred, eval_ctx))
return ret
