def run_init(rhandler, request):
name = rhandler.eval.apply(request[1].resolve(rhandler.C))
arg = rhandler.eval.apply(request[2].resolve(rhandler.C))
if rhandler.verbose:
Logger.msg(rhandler.name, "init " + str(name))
f = rhandler.F.get_function(name)
if f is None:
raise ValueError("Function not registered: " + str(name) +
" request: " + str(request))
f.initialize(arg)
def run_match(self, request, exec_module):
a = request[1].resolve(self.C)
b = request[2].resolve(self.C)
sub_request = request[3]
s = a.match(b)
if self.verbose:
Logger.msg(self.name,
"match %s to %s -> %s" % (str(a), str(b), str(s)))
if s is not None:
self.satisfy_request(sub_request.substitute(s), exec_module)
def run_forall(rhandler, request, exec_module):
domain_map = request[1].resolve(rhandler.C)
sub_request = request[2]
variables = []
choices = []
for var_choice in domain_map:
variables.append(var_choice.get_key())
domain = rhandler.eval.apply(var_choice.get_value())
domain_list = []
for v in domain:
domain_list.append(v)
# domain.add_all_to(domain_list)
choices.append(domain_list)
if rhandler.verbose:
Logger.msg(rhandler.name, "forall choices: " + str(choices))
combos = ComboIterator(choices)
s = Substitution()
for combo in combos:
for i in range(len(combo)):
s.add(variables[i], combo[i])
sub_req_inst = sub_request.substitute(s)
if rhandler.verbose:
Logger.msg(rhandler.name, "calling: " + str(sub_req_inst))
Logger.inc_depth()
rhandler.satisfy_request(sub_req_inst, exec_module)
if rhandler.verbose:
Logger.dec_depth()
def run_list(rhandler, request, exec_module):
if rhandler.verbose:
Logger.msg(rhandler.name, "begin list" + str(request))
Logger.inc_depth()
for sub_request in request:
rhandler.satisfy_request(sub_request, exec_module)
if rhandler.verbose:
Logger.dec_depth()
Logger.msg(rhandler.name, "end list")
def run_write(rhandler, request, exec_module):
value = rhandler.eval.apply(request.get(1).resolve(rhandler.C))
ref = out2ref(request.get(2).resolve(rhandler.C), rhandler.C, exec_module)
if rhandler.verbose:
Logger.msg(rhandler.name, "write %s to %s" % (str(value), str(ref)))
prev_entry = rhandler.C.get_entry(ref.get_ref_target(),
module=ref.get_ref_module())
if prev_entry is None:
prev_type = TYPE_TERM
else:
prev_type = prev_entry.get_type()
out_entry = Entry(prev_type, ref.get_ref_target(), value)
if rhandler.verbose:
Logger.msg(rhandler.name, "Writing: %s" % (str(out_entry)))
rhandler.C.set_entry(out_entry, module=ref.get_ref_module())
def run_if(rhandler, request, exec_module):
condition = request.get(1).resolve(rhandler.C)
condition_computed = rhandler.eval.apply(condition)
if rhandler.verbose:
Logger.msg(rhandler.name, "if " + str(condition))
Logger.msg(rhandler.name, "-> " + str(condition_computed))
if condition_computed.bool_value():
if rhandler.verbose:
Logger.msg(rhandler.name, "then: " + str(request.get(2)))
rhandler.satisfy_request(request.get(2), exec_module)
else:
if rhandler.verbose:
Logger.msg(rhandler.name, "else: " + str(request.get(3)))
rhandler.satisfy_request(request.get(3), exec_module)
def run_loop(rhandler, request, exec_module):
while True:
if rhandler.verbose:
Logger.msg(rhandler.name, "loop")
Logger.inc_depth()
rhandler.satisfy_request(request[1], exec_module)
if rhandler.verbose:
Logger.dec_depth()
def run_while(rhandler, request, exec_module):
if rhandler.verbose:
Logger.msg(rhandler.name, "while")
Logger.inc_depth()
condition = request[1].resolve(rhandler.C)
while rhandler.eval.apply(condition).bool_value():
rhandler.satisfy_request(request[2], exec_module)
condition = request[1].resolve(rhandler.C)
if rhandler.verbose:
Logger.dec_depth()
def check(self, type_def, term):
# Logger.msg("TypeCheck", str(type_def) + " ?? " + str(term))
r = False
if isinstance(type_def, Tuple):
type_class = type_def[0]
if type_class == Symbolic("basic-type"):
e = Tuple([type_def[1], term])
r = self.evaluator.apply(e).bool_value()
elif type_class == Symbolic("set-of"):
subType = type_def.get(1)
if isinstance(term, Set):
r = True
Logger.inc_depth()
for e in term:
if not self.check(subType, e):
#print("---> FAIL")
r = False
break
Logger.dec_depth()
else:
r = False
elif type_class == Symbolic("list-of"):
subType = type_def.get(1)
if isinstance(term, List):
r = True
Logger.inc_depth()
for e in term:
if not self.check(subType, e):
r = False
break
Logger.dec_depth()
else:
r = False
elif type_class == Symbolic("collection-of"):
subType = type_def.get(1)
if isinstance(t, Collection):
r = True
Logger.inc_depth()
for e in term:
if not self.check(subType, e):
r = False
break
Logger.dec_depth()
else:
r = False
elif type_class == Symbolic("signed-tuple"):
signature = type_def.get(1)
min = type_def.get_or_default(Symbolic("min"),
Integer(len(signature)))
max = type_def.get_or_default(Symbolic("max"),
Integer(len(signature)))
repeat = type_def.get_or_default(Symbolic("repeat"),
Integer(1))
tSize = Integer(len(type_def))
repeat_start_idx = len(signature) - repeat.int_value()
if isinstance(term, Tuple) and tSize >= min and tSize <= max:
Logger.inc_depth()
r = True
for i in range(0, len(signature)):
sig_idx = i
if i >= signature.size():
sig_idx = repeat_start_idx + \
(i - signature.size()) % repeat.getIntValue()
if not self.check(signature.get(sig_idx),
term.get(i)):
r = False
break
Logger.dec_depth()
else:
r = False
elif type_class == Symbolic("key-value-tuple"):
keyTypeCol = type_def.get(1)
r = True
Logger.inc_depth()
for kvp in keyTypeCol:
e = term.get(kvp.get_key())
if e is None:
r = False
break
if not self.check(kvp.get_value(), e):
r = False
break
Logger.dec_depth()
elif type_class == Symbolic("enum"):
r = term in type_def.get(1)
elif type_class == Symbolic("numerical-range"):
min = type_def.get_or_default(Symbolic("min"), Infinity.neg())
max = type_def.get_or_default(Symbolic("max"), Infinity.pos())
r = False
if isinstance(term, Numerical):
if term >= min and term <= max:
r = True
elif type_class == Symbolic("typed-key-value"):
r = False
if isinstance(term, KeyValue):
if self.check(type_def[1], term.get_key()) and self.check(
type_def[1], term.get_value()):
r = True
elif type_class == Symbolic("or-type"):
r = False
for choice in type_def[1]:
if self.check(choice, term):
r = True
break
else:
raise ValueError("#type expression not supported:", type_def)
elif isinstance(type_def, Symbolic):
e = Tuple([type_def, term])
r = self.evaluator.apply(e).bool_value()
else:
r = False
raise ValueError("#type expression not supported:", type_def)
# if not r:
# Logger.msg("TypeCheck", str(term) + " !! " + str(type_def))
return r
def run_reference_request(rhandler, request, exec_module):
ref_target = request.get_ref_target()
if isinstance(ref_target, Reference):
ref_target = rhandler.C.resolve_reference(ref_target)
resolved_request = rhandler.C.get_entry(request.get_ref_module(),
ref_target)
if resolved_request is None:
if rhandler.verbose:
Logger.msg(
rhandler.name, "Entry not found in working module:" +
str(request.get_ref_target))
Logger.inc_depth()
entries = rhandler.C.get_matching_entries(None, None, request)
for e in entries:
if rhandler.verbose:
Logger.msg(rhandler.name, "Match: " + str(e.get_value()))
rhandler.satisfy_request(e.get_value(), exec_module)
if rhandler.verbose:
if len(entries) == 0:
Logger.msg(rhandler.name,
"Could not find entries matching: " + str(request))
Logger.dec_depth()
else:
if rhandler.verbose:
Logger.msg(
rhandler.name, "Reference %s (%s) resolved to %s." %
(str(request), str(request.get_ref_target().resolve(
rhandler.C)), str(resolved_request)))
Logger.inc_depth()
rhandler.satisfy_request(resolved_request.get_value(), exec_module)
if rhandler.verbose:
Logger.dec_depth()
def run_call(rhandler, request, exec_module):
name = rhandler.eval.apply(request[1].resolve(rhandler.C))
input = rhandler.eval.apply(request[2].resolve(rhandler.C))
output = request[3].resolve(rhandler.C)
if rhandler.verbose:
Logger.msg(rhandler.name, "call " + str(name) + " with " + str(input))
Logger.inc_depth()
f = rhandler.F.get_function(name)
if f is None:
raise ValueError("Function not registered: " + str(name) +
" request: " + str(request))
if rhandler.enforce_type_checking \
and callable(getattr(f, "get_interface_uri", None)):
interface_uri = f.get_interface_uri()
f_type_check = rhandler.F.get_input_checker(interface_uri)
if not f_type_check.apply(input).bool_value():
rhandler.eval.set_verbose(2)
f_type_check.apply(input)
raise "Input type check failed: " + str(request)
result = f.apply(input)
if rhandler.enforce_type_checking \
and callable(getattr(f, "get_interface_uri", None)):
interface_uri = f.get_interface_uri()
f_type_check = rhandler.F.get_ouput_checker(interface_uri)
if not f_type_check.apply(result).bool_value():
rhandler.eval.set_verbose(2)
f_type_check.apply(result)
raise ValueError("Input type check failed: " + str(request))
if isinstance(output, Collection):
for out in output:
key = out.get_key()
ref = out2ref(out.get_value(), rhandler.C, exec_module)
value = result.get(key, None)
if value is None:
raise ValueError("Request: " + str(request) + "returned: " +
str(result) + "missing key: " + str(output) +
"from output specification: " + str(output) +
"Make sure the keys in the output " +
"specification are the same as used in the" +
" result returned by the requested function.")
prev_entry = rhandler.C.get_entry(ref.get_ref_module(),
ref.get_ref_target())
if prev_entry is None:
prev_type = TYPE_TERM
else:
prev_type = prev_entry.get_type()
out_entry = Entry(prev_type, ref.get_ref_target(), value)
if rhandler.verbose:
Logger.msg(rhandler.name, "Writing: %s" % (str(out_entry)))
rhandler.C.set_entry(out_entry, module=ref.get_ref_module())
if rhandler.verbose:
Logger.dec_depth()
else:
ref = out2ref(output, rhandler.C, exec_module)
prev_entry = rhandler.C.get_entry(ref.get_ref_target(),
module=ref.get_ref_module())
if prev_entry is None:
prev_type = TYPE_TERM
else:
prev_type = prev_entry.get_type()
out_entry = Entry(prev_type, ref.get_ref_target(), result)
rhandler.C.set_entry(out_entry, ref.get_ref_module())
if rhandler.verbose:
Logger.msg(rhandler.name, "Writing: %s" % (str(out_entry)))
Logger.dec_depth()