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 fetchop_func_formula(specification, grammar, expr):
if (exprs.is_function_expression(expr)):
# assert (exprs.is_function_expression(specification.spec_expr))
# origexpr = specification.spec_expr.children[0]
result = fetchop(expr)
elif (exprs.is_formal_parameter_expression(expr)):
# only a single parameter
result = aparam_to_string(0)
else:
result = fetchop(expr)
return result
def fetchop(expr):
if (exprs.is_function_expression(expr)):
fkind = expr.function_info.function_name
if dummy_pred_name in fkind: return dummy_pred_name
else: return fkind
elif (exprs.is_constant_expression(expr)):
# return str(exprs.get_expression_type(expr))
return exprs.expression_to_string(expr)
elif (exprs.is_formal_parameter_expression(expr)):
return exprs.expression_to_string(expr)
else:
return 'Var'
def from_expr(expr): # Has to be a linear expression
# Base case
if exprs.is_variable_expression(
expr) or exprs.is_formal_parameter_expression(expr):
return LIAExpression({expr: 1})
elif exprs.is_constant_expression(expr):
return LIAExpression({1: expr.value_object.value_object})
func_name = expr.function_info.function_name
if func_name in ['+', 'add']:
return reduce(LIAExpression.__add__,
map(LIAExpression.from_expr, expr.children))
elif func_name == 'sub' or (func_name == '-'
and len(expr.children) == 2):
return LIAExpression.from_expr(
expr.children[0]) - LIAExpression.from_expr(expr.children[1])
elif func_name in ['*', 'mul']:
return reduce(LIAExpression.__mul__,
map(LIAExpression.from_expr, expr.children))
elif func_name == '-':
return -LIAExpression.from_expr(expr.children[0])
else:
# print(_expr_to_str(expr))
raise NotImplementedError
def identify_lia_grammars(synth_fun, grammar):
# We want to identify difference bounds, octogons, and full linear arithmetic
# We check the following:
# Start rewrites to variables, at least 0,1, Start + Start, Start - Start, ite (Cond) Start Start
# Cond rewrites to Start <= Start, Start < Start, etc
start = grammar.start
# Can start rewrite to all arguments?
expr_rewrites = []
func_rewrites = []
for rewrite in grammar.rules[start]:
if type(rewrite) == ExpressionRewrite:
expr_rewrites.append(rewrite)
elif type(rewrite) == FunctionRewrite:
func_rewrites.append(rewrite)
else:
# We really should be doing this transitively
pass
formal_params = set()
consts = set()
for er in expr_rewrites:
expr = er.expr
if exprs.is_formal_parameter_expression(expr):
formal_params.add(expr)
elif exprs.is_constant_expression(expr):
consts.add(expr.value_object.value_object)
if len(formal_params) != len(synth_fun.domain_types):
return None
if not (0 in consts) or not (1 in consts):
return None
funcs = set()
has_ite = False
ite_cond_nt = False
for fr in func_rewrites:
if (len(fr.children) == 2
and all([type(c) == NTRewrite for c in fr.children])
and all([c.non_terminal == start for c in fr.children])):
funcs.add(fr.function_info.function_name)
if (fr.function_info.function_name == 'ite'
and all([type(c) == NTRewrite for c in fr.children])
and all([c.non_terminal == start for c in fr.children[1:]])):
has_ite = True
ite_cond_nt = fr.children[0].non_terminal
if ('+' not in funcs or not has_ite):
return None
comparators = set()
combination_funcs = set()
for r in grammar.rules[ite_cond_nt]:
if type(r) != FunctionRewrite:
continue
if (r.function_info.function_name in ['and', 'or', 'not']
and all([type(c) == NTRewrite for c in r.children])
and all([c.non_terminal == ite_cond_nt for c in r.children])):
combination_funcs.add(r.function_info.function_name)
if (r.function_info.function_name in ['<=', '<', '>=', '>', '=']
and all([type(c) == NTRewrite for c in r.children])
and all([c.non_terminal == start for c in r.children])):
comparators.add(r.function_info.function_name)
if '<=' not in comparators and '<' not in comparators:
return None
# Term stuff
boolean_combs = ('and' in combination_funcs) and (
'or' in combination_funcs) and ('not' in combination_funcs)
negatives = ('-' in funcs)
constant_multiplication = ('*' in funcs)
div = ('div' in funcs)
mod = ('mod' in funcs)
return (boolean_combs, comparators, consts, negatives,
constant_multiplication, div, mod)