def next(self): s_key = self.d.dictdef.read_key() s_value = self.d.dictdef.read_value() if (isinstance(s_key, model.SomeImpossibleValue) or isinstance(s_value, model.SomeImpossibleValue)): return model.s_ImpossibleValue return model.SomeTuple((s_key, s_value))
def __init__(self, rtyper): self.rtyper = rtyper self.statvfs_field_indexes = {} for i, (name, TYPE) in enumerate(STATVFS_FIELDS): self.statvfs_field_indexes[name] = i self.s_tuple = annmodel.SomeTuple( [lltype_to_annotation(TYPE) for name, TYPE in STATVFS_FIELDS]) self.r_tuple = rtyper.getrepr(self.s_tuple) self.lowleveltype = self.r_tuple.lowleveltype
def __init__(self, rtyper): self.rtyper = rtyper self.stat_fields = ll_os_stat.STAT_FIELDS self.stat_field_indexes = {} for i, (name, TYPE) in enumerate(self.stat_fields): self.stat_field_indexes[name] = i self.s_tuple = annmodel.SomeTuple( [lltype_to_annotation(TYPE) for name, TYPE in self.stat_fields]) self.r_tuple = rtyper.getrepr(self.s_tuple) self.lowleveltype = self.r_tuple.lowleveltype
def test_runtime_type_info(): S = lltype.GcStruct('s', ('x', lltype.Signed), rtti=True) def ll_example(p): return (lltype.runtime_type_info(p), lltype.runtime_type_info(p) == lltype.getRuntimeTypeInfo(S)) assert ll_example(lltype.malloc(S)) == (lltype.getRuntimeTypeInfo(S), True) s, t = ll_rtype(ll_example, [SomePtr(lltype.Ptr(S))]) assert s == annmodel.SomeTuple( [SomePtr(lltype.Ptr(lltype.RuntimeTypeInfo)), annmodel.SomeBool()])
def install_marshaller((tag, s_tuple)): def dump_tuple(buf, x): buf.append(TYPE_TUPLE) w_long(buf, len(x)) for i, itemdumper in unroll_item_dumpers: itemdumper(buf, x[i]) itemdumpers = [get_marshaller(s_item) for s_item in s_tuple.items] unroll_item_dumpers = unrolling_iterable(enumerate(itemdumpers)) dumper_annotations = [get_dumper_annotation(itemdumper) for itemdumper in itemdumpers] s_general_tuple = annmodel.SomeTuple(dumper_annotations) add_dumper(s_general_tuple, dump_tuple)
def make_driverhook_graphs(self): # annhelper = MixLevelHelperAnnotator(self.translator.rtyper) for jd in self.jitdrivers_sd: jd._get_printable_location_ptr = self._make_hook_graph( jd, annhelper, jd.jitdriver.get_printable_location, annmodel.SomeString()) jd._get_unique_id_ptr = self._make_hook_graph( jd, annhelper, jd.jitdriver.get_unique_id, annmodel.SomeInteger()) jd._confirm_enter_jit_ptr = self._make_hook_graph( jd, annhelper, jd.jitdriver.confirm_enter_jit, annmodel.s_Bool, onlygreens=False) jd._can_never_inline_ptr = self._make_hook_graph( jd, annhelper, jd.jitdriver.can_never_inline, annmodel.s_Bool) jd._should_unroll_one_iteration_ptr = self._make_hook_graph( jd, annhelper, jd.jitdriver.should_unroll_one_iteration, annmodel.s_Bool) # items = [] types = () pos = () if jd.jitdriver.get_location: assert hasattr(jd.jitdriver.get_location, '_loc_types'), """ You must decorate your get_location function: from rpython.rlib.rjitlog import rjitlog as jl @jl.returns(jl.MP_FILENAME, jl.MP_XXX, ...) def get_loc(your, green, keys): name = "x.txt" # extract it from your green keys return (name, ...) """ types = jd.jitdriver.get_location._loc_types del jd.jitdriver.get_location._loc_types # for _, type in types: if type == 's': items.append(annmodel.SomeString()) elif type == 'i': items.append(annmodel.SomeInteger()) else: raise NotImplementedError s_Tuple = annmodel.SomeTuple(items) jd._get_location_ptr = self._make_hook_graph( jd, annhelper, jd.jitdriver.get_location, s_Tuple) jd._get_loc_types = types annhelper.finish()
def _get_rmarshall_support_(self): # for rlib.rmarshal # reduce and recreate stat_result objects from 10-tuples # (we ignore the extra values here for simplicity and portability) def stat_result_reduce(st): return (st[0], st[1], st[2], st[3], st[4], st[5], st[6], st[7], st[8], st[9]) def stat_result_recreate(tup): return make_stat_result(tup + extra_zeroes) s_reduced = annmodel.SomeTuple([ lltype_to_annotation(TYPE) for name, TYPE in PORTABLE_STAT_FIELDS ]) extra_zeroes = (0, ) * (len(STAT_FIELDS) - len(PORTABLE_STAT_FIELDS)) return s_reduced, stat_result_reduce, stat_result_recreate
def _get_rmarshall_support_(self): # for rlib.rmarshal # reduce and recreate stat_result objects from 10-tuples # (we ignore the extra values here for simplicity and portability) def stat_result_reduce(st): return (st[0], st[1], st[2], st[3], st[4], st[5], st[6], st.st_atime, st.st_mtime, st.st_ctime) def stat_result_recreate(tup): atime, mtime, ctime = tup[7:] result = tup[:7] result += (int(atime), int(mtime), int(ctime)) result += extra_zeroes result += (int((atime - result[7]) * 1e9), int((mtime - result[8]) * 1e9), int((ctime - result[9]) * 1e9)) return make_stat_result(result) s_reduced = annmodel.SomeTuple([lltype_to_annotation(TYPE) for name, TYPE in PORTABLE_STAT_FIELDS[:7]] + 3 * [lltype_to_annotation(lltype.Float)]) extra_zeroes = (0,) * (len(STAT_FIELDS) - len(PORTABLE_STAT_FIELDS) - 3) return s_reduced, stat_result_reduce, stat_result_recreate
def test_reprkeys_dont_clash(): stup1 = annmodel.SomeTuple((annmodel.SomeFloat(), annmodel.SomeInteger())) stup2 = annmodel.SomeTuple((annmodel.SomeString(), annmodel.SomeInteger())) key1 = stup1.rtyper_makekey() key2 = stup2.rtyper_makekey() assert key1 != key2