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_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_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_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_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_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 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_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_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()