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 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 _merge_grammars(sf_grammar_list):
start = "MergedStart"
nts = [start]
nt_type = {}
rules = {}
starts = []
for sf_name, sf_obj, grammar in sf_grammar_list:
renamed_grammar = grammar.add_prefix(sf_name)
nts.extend(renamed_grammar.non_terminals)
nt_type.update(renamed_grammar.nt_type)
rules.update(renamed_grammar.rules)
starts.append(renamed_grammar.start)
comma_function = semantics_core.CommaFunction([ nt_type[s] for s in starts ])
rules[start] = [ grammars.FunctionRewrite(comma_function,
*tuple([ grammars.NTRewrite(s, nt_type[s]) for s in starts ])) ]
nt_type[start] = None
merged_grammar = grammars.Grammar(nts, nt_type, rules, start)
return merged_grammar
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)