def test_structcopy(self): X2 = lltype.Struct('X2', ('x', LONG)) X1 = lltype.Struct('X1', ('a', LONG), ('x2', X2), ('p', lltype.Ptr(X2))) def f(): p2 = make(X2, x=123) p1 = make(X1, a=5, p=p2) p1.x2.x = 456 p1bis = make(X1) p2bis = make(X2) structcopy(p1bis, p1) assert p1bis.a == 5 assert p1bis.x2.x == 456 assert p1bis.p == p2 structcopy(p2bis, p2) res = p2bis.x lltype.free(p2bis, flavor='raw') lltype.free(p1bis, flavor='raw') lltype.free(p2, flavor='raw') lltype.free(p1, flavor='raw') return res assert f() == 123 res = interpret(f, []) assert res == 123
def test_interior_ptr_with_index_and_field(self): py.test.skip("llptr support not really useful any more") S = lltype.Struct("S", ('x', lltype.Signed)) T = lltype.Struct("T", ('s', S)) U = lltype.GcArray(T) def f(x): u = lltype.malloc(U, 1) u[0].s.x = x return u[0].s.x graph = self.check(f, [int], [42], 42)
def test_sizeof(): # this is mostly an "assert not raises" sort of test array = lltype.Array(lltype.Signed) struct = lltype.Struct("S", ('x', lltype.Signed)) varstruct = lltype.Struct("S", ('x', lltype.Signed), ('y', array)) sizeof(struct) sizeof(lltype.Signed) py.test.raises(AssertionError, "sizeof(array)") py.test.raises(AssertionError, "sizeof(varstruct)") sizeof(array, 1) sizeof(varstruct, 2)
def test_interior_ptr_with_index_and_field(self): S = lltype.Struct("S", ('x', lltype.Signed)) T = lltype.Struct("T", ('s', S)) U = lltype.GcArray(T) def f(x): u = lltype.malloc(U, 1) u[0].s.x = x return u[0].s.x graph = self.check(f, [int], [42], 42)
def test_indirect_recursive_struct_more(self): NODE = lltype.ForwardReference() NODE2 = lltype.Struct('NODE2', ('ping', lltype.Ptr(NODE))) NODE.become(lltype.Struct('NODE', ('pong', NODE2))) # Building NODE2 first used to fail. get_ctypes_type(NODE2) CNODEPTR = get_ctypes_type(NODE) pc = CNODEPTR() pc.pong.ping = ctypes.pointer(pc) p = ctypes2lltype(lltype.Ptr(NODE), ctypes.pointer(pc)) assert p.pong.ping == p
def test_raw_free_with_hdr(): from pypy.rpython.memory.gcheader import GCHeaderBuilder HDR = lltype.Struct('h', ('t', lltype.Signed)) gh = GCHeaderBuilder(HDR).size_gc_header A = lltype.GcArray(lltype.Signed) adr = raw_malloc(gh + sizeof(A, 10)) p_a = cast_adr_to_ptr(adr + gh, lltype.Ptr(A)) p_a[0] = 1 adr = cast_ptr_to_adr(p_a) - gh raw_free(adr) py.test.raises(RuntimeError, "p_a[0]") py.test.raises(RuntimeError, "p_a[0] = 2") repr(adr) str(p_a) S = lltype.GcStruct('S', ('x', lltype.Signed)) adr = raw_malloc(gh + sizeof(S)) p_s = cast_adr_to_ptr(adr + gh, lltype.Ptr(S)) p_s.x = 1 adr = cast_ptr_to_adr(p_s) - gh raw_free(adr) py.test.raises(RuntimeError, "p_s.x") py.test.raises(RuntimeError, "p_s.x = 2") repr(adr) str(p_s) T = lltype.GcStruct('T', ('s', S)) adr = raw_malloc(gh + sizeof(T)) p_s = cast_adr_to_ptr(adr + gh, lltype.Ptr(S)) p_s.x = 1 adr = cast_ptr_to_adr(p_s) - gh raw_free(adr) py.test.raises(RuntimeError, "p_s.x") py.test.raises(RuntimeError, "p_s.x = 2") repr(adr) str(p_s) U = lltype.Struct('U', ('y', lltype.Signed)) T = lltype.GcStruct('T', ('x', lltype.Signed), ('u', U)) adr = raw_malloc(gh + sizeof(T)) p_t = cast_adr_to_ptr(adr + gh, lltype.Ptr(T)) p_u = p_t.u p_u.y = 1 adr = cast_ptr_to_adr(p_t) - gh raw_free(adr) py.test.raises(RuntimeError, "p_u.y") py.test.raises(RuntimeError, "p_u.y = 2") repr(adr) str(p_u)
def test_substructures(self): S1 = lltype.Struct('S1', ('x', lltype.Signed)) BIG = lltype.Struct('BIG', ('s1a', S1), ('s1b', S1)) s = lltype.malloc(BIG, flavor='raw') s.s1a.x = 123 s.s1b.x = 456 sc = lltype2ctypes(s) assert sc.contents.s1a.x == 123 assert sc.contents.s1b.x == 456 sc.contents.s1a.x += 1 sc.contents.s1b.x += 10 assert s.s1a.x == 124 assert s.s1b.x == 466 s.s1a.x += 3 s.s1b.x += 30 assert sc.contents.s1a.x == 127 assert sc.contents.s1b.x == 496 lltype.free(s, flavor='raw') s = lltype.malloc(BIG, flavor='raw') s1ac = lltype2ctypes(s.s1a) s1ac.contents.x = 53 sc = lltype2ctypes(s) assert sc.contents.s1a.x == 53 sc.contents.s1a.x += 1 assert s1ac.contents.x == 54 assert s.s1a.x == 54 s.s1a.x += 2 assert s1ac.contents.x == 56 assert sc.contents.s1a.x == 56 sc.contents.s1a.x += 3 assert s1ac.contents.x == 59 assert s.s1a.x == 59 t = ctypes2lltype(lltype.Ptr(BIG), sc) assert t == s assert t.s1a == s.s1a assert t.s1a.x == 59 s.s1b.x = 8888 assert t.s1b == s.s1b assert t.s1b.x == 8888 t1 = ctypes2lltype(lltype.Ptr(S1), s1ac) assert t.s1a == t1 assert t1.x == 59 t1.x += 1 assert sc.contents.s1a.x == 60 lltype.free(s, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_raw_malloc(self): py.test.skip("Exploding") S = lltype.Struct('x', ('x', lltype.Signed)) def f(): p = lltype.malloc(S, flavor='raw') hs = self.hannotate(f, [], policy=P_NOVIRTUAL)
def test_struct_fields(self): longsize = 4 if IS_32_BIT else 8 POINT = lltype.Struct( 'POINT', ('x', rffi.LONG), ('y', rffi.SHORT), ('z', rffi.VOIDP), ) y_ofs = longsize z_ofs = longsize * 2 p = lltype.malloc(POINT, flavor='raw') p.x = 42 p.y = rffi.cast(rffi.SHORT, -1) p.z = rffi.cast(rffi.VOIDP, 0x1234) addr = rffi.cast(rffi.VOIDP, p) assert struct_getfield_int(types.slong, addr, 0) == 42 assert struct_getfield_int(types.sshort, addr, y_ofs) == -1 assert struct_getfield_int(types.pointer, addr, z_ofs) == 0x1234 # struct_setfield_int(types.slong, addr, 0, 43) struct_setfield_int(types.sshort, addr, y_ofs, 0x1234FFFE) # 0x1234 is masked out struct_setfield_int(types.pointer, addr, z_ofs, 0x4321) assert p.x == 43 assert p.y == -2 assert rffi.cast(rffi.LONG, p.z) == 0x4321 # lltype.free(p, flavor='raw')
def test_del_basic(): for gcpolicy in ["ref"]: #, "framework"]: S = lltype.GcStruct('S', ('x', lltype.Signed), rtti=True) TRASH = lltype.GcStruct('TRASH', ('x', lltype.Signed)) GLOBAL = lltype.Struct('GLOBAL', ('x', lltype.Signed)) glob = lltype.malloc(GLOBAL, immortal=True) def destructor(s): glob.x = s.x + 1 def type_info_S(s): return lltype.getRuntimeTypeInfo(S) def g(n): s = lltype.malloc(S) s.x = n # now 's' should go away def entrypoint(n): g(n) # llop.gc__collect(lltype.Void) return glob.x t = TranslationContext() t.buildannotator().build_types(entrypoint, [int]) rtyper = t.buildrtyper() destrptr = rtyper.annotate_helper_fn(destructor, [lltype.Ptr(S)]) rtyper.attachRuntimeTypeInfoFunc(S, type_info_S, destrptr=destrptr) rtyper.specialize() fn = compile_func(entrypoint, None, t, gcpolicy=gcpolicy) res = fn(123) assert res == 124
def test_arrayofstruct(self): S1 = lltype.Struct('S1', ('x', lltype.Signed)) A = lltype.Array(S1, hints={'nolength': True}) a = lltype.malloc(A, 5, flavor='raw') a[0].x = 100 a[1].x = 101 a[2].x = 102 a[3].x = 103 a[4].x = 104 ac = lltype2ctypes(a, normalize=False) assert ac.contents.items[0].x == 100 assert ac.contents.items[2].x == 102 ac.contents.items[3].x += 500 assert a[3].x == 603 a[4].x += 600 assert ac.contents.items[4].x == 704 a1 = ctypes2lltype(lltype.Ptr(A), ac) assert a1 == a assert a1[2].x == 102 aitem1 = ctypes2lltype(lltype.Ptr(S1), ctypes.pointer(ac.contents.items[1])) assert aitem1.x == 101 assert aitem1 == a1[1] lltype.free(a, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_cstruct_to_ll(self): S = lltype.Struct('S', ('x', lltype.Signed), ('y', lltype.Signed)) s = lltype.malloc(S, flavor='raw') s2 = lltype.malloc(S, flavor='raw') s.x = 123 sc = lltype2ctypes(s) t = ctypes2lltype(lltype.Ptr(S), sc) assert lltype.typeOf(t) == lltype.Ptr(S) assert s == t assert not (s != t) assert t == s assert not (t != s) assert t != lltype.nullptr(S) assert not (t == lltype.nullptr(S)) assert lltype.nullptr(S) != t assert not (lltype.nullptr(S) == t) assert t != s2 assert not (t == s2) assert s2 != t assert not (s2 == t) assert t.x == 123 t.x += 1 assert s.x == 124 s.x += 1 assert t.x == 125 lltype.free(s, flavor='raw') lltype.free(s2, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_uninitialized2ctypes(self): # for now, uninitialized fields are filled with 0xDD in the ctypes data def checkobj(o, size): p = ctypes.cast(ctypes.c_void_p(ctypes.addressof(o)), ctypes.POINTER(ctypes.c_ubyte * size)) for i in range(size): assert p.contents[i] == 0xDD def checkval(v, fmt): res = struct.pack(fmt, v) assert res == "\xDD" * len(res) checkval(uninitialized2ctypes(rffi.CHAR), 'B') checkval(uninitialized2ctypes(rffi.SHORT), 'h') checkval(uninitialized2ctypes(rffi.INT), 'i') checkval(uninitialized2ctypes(rffi.UINT), 'I') checkval(uninitialized2ctypes(rffi.LONGLONG), 'q') checkval(uninitialized2ctypes(rffi.DOUBLE), 'd') checkobj(uninitialized2ctypes(rffi.INTP), ctypes.sizeof(ctypes.c_void_p)) checkobj(uninitialized2ctypes(rffi.CCHARP), ctypes.sizeof(ctypes.c_void_p)) S = lltype.Struct('S', ('x', lltype.Signed), ('y', lltype.Signed)) s = lltype.malloc(S, flavor='raw') sc = lltype2ctypes(s) checkval(sc.contents.x, 'l') checkval(sc.contents.y, 'l') lltype.free(s, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_degenerated_merge_cross_substructure(self): py.test.skip("no longer a valid test") from pypy.rlib import objectmodel S = lltype.Struct('S', ('n', lltype.Signed)) T = lltype.GcStruct('T', ('s', S), ('s1', S), ('n', lltype.Float)) def ll_function(flag): t = lltype.malloc(T) t.s.n = 3 t.s1.n = 3 if flag: s = t.s else: s = t.s1 objectmodel.keepalive_until_here(t) return s, t hs = self.hannotate(ll_function, [bool]) assert isinstance(hs, SomeLLAbstractContainer) assert not hs.contentdef.degenerated assert len(hs.contentdef.fields) == 2 hs0 = hs.contentdef.fields['item0'].s_value # 's' assert isinstance(hs0, SomeLLAbstractContainer) assert hs0.contentdef.degenerated hs1 = hs.contentdef.fields['item1'].s_value # 't' assert isinstance(hs1, SomeLLAbstractContainer) assert hs1.contentdef.degenerated
def test_array_fields(self): POINT = lltype.Struct( "POINT", ("x", lltype.Float), ("y", lltype.Float), ) points = lltype.malloc(rffi.CArray(POINT), 2, flavor="raw") points[0].x = 1.0 points[0].y = 2.0 points[1].x = 3.0 points[1].y = 4.0 points = rffi.cast(rffi.CArrayPtr(lltype.Char), points) assert array_getitem(types.double, 16, points, 0, 0) == 1.0 assert array_getitem(types.double, 16, points, 0, 8) == 2.0 assert array_getitem(types.double, 16, points, 1, 0) == 3.0 assert array_getitem(types.double, 16, points, 1, 8) == 4.0 # array_setitem(types.double, 16, points, 0, 0, 10.0) array_setitem(types.double, 16, points, 0, 8, 20.0) array_setitem(types.double, 16, points, 1, 0, 30.0) array_setitem(types.double, 16, points, 1, 8, 40.0) # assert array_getitem(types.double, 16, points, 0, 0) == 10.0 assert array_getitem(types.double, 16, points, 0, 8) == 20.0 assert array_getitem(types.double, 16, points, 1, 0) == 30.0 assert array_getitem(types.double, 16, points, 1, 8) == 40.0 # lltype.free(points, flavor="raw")
def test_prebuilt_list_of_addresses(self): from pypy.rpython.lltypesystem import llmemory TP = lltype.Struct('x', ('y', lltype.Signed)) a = lltype.malloc(TP, flavor='raw', immortal=True) b = lltype.malloc(TP, flavor='raw', immortal=True) c = lltype.malloc(TP, flavor='raw', immortal=True) a_a = llmemory.cast_ptr_to_adr(a) a0 = llmemory.cast_ptr_to_adr(a) assert a_a is not a0 assert a_a == a0 a_b = llmemory.cast_ptr_to_adr(b) a_c = llmemory.cast_ptr_to_adr(c) d = {a_a: 3, a_b: 4, a_c: 5} d[a0] = 8 def func(i): if i == 0: ptr = a else: ptr = b return d[llmemory.cast_ptr_to_adr(ptr)] py.test.raises(TypeError, self.interpret, func, [0])
def test_compiled_arena_protect(self): import os from pypy.translator.c.test.test_genc import compile S = lltype.Struct('S', ('x', lltype.Signed)) # def fn(argv): testrun = int(argv[1]) a = arena_malloc(65536, False) arena_reserve(a, llmemory.sizeof(S)) p = llmemory.cast_adr_to_ptr(a + 23432, lltype.Ptr(S)) p.x = 123 assert p.x == 123 arena_protect(a, 65536, True) result = 0 if testrun == 1: print p.x # segfault if testrun == 2: p.x = 124 # segfault arena_protect(a, 65536, False) p.x += 10 print p.x return 0 # t, cbuilder = self.compile(fn) data = cbuilder.cmdexec('0') assert data == '133\n' if has_protect: cbuilder.cmdexec('1', expect_crash=True) cbuilder.cmdexec('2', expect_crash=True)
def test_get_call_descr_not_translated(): c0 = GcCache(False) descr1 = get_call_descr(c0, [lltype.Char, lltype.Signed], lltype.Char) assert descr1.get_result_size() == rffi.sizeof(lltype.Char) assert descr1.get_result_type() == history.INT assert descr1.arg_classes == "ii" # T = lltype.GcStruct('T') descr2 = get_call_descr(c0, [lltype.Ptr(T)], lltype.Ptr(T)) assert descr2.get_result_size() == rffi.sizeof(lltype.Ptr(T)) assert descr2.get_result_type() == history.REF assert descr2.arg_classes == "r" # U = lltype.GcStruct('U', ('x', lltype.Signed)) assert descr2 == get_call_descr(c0, [lltype.Ptr(U)], lltype.Ptr(U)) # V = lltype.Struct('V', ('x', lltype.Signed)) assert (get_call_descr(c0, [], lltype.Ptr(V)).get_result_type() == history.INT) # assert (get_call_descr(c0, [], lltype.Void).get_result_type() == history.VOID) # descr4 = get_call_descr(c0, [lltype.Float, lltype.Float], lltype.Float) assert descr4.get_result_size() == rffi.sizeof(lltype.Float) assert descr4.get_result_type() == history.FLOAT assert descr4.arg_classes == "ff" # descr5 = get_call_descr(c0, [lltype.SingleFloat], lltype.SingleFloat) assert descr5.get_result_size() == rffi.sizeof(lltype.SingleFloat) assert descr5.get_result_type() == "S" assert descr5.arg_classes == "S"
def test_primitive(self): assert lltype2ctypes(5) == 5 assert lltype2ctypes('?') == ord('?') assert lltype2ctypes('\xE0') == 0xE0 assert lltype2ctypes(unichr(1234)) == 1234 assert ctypes2lltype(lltype.Signed, 5) == 5 assert ctypes2lltype(lltype.Char, ord('a')) == 'a' assert ctypes2lltype(lltype.UniChar, ord(u'x')) == u'x' assert ctypes2lltype(lltype.Char, 0xFF) == '\xFF' assert lltype2ctypes(5.25) == 5.25 assert ctypes2lltype(lltype.Float, 5.25) == 5.25 assert lltype2ctypes(u'x') == ord(u'x') res = lltype2ctypes(rffi.r_singlefloat(-3.5)) assert isinstance(res, ctypes.c_float) assert res.value == -3.5 res = ctypes2lltype(lltype.SingleFloat, ctypes.c_float(-3.5)) assert isinstance(res, rffi.r_singlefloat) assert float(res) == -3.5 assert lltype2ctypes(rffi.r_ulong(-1)) == sys.maxint * 2 + 1 res = ctypes2lltype(lltype.Unsigned, sys.maxint * 2 + 1) assert (res, type(res)) == (rffi.r_ulong(-1), rffi.r_ulong) res = lltype2ctypes(llmemory.sizeof(lltype.Signed)) assert res == struct.calcsize("l") S = lltype.Struct('S', ('x', lltype.Signed), ('y', lltype.Signed)) res = lltype2ctypes(llmemory.sizeof(S)) assert res == struct.calcsize("ll") p = lltype.nullptr(S) cptr = lltype2ctypes(p) assert not cptr py.test.raises(ValueError, 'cptr.contents') # NULL pointer access res = ctypes2lltype(lltype.Ptr(S), cptr) assert res == p assert not ALLOCATED # detects memory leaks in the test
def test_propagate_exception(self): S = lltype.Struct('S', ('flag', lltype.Signed)) s = lltype.malloc(S, immortal=True) def ll_two(x): if x == 0: raise ValueError return x + 7 def ll_function(y): res = ll_two(y) s.flag = 1 return res s.flag = 0 self.timeshift_raises(ValueError, ll_function, [0], [], policy=P_NOVIRTUAL) assert s.flag == 0 s.flag = 0 self.timeshift_raises(ValueError, ll_function, [0], [0], policy=P_NOVIRTUAL) assert s.flag == 0 s.flag = 0 res = self.timeshift(ll_function, [17], [0], policy=P_NOVIRTUAL) assert res == 24 if self.__class__ is TestException: # no chance to work with genc assert s.flag == 1 self.check_insns({'setfield': 1})
def test_recursive_struct(self): SX = lltype.ForwardReference() S1 = lltype.Struct('S1', ('p', lltype.Ptr(SX)), ('x', lltype.Signed)) SX.become(S1) # a chained list s1 = lltype.malloc(S1, flavor='raw') s2 = lltype.malloc(S1, flavor='raw') s3 = lltype.malloc(S1, flavor='raw') s1.x = 111 s2.x = 222 s3.x = 333 s1.p = s2 s2.p = s3 s3.p = lltype.nullptr(S1) sc1 = lltype2ctypes(s1) sc2 = sc1.contents.p sc3 = sc2.contents.p assert not sc3.contents.p assert sc1.contents.x == 111 assert sc2.contents.x == 222 assert sc3.contents.x == 333 sc3.contents.x += 1 assert s3.x == 334 s3.x += 2 assert sc3.contents.x == 336 lltype.free(s1, flavor='raw') lltype.free(s2, flavor='raw') lltype.free(s3, flavor='raw') # a self-cycle s1 = lltype.malloc(S1, flavor='raw') s1.x = 12 s1.p = s1 sc1 = lltype2ctypes(s1) assert sc1.contents.x == 12 assert (ctypes.addressof(sc1.contents.p.contents) == ctypes.addressof( sc1.contents)) s1.x *= 5 assert sc1.contents.p.contents.p.contents.p.contents.x == 60 lltype.free(s1, flavor='raw') # a longer cycle s1 = lltype.malloc(S1, flavor='raw') s2 = lltype.malloc(S1, flavor='raw') s1.x = 111 s1.p = s2 s2.x = 222 s2.p = s1 sc1 = lltype2ctypes(s1) assert sc1.contents.x == 111 assert sc1.contents.p.contents.x == 222 assert (ctypes.addressof(sc1.contents.p.contents) != ctypes.addressof( sc1.contents)) assert (ctypes.addressof( sc1.contents.p.contents.p.contents) == ctypes.addressof( sc1.contents)) lltype.free(s1, flavor='raw') lltype.free(s2, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_recursive_llhelper(): from pypy.rpython.annlowlevel import llhelper from pypy.rpython.lltypesystem import lltype from pypy.rlib.objectmodel import specialize from pypy.rlib.nonconst import NonConstant FT = lltype.ForwardReference() FTPTR = lltype.Ptr(FT) STRUCT = lltype.Struct("foo", ("bar", FTPTR)) FT.become(lltype.FuncType([lltype.Ptr(STRUCT)], lltype.Signed)) class A: def __init__(self, func, name): self.func = func self.name = name def _freeze_(self): return True @specialize.memo() def make_func(self): f = getattr(self, "_f", None) if f is not None: return f f = lambda *args: self.func(*args) f.c_name = self.name f.relax_sig_check = True f.__name__ = "WRAP%s" % (self.name, ) self._f = f return f def get_llhelper(self): return llhelper(FTPTR, self.make_func()) def f(s): if s.bar == t.bar: lltype.free(s, flavor="raw") return 1 lltype.free(s, flavor="raw") return 0 def g(x): return 42 def chooser(x): s = lltype.malloc(STRUCT, flavor="raw") if x: s.bar = llhelper(FTPTR, a_f.make_func()) else: s.bar = llhelper(FTPTR, a_g.make_func()) return f(s) a_f = A(f, "f") a_g = A(g, "g") t = lltype.malloc(STRUCT, flavor="raw", immortal=True) t.bar = llhelper(FTPTR, a_f.make_func()) fn = compile(chooser, [bool]) assert fn(True)
def create_lowlevel_type(self): entry_methods = { "valid": LLOrderedDict.ll_valid_from_flag, "everused": LLOrderedDict.ll_everused_from_flag, "mark_deleted": LLOrderedDict.ll_mark_deleted_in_flag, "must_clear_key": self._must_clear(self.key_repr.lowleveltype), "must_clear_value": self._must_clear(self.value_repr.lowleveltype), } fields = [ ("key", self.key_repr.lowleveltype), ("value", self.value_repr.lowleveltype), ("next", lltype.Signed), ("prev", lltype.Signed), ("everused", lltype.Bool), ("valid", lltype.Bool), ] fast_hash_func = None if not self.hash_func_repr: fast_hash_func = self.key_repr.get_ll_hash_function() if fast_hash_func is None: fields.append(("hash", lltype.Signed)) entry_methods["hash"] = LLOrderedDict.ll_hash_from_cache else: entry_methods["hash"] = LLOrderedDict.ll_hash_recompute entry_methods["fast_hash_func"] = fast_hash_func DICTENTRY = lltype.Struct("ORDEREDDICTENTRY", *fields) fields = [ ("num_items", lltype.Signed), ("resize_counter", lltype.Signed), ("first_entry", lltype.Signed), ("last_entry", lltype.Signed), ("entries", lltype.Ptr(lltype.GcArray(DICTENTRY, adtmeths=entry_methods))), ] dict_methods = {} if self.eq_func_repr and self.hash_func_repr: dict_methods["paranoia"] = True dict_methods["hashkey"] = LLOrderedDict.ll_hashkey_custom dict_methods["keyeq"] = LLOrderedDict.ll_keyeq_custom dict_methods["r_hashkey"] = self.hash_func_repr dict_methods["r_keyeq"] = self.eq_func_repr fields.append(("hashkey_func", self.hash_func_repr.lowleveltype)) fields.append(("keyeq_func", self.eq_func_repr.lowleveltype)) else: dict_methods["paranoia"] = False dict_methods["hashkey"] = lltype.staticAdtMethod( self.key_repr.get_ll_hash_function()) ll_keyeq = self.key_repr.get_ll_eq_function() if ll_keyeq is not None: ll_keyeq = lltype.staticAdtMethod(ll_keyeq) dict_methods["keyeq"] = ll_keyeq DICT = lltype.GcStruct("ORDEREDDICT", *fields, adtmeths=dict_methods) return lltype.Ptr(DICT)
def test_interior_ptr_with_field_and_index(self): py.test.skip("llptr support not really useful any more") S = lltype.Struct("S", ('x', lltype.Signed)) T = lltype.GcStruct("T", ('items', lltype.Array(S))) def f(x): t = lltype.malloc(T, 1) t.items[0].x = x return t.items[0].x graph = self.check(f, [int], [42], 42)
def test_interior_ptr(self): py.test.skip("llptr support not really useful any more") S = lltype.Struct("S", ('x', lltype.Signed)) T = lltype.GcStruct("T", ('s', S)) def f(x): t = lltype.malloc(T) t.s.x = x return t.s.x graph = self.check(f, [int], [42], 42)
def test_varsized_struct(self): STR = lltype.Struct( 'rpy_string', ('hash', lltype.Signed), ('chars', lltype.Array(lltype.Char, hints={'immutable': True}))) s = lltype.malloc(STR, 3, flavor='raw') one = force_cast(rffi.VOIDP, s) # sanity check #assert lltype2ctypes(one).contents.items._length_ > 0 two = force_cast(lltype.Ptr(STR), one) assert s == two
def test_complex_struct(): A = lltype.Array(lltype.Signed) # XXX WHY cant we create a varsize array as last elemen here? :-( S2 = lltype.Struct('s2', ('a', lltype.Signed)) # ('a', A) S3 = lltype.Struct('s3', ('s', lltype.Signed), ('s2', S2)) SBASE = lltype.GcStruct('base', ('a', lltype.Signed), ('b', S3)) SBASEPTR = lltype.Ptr(SBASE) sizeofsbase = llmemory.sizeof(SBASE) offset_toa = offsetofs(SBASE, 'b', 's2', 'a') def complex_struct(): adr = llmemory.raw_malloc(sizeofsbase) s = llmemory.cast_adr_to_ptr(adr, SBASEPTR) s.b.s2.a = 42 return (adr + offset_toa).signed[0] fn = compile_function(complex_struct, []) assert fn() == 42
def test_structarray_add(): S = lltype.Struct("S", ("x", lltype.Signed)) for a in [lltype.malloc(lltype.GcArray(S), 5), lltype.malloc(lltype.FixedSizeArray(S, 5), immortal=True)]: a[3].x = 42 adr_s = cast_ptr_to_adr(a) adr_s += itemoffsetof(lltype.typeOf(a).TO, 0) adr_s += sizeof(S) * 3 s = cast_adr_to_ptr(adr_s, lltype.Ptr(S)) assert s.x == 42
def test_interior_ptr_with_index(self): S = lltype.Struct("S", ('x', lltype.Signed)) T = lltype.GcArray(S) def f(x): t = lltype.malloc(T, 1) t[0].x = x return t[0].x graph = self.check(f, [int], [42], 42)
def test_interior_ptr_with_field_and_index(self): S = lltype.Struct("S", ('x', lltype.Signed)) T = lltype.GcStruct("T", ('items', lltype.Array(S))) def f(x): t = lltype.malloc(T, 1) t.items[0].x = x return t.items[0].x graph = self.check(f, [int], [42], 42)