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
