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