def test_reprkeys_dont_clash():
stup1 = annmodel.SomeTuple((annmodel.SomeFloat(), annmodel.SomeInteger()))
stup2 = annmodel.SomeTuple((annmodel.SomeString(), annmodel.SomeInteger()))
rtyper = RPythonTyper(annrpython.RPythonAnnotator(None))
key1 = rtyper.makekey(stup1)
key2 = rtyper.makekey(stup2)
assert key1 != key2
def next(self):
s_key = self.d.read_key()
s_value = self.d.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 test_runtime_type_info():
S = GcStruct('s', ('x', Signed))
attachRuntimeTypeInfo(S)
def ll_example(p):
return (runtime_type_info(p),
runtime_type_info(p) == getRuntimeTypeInfo(S))
assert ll_example(malloc(S)) == (getRuntimeTypeInfo(S), True)
s, t = ll_rtype(ll_example, [annmodel.SomePtr(Ptr(S))])
assert s == annmodel.SomeTuple([annmodel.SomePtr(Ptr(RuntimeTypeInfo)),
annmodel.SomeBool()])
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([annmodel.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 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 __init__(self, rtyper):
self.rtyper = rtyper
if rtyper.type_system.name == "lltypesystem":
self.stat_fields = ll_os_stat.STAT_FIELDS
else:
self.stat_fields = ll_os_stat.PORTABLE_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([
annmodel.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 consider_op_newtuple(self, *args):
return annmodel.SomeTuple(items=args)
def compute_result_annotation(self, s_gcobject, s_pool):
from pypy.annotation import model as annmodel
return annmodel.SomeTuple(
[s_gcobject, annmodel.SomeExternalObject(GcPool)])
else:
FUNCTYPE = ootype.StaticMethod(ARGS, RESULT)
sm = ootype._static_meth(FUNCTYPE,
_name=func.__name__,
_callable=func)
cfunc = hop.inputconst(FUNCTYPE, sm)
args_v = hop.inputargs(*hop.args_r)
return hop.genop('direct_call', [cfunc] + args_v, hop.r_result)
# annotations
from pypy.annotation import model as annmodel
s_ConstOrVar = annmodel.SomePtr(CONSTORVAR)
s_Link = annmodel.SomePtr(LINK)
s_LinkPair = annmodel.SomeTuple([s_Link, s_Link])
s_Block = annmodel.SomePtr(BLOCK)
s_Graph = annmodel.SomePtr(GRAPH)
setannotation(newblock, s_Block)
setannotation(newgraph, s_ConstOrVar)
setannotation(getstartblock, s_Block)
setannotation(geninputarg, s_ConstOrVar)
setannotation(getinputarg, s_ConstOrVar)
setannotation(genop, s_ConstOrVar)
setannotation(gengetsubstruct, s_ConstOrVar)
setannotation(gengetarraysubstruct, s_ConstOrVar)
setannotation(gensetfield, None)
setannotation(gengetfield, s_ConstOrVar)
setannotation(gensetarrayitem, None)
setannotation(gengetarrayitem, s_ConstOrVar)
