def load_extension_module(space, path, name): if os.sep not in path: path = os.curdir + os.sep + path # force a '/' in the path state = space.fromcache(State) if state.find_extension(name, path) is not None: return old_context = state.package_context state.package_context = name, path try: from pypy.rlib import rdynload try: ll_libname = rffi.str2charp(path) try: dll = rdynload.dlopen(ll_libname) finally: lltype.free(ll_libname, flavor='raw') except rdynload.DLOpenError, e: raise operationerrfmt( space.w_ImportError, "unable to load extension module '%s': %s", path, e.msg) try: initptr = rdynload.dlsym(dll, 'init%s' % (name.split('.')[-1],)) except KeyError: raise operationerrfmt( space.w_ImportError, "function init%s not found in library %s", name, path) initfunc = rffi.cast(initfunctype, initptr) generic_cpy_call(space, initfunc) state.check_and_raise_exception()
def setlen(self, size): if size > 0: if size > self.allocated or size < self.allocated / 2: if size < 9: some = 3 else: some = 6 some += size >> 3 self.allocated = size + some new_buffer = lltype.malloc(mytype.arraytype, self.allocated, flavor='raw', add_memory_pressure=True) for i in range(min(size, self.len)): new_buffer[i] = self.buffer[i] else: self.len = size return else: assert size == 0 self.allocated = 0 new_buffer = lltype.nullptr(mytype.arraytype) if self.buffer: lltype.free(self.buffer, flavor='raw') self.buffer = new_buffer self.len = size
def walk_roots(self, collect_stack_root, collect_static_in_prebuilt_nongc, collect_static_in_prebuilt_gc): gc = self.tester.gc layoutbuilder = self.tester.layoutbuilder if collect_static_in_prebuilt_gc: for addrofaddr in layoutbuilder.addresses_of_static_ptrs: if addrofaddr.address[0]: collect_static_in_prebuilt_gc(gc, addrofaddr) if collect_static_in_prebuilt_nongc: for addrofaddr in layoutbuilder.addresses_of_static_ptrs_in_nongc: if addrofaddr.address[0]: collect_static_in_prebuilt_nongc(gc, addrofaddr) if collect_stack_root: stackroots = self.tester.stackroots a = lltype.malloc(ADDR_ARRAY, len(stackroots), flavor='raw') for i in range(len(a)): a[i] = llmemory.cast_ptr_to_adr(stackroots[i]) a_base = lltype.direct_arrayitems(a) for i in range(len(a)): ai = lltype.direct_ptradd(a_base, i) collect_stack_root(gc, llmemory.cast_ptr_to_adr(ai)) for i in range(len(a)): PTRTYPE = lltype.typeOf(stackroots[i]) stackroots[i] = llmemory.cast_adr_to_ptr(a[i], PTRTYPE) lltype.free(a, flavor='raw')
def test_raw_memclear_on_empty_array(): py.test.skip("Fails") A = lltype.FixedSizeArray(lltype.Signed, 0) a = lltype.malloc(A, flavor='raw') src = cast_ptr_to_adr(a) + itemoffsetof(A, 0) raw_memclear(src, sizeof(lltype.Signed) * 0) lltype.free(a, flavor="raw")
def time_clock_llimpl(): a = lltype.malloc(RUSAGE, flavor='raw') c_getrusage(RUSAGE_SELF, a) result = (decode_timeval(a.c_ru_utime) + decode_timeval(a.c_ru_stime)) lltype.free(a, flavor='raw') return result
def llimpl_FormatError(code): "Return a message corresponding to the given Windows error code." buf = lltype.malloc(rffi.CCHARPP.TO, 1, flavor='raw') try: msglen = FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, None, rffi.cast(DWORD, code), DEFAULT_LANGUAGE, rffi.cast(rffi.CCHARP, buf), 0, None) if msglen <= 2: # includes the case msglen < 0 return fake_FormatError(code) # FormatMessage always appends \r\n. buflen = intmask(msglen - 2) assert buflen > 0 result = rffi.charpsize2str(buf[0], buflen) LocalFree(rffi.cast(rffi.VOIDP, buf[0])) finally: lltype.free(buf, flavor='raw') return result
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_forced_ptr_cast(self): import array A = lltype.Array(lltype.Signed, hints={'nolength': True}) B = lltype.Array(lltype.Char, hints={'nolength': True}) a = lltype.malloc(A, 10, flavor='raw') for i in range(10): a[i] = i*i b = rffi.cast(lltype.Ptr(B), a) checker = array.array('l') for i in range(10): checker.append(i*i) expected = checker.tostring() for i in range(len(expected)): assert b[i] == expected[i] c = rffi.cast(rffi.VOIDP, a) addr = lltype2ctypes(c) #assert addr == ctypes.addressof(a._obj._ctypes_storage) d = ctypes2lltype(rffi.VOIDP, addr) assert lltype.typeOf(d) == rffi.VOIDP assert c == d e = rffi.cast(lltype.Ptr(A), d) for i in range(10): assert e[i] == i*i c = lltype.nullptr(rffi.VOIDP.TO) addr = rffi.cast(lltype.Signed, c) assert addr == 0 lltype.free(a, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_mousemove(self): if not self.is_interactive: py.test.skip("interactive test only") print print "Move the Mouse up and down:" print " Use Escape to quit." event = lltype.malloc(RSDL.Event, flavor="raw") directions = [False]*4 try: while True: ok = RSDL.WaitEvent(event) assert rffi.cast(lltype.Signed, ok) == 1 c_type = rffi.getintfield(event, "c_type") if c_type == RSDL.MOUSEMOTION: m = rffi.cast(RSDL.MouseMotionEventPtr, event) assert rffi.getintfield(m, "c_x") >= 0 assert rffi.getintfield(m, "c_y") >= 0 print rffi.getintfield(m, "c_xrel") directions[0] |= rffi.getintfield(m, "c_xrel")>0 directions[1] |= rffi.getintfield(m, "c_xrel")<0 directions[2] |= rffi.getintfield(m, "c_yrel")>0 directions[3] |= rffi.getintfield(m, "c_yrel")<0 if False not in directions: break elif c_type == RSDL.KEYUP: p = rffi.cast(RSDL.KeyboardEventPtr, event) if rffi.getintfield(p.c_keysym, 'c_sym') == RSDL.K_ESCAPE: print " test manually aborted" py.test.fail(" mousemovement test aborted") break finally: lltype.free(event, flavor='raw')
def test_addr_raw_packet(): if not hasattr(rsocket._c, 'sockaddr_ll'): py.test.skip("posix specific test") c_addr_ll = lltype.malloc(rsocket._c.sockaddr_ll, flavor='raw') addrlen = rffi.sizeof(rsocket._c.sockaddr_ll) c_addr = rffi.cast(lltype.Ptr(rsocket._c.sockaddr), c_addr_ll) rffi.setintfield(c_addr_ll, 'c_sll_ifindex', 1) rffi.setintfield(c_addr_ll, 'c_sll_protocol', 8) rffi.setintfield(c_addr_ll, 'c_sll_pkttype', 13) rffi.setintfield(c_addr_ll, 'c_sll_hatype', 0) rffi.setintfield(c_addr_ll, 'c_sll_halen', 3) c_addr_ll.c_sll_addr[0] = 'a' c_addr_ll.c_sll_addr[1] = 'b' c_addr_ll.c_sll_addr[2] = 'c' rffi.setintfield(c_addr, 'c_sa_family', socket.AF_PACKET) # fd needs to be somehow valid s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) fd = s.fileno() w_obj = rsocket.make_address(c_addr, addrlen).as_object(fd, space) lltype.free(c_addr_ll, flavor='raw') assert space.is_true(space.eq(w_obj, space.newtuple([ space.wrap('lo'), space.wrap(socket.ntohs(8)), space.wrap(13), space.wrap(False), space.wrap("abc"), ])))
def test_keypresses(self): if not self.is_interactive: py.test.skip("interactive test only") RSDL.EnableUNICODE(1) print print "Keys pressed in the Pygame window should be printed below." print " Use Escape to quit." event = lltype.malloc(RSDL.Event, flavor='raw') try: while True: ok = RSDL.WaitEvent(event) assert rffi.cast(lltype.Signed, ok) == 1 c_type = rffi.getintfield(event, 'c_type') if c_type == RSDL.KEYDOWN: p = rffi.cast(RSDL.KeyboardEventPtr, event) if rffi.getintfield(p.c_keysym, 'c_sym') == RSDL.K_ESCAPE: print 'Escape key' break char = rffi.getintfield(p.c_keysym, 'c_unicode') if char != 0: print 'Key:', unichr(char).encode('utf-8') else: print 'Some special key' else: print '(event of type %d)' % c_type finally: lltype.free(event, flavor='raw')
def test_blit_rect(self): surface = RSDL.CreateRGBSurface(0, 150, 50, 32, r_uint(0x000000FF), r_uint(0x0000FF00), r_uint(0x00FF0000), r_uint(0xFF000000)) fmt = surface.c_format color = RSDL.MapRGB(fmt, 255, 0, 0) RSDL.FillRect(surface, lltype.nullptr(RSDL.Rect), color) paintrect = RSDL_helper.mallocrect(75, 0, 150, 50) dstrect = lltype.malloc(RSDL.Rect, flavor='raw') try: color = RSDL.MapRGB(fmt, 255, 128, 0) RSDL.FillRect(surface, paintrect, color) rffi.setintfield(dstrect, 'c_x', 10) rffi.setintfield(dstrect, 'c_y', 10) rffi.setintfield(dstrect, 'c_w', 150) rffi.setintfield(dstrect, 'c_h', 50) RSDL.BlitSurface(surface, lltype.nullptr(RSDL.Rect), self.screen, dstrect) RSDL.Flip(self.screen) finally: lltype.free(dstrect, flavor='raw') lltype.free(paintrect, flavor='raw') RSDL.FreeSurface(surface) self.check("Half Red/Orange rectangle(150px * 50px) at the top left, 10 pixels from the border")
def test_poll(self): if not self.is_interactive: py.test.skip("interactive test only") import time, sys RSDL.EnableUNICODE(1) print print "Keys pressed in the Pygame window give a dot." print " Wait 3 seconds to quit." timeout = time.time() + 3 event = lltype.malloc(RSDL.Event, flavor='raw') try: while True: # busy polling ok = RSDL.PollEvent(event) ok = rffi.cast(lltype.Signed, ok) assert ok >= 0 if ok > 0: c_type = rffi.getintfield(event, 'c_type') if c_type == RSDL.KEYDOWN: sys.stderr.write('.') p = rffi.cast(RSDL.KeyboardEventPtr, event) if rffi.getintfield(p.c_keysym, 'c_sym') == RSDL.K_ESCAPE: print 'Escape key' break timeout = time.time() + 3 else: if time.time() > timeout: break time.sleep(0.05) finally: lltype.free(event, flavor='raw')
def ioctl(space, w_fd, op, w_arg=0, mutate_flag=-1): """ioctl(fd, opt[, arg[, mutate_flag]]) Perform the requested operation on file descriptor fd. The operation is defined by opt and is operating system dependent. Typically these codes are retrieved from the fcntl or termios library modules. """ # removed the largish docstring because it is not in sync with the # documentation any more (even in CPython's docstring is out of date) # XXX this function's interface is a mess. # We try to emulate the behavior of Python >= 2.5 w.r.t. mutate_flag fd = space.c_filedescriptor_w(w_fd) op = rffi.cast(rffi.INT, op) # C long => C int if mutate_flag != 0: try: rwbuffer = space.rwbuffer_w(w_arg) except OperationError, e: if not e.match(space, space.w_TypeError): raise if mutate_flag > 0: raise else: arg = rwbuffer.as_str() ll_arg = rffi.str2charp(arg) rv = ioctl_str(fd, op, ll_arg) arg = rffi.charpsize2str(ll_arg, len(arg)) lltype.free(ll_arg, flavor='raw') if rv < 0: raise _get_error(space, "ioctl") rwbuffer.setslice(0, arg) return space.wrap(rv)
def _free_buffers(self, ll_result, ll_args): if ll_result: self._free_buffer_maybe(rffi.cast(rffi.VOIDP, ll_result), self.restype) for i in range(len(self.argtypes)): argtype = self.argtypes[i] self._free_buffer_maybe(ll_args[i], argtype) lltype.free(ll_args, flavor='raw')
def __init__(self, space, environment, context, retrieveError): self.context = context if retrieveError: if environment.errorHandle: handle = environment.errorHandle handleType = roci.OCI_HTYPE_ERROR else: handle = environment.handle handleType = roci.OCI_HTYPE_ENV codeptr = lltype.malloc(rffi.CArray(roci.sb4), 1, flavor='raw') BUFSIZE = 1024 textbuf, text = rffi.alloc_buffer(BUFSIZE) try: status = roci.OCIErrorGet( handle, 1, lltype.nullptr(roci.oratext.TO), codeptr, textbuf, BUFSIZE, handleType) if status != roci.OCI_SUCCESS: raise OperationError( get(space).w_InternalError, space.wrap("No Oracle error?")) self.code = codeptr[0] self.w_message = config.w_string(space, textbuf) finally: lltype.free(codeptr, flavor='raw') rffi.keep_buffer_alive_until_here(textbuf, text) if config.WITH_UNICODE: # XXX remove double zeros at the end pass
def getdefaultlocale(space): encoding = "cp%d" % GetACP() BUFSIZE = 50 buf_lang = lltype.malloc(rffi.CCHARP.TO, BUFSIZE, flavor='raw') buf_country = lltype.malloc(rffi.CCHARP.TO, BUFSIZE, flavor='raw') try: if (GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SISO639LANGNAME, buf_lang, BUFSIZE) and GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_SISO3166CTRYNAME, buf_country, BUFSIZE)): lang = rffi.charp2str(buf_lang) country = rffi.charp2str(buf_country) return space.newtuple([space.wrap("%s_%s" % (lang, country)), space.wrap(encoding)]) # If we end up here, this windows version didn't know about # ISO639/ISO3166 names (it's probably Windows 95). Return the # Windows language identifier instead (a hexadecimal number) elif GetLocaleInfo(LOCALE_USER_DEFAULT, LOCALE_IDEFAULTLANGUAGE, buf_lang, BUFSIZE): lang = rffi.charp2str(buf_lang) return space.newtuple([space.wrap("0x%s" % lang), space.wrap(encoding)]) else: return space.newtuple([space.w_None, space.wrap(encoding)]) finally: lltype.free(buf_lang, flavor='raw') lltype.free(buf_country, flavor='raw')
def _enlarge_gcmap(self): oldgcmap = self._gcmap if self._gcmap_deadentries * 3 * 2 > self._gcmap_maxlength: # More than 1/3rd of the entries are dead. Don't actually # enlarge the gcmap table, but just clean up the dead entries. newgcmap = oldgcmap else: # Normal path: enlarge the array. newlength = 250 + (self._gcmap_maxlength // 3) * 4 newgcmap = lltype.malloc(self.GCMAP_ARRAY, newlength, flavor='raw', track_allocation=False) self._gcmap_maxlength = newlength # j = 0 i = 0 end = self._gcmap_curlength while i < end: if oldgcmap[i + 1]: newgcmap[j] = oldgcmap[i] newgcmap[j + 1] = oldgcmap[i + 1] j += 2 i += 2 self._gcmap_curlength = j self._gcmap_deadentries = 0 if oldgcmap != newgcmap: self._gcmap = newgcmap if oldgcmap: lltype.free(oldgcmap, flavor='raw', track_allocation=False) return j
def test_carray_to_ll(): A = lltype.Array(lltype.Signed, hints={'nolength': True}) a = lltype.malloc(A, 10, flavor='raw') a2 = lltype.malloc(A, 10, flavor='raw') a[0] = 100 a[1] = 101 a[2] = 110 ac = lltype2ctypes(a) b = ctypes2lltype(lltype.Ptr(A), ac) assert lltype.typeOf(b) == lltype.Ptr(A) assert b == a assert not (b != a) assert a == b assert not (a != b) assert b != lltype.nullptr(A) assert not (b == lltype.nullptr(A)) assert lltype.nullptr(A) != b assert not (lltype.nullptr(A) == b) assert b != a2 assert not (b == a2) assert a2 != b assert not (a2 == b) assert b[2] == 110 b[2] *= 2 assert a[2] == 220 a[2] *= 3 assert b[2] == 660 lltype.free(a, flavor='raw') lltype.free(a2, flavor='raw')
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(): 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')
def test_qsort(self): CMPFUNC = lltype.FuncType([rffi.VOIDP, rffi.VOIDP], rffi.INT) qsort = rffi.llexternal('qsort', [rffi.VOIDP, rffi.SIZE_T, rffi.SIZE_T, lltype.Ptr(CMPFUNC)], lltype.Void) lst = [23, 43, 24, 324, 242, 34, 78, 5, 3, 10] A = lltype.Array(lltype.Signed, hints={'nolength': True}) a = lltype.malloc(A, 10, flavor='raw') for i in range(10): a[i] = lst[i] SIGNEDPTR = lltype.Ptr(lltype.FixedSizeArray(lltype.Signed, 1)) def my_compar(p1, p2): p1 = rffi.cast(SIGNEDPTR, p1) p2 = rffi.cast(SIGNEDPTR, p2) print 'my_compar:', p1[0], p2[0] return rffi.cast(rffi.INT, cmp(p1[0], p2[0])) qsort(rffi.cast(rffi.VOIDP, a), rffi.cast(rffi.SIZE_T, 10), rffi.cast(rffi.SIZE_T, llmemory.sizeof(lltype.Signed)), llhelper(lltype.Ptr(CMPFUNC), my_compar)) for i in range(10): print a[i], print lst.sort() for i in range(10): assert a[i] == lst[i] lltype.free(a, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def __del__(self): if self.ll_cif: lltype.free(self.ll_cif, flavor='raw') self.ll_cif = lltype.nullptr(FFI_CIFP.TO) if self.ll_argtypes: lltype.free(self.ll_argtypes, flavor='raw') self.ll_argtypes = lltype.nullptr(FFI_TYPE_PP.TO)
def test(encoded, endian, realendian=None): encoded_charp = rffi.str2charp(encoded) strict_charp = rffi.str2charp("strict") if endian is not None: if endian < 0: value = -1 elif endian > 0: value = 1 else: value = 0 pendian = lltype.malloc(rffi.INTP.TO, 1, flavor='raw') pendian[0] = rffi.cast(rffi.INT, value) else: pendian = None w_ustr = api.PyUnicode_DecodeUTF16(encoded_charp, len(encoded), strict_charp, pendian) assert space.eq_w(space.call_method(w_ustr, 'encode', space.wrap('ascii')), space.wrap("abcd")) rffi.free_charp(encoded_charp) rffi.free_charp(strict_charp) if pendian: if realendian is not None: assert rffi.cast(rffi.INT, realendian) == pendian[0] lltype.free(pendian, flavor='raw')
def test_byval_argument(self): """ struct Point { long x; long y; }; long sum_point(struct Point p) { return p.x + p.y; } """ libfoo = CDLL(self.libfoo_name) ffi_point_struct = make_struct_ffitype_e(0, 0, [types.slong, types.slong]) ffi_point = ffi_point_struct.ffistruct sum_point = (libfoo, 'sum_point', [ffi_point], types.slong) # ARRAY = rffi.CArray(rffi.LONG) buf = lltype.malloc(ARRAY, 2, flavor='raw') buf[0] = 30 buf[1] = 12 adr = rffi.cast(rffi.VOIDP, buf) res = self.call(sum_point, [('arg_raw', adr)], rffi.LONG, jitif=["byval"]) assert res == 42 # check that we still have the ownership on the buffer assert buf[0] == 30 assert buf[1] == 12 lltype.free(buf, flavor='raw') lltype.free(ffi_point_struct, flavor='raw')
def walk_stack_from(self): curframe = lltype.malloc(WALKFRAME, flavor='raw') otherframe = lltype.malloc(WALKFRAME, flavor='raw') # Walk over all the pieces of stack. They are in a circular linked # list of structures of 7 words, the 2 first words being prev/next. # The anchor of this linked list is: anchor = llmemory.cast_ptr_to_adr(gcrootanchor) initialframedata = anchor.address[1] stackscount = 0 while initialframedata != anchor: # while we have not looped back self.fill_initial_frame(curframe, initialframedata) # Loop over all the frames in the stack while self.walk_to_parent_frame(curframe, otherframe): swap = curframe curframe = otherframe # caller becomes callee otherframe = swap # Then proceed to the next piece of stack initialframedata = initialframedata.address[1] stackscount += 1 # expected = rffi.stackcounter.stacks_counter ll_assert(not (stackscount < expected), "non-closed stacks around") ll_assert(not (stackscount > expected), "stacks counter corruption?") lltype.free(otherframe, flavor='raw') lltype.free(curframe, flavor='raw')
def get_darwin_sysctl_signed(sysctl_name): rval_p = lltype.malloc(rffi.LONGLONGP.TO, 1, flavor='raw') try: len_p = lltype.malloc(rffi.SIZE_TP.TO, 1, flavor='raw') try: size = rffi.sizeof(rffi.LONGLONG) rval_p[0] = rffi.cast(rffi.LONGLONG, 0) len_p[0] = rffi.cast(rffi.SIZE_T, size) # XXX a hack for llhelper not being robust-enough result = sysctlbyname(sysctl_name, rffi.cast(rffi.VOIDP, rval_p), len_p, lltype.nullptr(rffi.VOIDP.TO), rffi.cast(rffi.SIZE_T, 0)) rval = 0 if (rffi.cast(lltype.Signed, result) == 0 and rffi.cast(lltype.Signed, len_p[0]) == size): rval = rffi.cast(lltype.Signed, rval_p[0]) if rffi.cast(rffi.LONGLONG, rval) != rval_p[0]: rval = 0 # overflow! return rval finally: lltype.free(len_p, flavor='raw') finally: lltype.free(rval_p, flavor='raw')
def inflateEnd(stream): """ Free the resources associated with the inflate stream. Note that this may raise RZlibError. """ _inflateEnd(stream) lltype.free(stream, flavor='raw')
def win32_urandom(space, n): """urandom(n) -> str Return a string of n random bytes suitable for cryptographic use. """ if n < 0: raise OperationError(space.w_ValueError, space.wrap("negative argument not allowed")) provider = get(space).cryptProviderPtr[0] if not provider: # Acquire context. # This handle is never explicitly released. The operating # system will release it when the process terminates. if not CryptAcquireContext( get(space).cryptProviderPtr, None, None, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT): raise rwin32.lastWindowsError("CryptAcquireContext") provider = get(space).cryptProviderPtr[0] # Get random data buf = lltype.malloc(rffi.CArray(rwin32.BYTE), n, zero=True, # zero seed flavor='raw') try: if not CryptGenRandom(provider, n, buf): raise rwin32.lastWindowsError("CryptGenRandom") return space.wrap( rffi.charpsize2str(rffi.cast(rffi.CCHARP, buf), n)) finally: lltype.free(buf, flavor='raw')
def __del__(self): if self.ll_cif: lltype.free(self.ll_cif, flavor="raw", track_allocation=False) self.ll_cif = lltype.nullptr(FFI_CIFP.TO) if self.ll_argtypes: lltype.free(self.ll_argtypes, flavor="raw", track_allocation=False) self.ll_argtypes = lltype.nullptr(FFI_TYPE_PP.TO)
def inet_pton(family, ip): "human-readable string -> packed string" if family == AF_INET: size = sizeof(_c.in_addr) elif AF_INET6 is not None and family == AF_INET6: size = sizeof(_c.in6_addr) else: raise RSocketError("unknown address family") buf = mallocbuf(size) try: res = _c.inet_pton(family, ip, buf) if res < 0: raise last_error() elif res == 0: raise RSocketError("illegal IP address string passed " "to inet_pton") else: return ''.join([buf[i] for i in range(size)]) finally: lltype.free(buf, flavor='raw')
def accept(self, SocketClass=None): """Wait for an incoming connection. Return (new socket object, client address).""" if SocketClass is None: SocketClass = RSocket if self._select(False) == 1: raise SocketTimeout address, addr_p, addrlen_p = self._addrbuf() try: newfd = _c.socketaccept(self.fd, addr_p, addrlen_p) addrlen = addrlen_p[0] finally: lltype.free(addrlen_p, flavor='raw') address.unlock() if _c.invalid_socket(newfd): raise self.error_handler() address.addrlen = rffi.cast(lltype.Signed, addrlen) sock = make_socket(newfd, self.family, self.type, self.proto, SocketClass) return (sock, address)
def socketpair(family=socketpair_default_family, type=SOCK_STREAM, proto=0, SocketClass=RSocket): """socketpair([family[, type[, proto]]]) -> (socket object, socket object) Create a pair of socket objects from the sockets returned by the platform socketpair() function. The arguments are the same as for socket() except the default family is AF_UNIX if defined on the platform; otherwise, the default is AF_INET. """ result = lltype.malloc(_c.socketpair_t, 2, flavor='raw') res = _c.socketpair(family, type, proto, result) if res < 0: raise last_error() fd0 = rffi.cast(lltype.Signed, result[0]) fd1 = rffi.cast(lltype.Signed, result[1]) lltype.free(result, flavor='raw') return (make_socket(fd0, family, type, proto, SocketClass), make_socket(fd1, family, type, proto, SocketClass))
def test_unicode_resize(self, space, api): py_uni = new_empty_unicode(space, 10) ar = lltype.malloc(PyObjectP.TO, 1, flavor='raw') py_uni.c_buffer[0] = u'a' py_uni.c_buffer[1] = u'b' py_uni.c_buffer[2] = u'c' ar[0] = rffi.cast(PyObject, py_uni) api.PyUnicode_Resize(ar, 3) py_uni = rffi.cast(PyUnicodeObject, ar[0]) assert py_uni.c_size == 3 assert py_uni.c_buffer[1] == u'b' assert py_uni.c_buffer[3] == u'\x00' # the same for growing ar[0] = rffi.cast(PyObject, py_uni) api.PyUnicode_Resize(ar, 10) py_uni = rffi.cast(PyUnicodeObject, ar[0]) assert py_uni.c_size == 10 assert py_uni.c_buffer[1] == 'b' assert py_uni.c_buffer[10] == '\x00' Py_DecRef(space, ar[0]) lltype.free(ar, flavor='raw')
def _get_file_size(handle): # XXX use native Windows types like WORD high_ref = lltype.malloc(LPDWORD.TO, 1, flavor='raw') try: low = GetFileSize(handle, high_ref) low = rffi.cast(lltype.Signed, low) # XXX should be propagate the real type, allowing # for 2*sys.maxint? high = high_ref[0] # low might just happen to have the value INVALID_FILE_SIZE # so we need to check the last error also INVALID_FILE_SIZE = -1 NO_ERROR = 0 dwErr = GetLastError() err = rffi.cast(lltype.Signed, dwErr) if low == INVALID_FILE_SIZE and err != NO_ERROR: msg = os.strerror(err) raise OSError(err, msg) return low, high finally: lltype.free(high_ref, flavor='raw')
def CreateKey(space, w_hkey, subkey): """key = CreateKey(key, sub_key) - Creates or opens the specified key. key is an already open key, or one of the predefined HKEY_* constants sub_key is a string that names the key this method opens or creates. If key is one of the predefined keys, sub_key may be None. In that case, the handle returned is the same key handle passed in to the function. If the key already exists, this function opens the existing key The return value is the handle of the opened key. If the function fails, an exception is raised.""" hkey = hkey_w(w_hkey, space) rethkey = lltype.malloc(rwinreg.PHKEY.TO, 1, flavor='raw') try: ret = rwinreg.RegCreateKey(hkey, subkey, rethkey) if ret != 0: raiseWindowsError(space, ret, 'CreateKey') return space.wrap(W_HKEY(rethkey[0])) finally: lltype.free(rethkey, flavor='raw')
def ConnectRegistry(space, w_machine, w_hkey): """key = ConnectRegistry(computer_name, key) Establishes a connection to a predefined registry handle on another computer. computer_name is the name of the remote computer, of the form \\\\computername. If None, the local computer is used. key is the predefined handle to connect to. The return value is the handle of the opened key. If the function fails, an EnvironmentError exception is raised.""" machine = str_or_None_w(space, w_machine) hkey = hkey_w(w_hkey, space) rethkey = lltype.malloc(rwinreg.PHKEY.TO, 1, flavor='raw') try: ret = rwinreg.RegConnectRegistry(machine, hkey, rethkey) if ret != 0: raiseWindowsError(space, ret, 'RegConnectRegistry') return space.wrap(W_HKEY(rethkey[0])) finally: lltype.free(rethkey, flavor='raw')
def do_send_string(self, space, buffer, offset, size): from pypy.module._multiprocessing.interp_win32 import ( _WriteFile, ERROR_NO_SYSTEM_RESOURCES) from pypy.rlib import rwin32 charp = rffi.str2charp(buffer) written_ptr = lltype.malloc(rffi.CArrayPtr(rwin32.DWORD).TO, 1, flavor='raw') try: result = _WriteFile(self.handle, rffi.ptradd(charp, offset), size, written_ptr, rffi.NULL) if (result == 0 and rwin32.GetLastError() == ERROR_NO_SYSTEM_RESOURCES): raise operationerrfmt(space.w_ValueError, "Cannot send %d bytes over connection", size) finally: rffi.free_charp(charp) lltype.free(written_ptr, flavor='raw')
def test_string_resize(self, space, api): py_str = new_empty_str(space, 10) ar = lltype.malloc(PyObjectP.TO, 1, flavor='raw') py_str.c_buffer[0] = 'a' py_str.c_buffer[1] = 'b' py_str.c_buffer[2] = 'c' ar[0] = rffi.cast(PyObject, py_str) api._PyString_Resize(ar, 3) py_str = rffi.cast(PyStringObject, ar[0]) assert py_str.c_size == 3 assert py_str.c_buffer[1] == 'b' assert py_str.c_buffer[3] == '\x00' # the same for growing ar[0] = rffi.cast(PyObject, py_str) api._PyString_Resize(ar, 10) py_str = rffi.cast(PyStringObject, ar[0]) assert py_str.c_size == 10 assert py_str.c_buffer[1] == 'b' assert py_str.c_buffer[10] == '\x00' Py_DecRef(space, ar[0]) lltype.free(ar, flavor='raw')
def entry_point(argv=None): RSDL.Init(RSDL.INIT_VIDEO) >= 0 screen = RSDL.SetVideoMode(WIDTH, HEIGHT, 32, 0) event = lltype.malloc(RSDL.Event, flavor='raw') paintpattern = 0 try: while True: ok = RSDL.WaitEvent(event) assert rffi.cast(lltype.Signed, ok) == 1 c_type = rffi.getintfield(event, 'c_type') if c_type == RSDL.KEYDOWN: p = rffi.cast(RSDL.KeyboardEventPtr, event) if rffi.getintfield(p.c_keysym, 'c_sym') == RSDL.K_ESCAPE: print 'Escape key' break paintpattern += 1 update_screen(screen, paintpattern) finally: lltype.free(event, flavor='raw') return 0
def f(): from pypy.rpython.lltypesystem import lltype, rffi alist = [A() for i in range(50)] idarray = lltype.malloc(rffi.INTP.TO, len(alist), flavor='raw') # Compute the id of all the elements of the list. The goal is # to not allocate memory, so that if the GC needs memory to # remember the ids, it will trigger some collections itself i = 0 while i < len(alist): idarray[i] = compute_unique_id(alist[i]) i += 1 j = 0 while j < 2: if j == 1: # allocate some stuff between the two iterations [A() for i in range(20)] i = 0 while i < len(alist): assert idarray[i] == compute_unique_id(alist[i]) i += 1 j += 1 lltype.free(idarray, flavor='raw')
def QueryValueEx(space, w_hkey, subkey): """value,type_id = QueryValueEx(key, value_name) - Retrieves the type and data for a specified value name associated with an open registry key. key is an already open key, or any one of the predefined HKEY_* constants. value_name is a string indicating the value to query""" hkey = hkey_w(w_hkey, space) null_dword = lltype.nullptr(rwin32.LPDWORD.TO) retDataSize = lltype.malloc(rwin32.LPDWORD.TO, 1, flavor='raw') try: ret = rwinreg.RegQueryValueEx(hkey, subkey, null_dword, null_dword, None, retDataSize) if ret != 0: raiseWindowsError(space, ret, 'RegQueryValueEx') databuf = lltype.malloc(rffi.CCHARP.TO, retDataSize[0], flavor='raw') try: retType = lltype.malloc(rwin32.LPDWORD.TO, 1, flavor='raw') try: ret = rwinreg.RegQueryValueEx(hkey, subkey, null_dword, retType, databuf, retDataSize) if ret != 0: raiseWindowsError(space, ret, 'RegQueryValueEx') return space.newtuple([ convert_from_regdata(space, databuf, retDataSize[0], retType[0]), space.wrap(retType[0]), ]) finally: lltype.free(retType, flavor='raw') finally: lltype.free(databuf, flavor='raw') finally: lltype.free(retDataSize, flavor='raw')
def os_utime_llimpl(path, tp): hFile = CreateFile(path, FILE_WRITE_ATTRIBUTES, 0, None, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, rwin32.NULL_HANDLE) if hFile == rwin32.INVALID_HANDLE_VALUE: raise rwin32.lastWindowsError() ctime = lltype.nullptr(rwin32.FILETIME) atime = lltype.malloc(rwin32.FILETIME, flavor='raw') mtime = lltype.malloc(rwin32.FILETIME, flavor='raw') try: if tp is None: now = lltype.malloc(rwin32.SYSTEMTIME, flavor='raw') try: GetSystemTime(now) if (not SystemTimeToFileTime(now, atime) or not SystemTimeToFileTime(now, mtime)): raise rwin32.lastWindowsError() finally: lltype.free(now, flavor='raw') else: actime, modtime = tp time_t_to_FILE_TIME(actime, atime) time_t_to_FILE_TIME(modtime, mtime) if not SetFileTime(hFile, ctime, atime, mtime): raise rwin32.lastWindowsError() finally: rwin32.CloseHandle(hFile) lltype.free(atime, flavor='raw') lltype.free(mtime, flavor='raw')
def test_iterkeys(self, space, api): w_dict = space.sys.getdict(space) py_dict = make_ref(space, w_dict) ppos = lltype.malloc(Py_ssize_tP.TO, 1, flavor='raw') pkey = lltype.malloc(PyObjectP.TO, 1, flavor='raw') pvalue = lltype.malloc(PyObjectP.TO, 1, flavor='raw') keys_w = [] values_w = [] try: ppos[0] = 0 while api.PyDict_Next(w_dict, ppos, pkey, None): w_key = from_ref(space, pkey[0]) keys_w.append(w_key) ppos[0] = 0 while api.PyDict_Next(w_dict, ppos, None, pvalue): w_value = from_ref(space, pvalue[0]) values_w.append(w_value) finally: lltype.free(ppos, flavor='raw') lltype.free(pkey, flavor='raw') lltype.free(pvalue, flavor='raw') api.Py_DecRef(py_dict) # release borrowed references assert space.eq_w(space.newlist(keys_w), space.call_method(w_dict, "keys")) assert space.eq_w(space.newlist(values_w), space.call_method(w_dict, "values"))
def _internalFetch(self, space, numRows): if not self.fetchVariables: raise OperationError( get(space).w_InterfaceError, space.wrap("query not executed")) status = roci.OCIStmtFetch( self.handle, self.environment.errorHandle, numRows, roci.OCI_FETCH_NEXT, roci.OCI_DEFAULT) if status != roci.OCI_NO_DATA: self.environment.checkForError( status, "Cursor_InternalFetch(): fetch") for var in self.fetchVariables: assert isinstance(var, interp_variable.W_Variable) var.internalFetchNum += 1 attrptr = lltype.malloc(rffi.CArrayPtr(roci.ub4).TO, 1, flavor='raw') try: status = roci.OCIAttrGet( self.handle, roci.OCI_HTYPE_STMT, rffi.cast(roci.dvoidp, attrptr), lltype.nullptr(roci.Ptr(roci.ub4).TO), roci.OCI_ATTR_ROW_COUNT, self.environment.errorHandle) self.environment.checkForError( status, "Cursor_InternalFetch(): row count") self.actualRows = (rffi.cast(lltype.Signed, attrptr[0]) - self.rowCount) self.rowNum = 0 finally: lltype.free(attrptr, flavor='raw')
def SetValueEx(space, w_hkey, value_name, w_reserved, typ, w_value): """SetValueEx(key, value_name, reserved, type, value) - Stores data in the value field of an open registry key. key is an already open key, or any one of the predefined HKEY_* constants. value_name is a string containing the name of the value to set, or None type is an integer that specifies the type of the data. This should be one of: REG_BINARY -- Binary data in any form. REG_DWORD -- A 32-bit number. REG_DWORD_LITTLE_ENDIAN -- A 32-bit number in little-endian format. REG_DWORD_BIG_ENDIAN -- A 32-bit number in big-endian format. REG_EXPAND_SZ -- A null-terminated string that contains unexpanded references to environment variables (for example, %PATH%). REG_LINK -- A Unicode symbolic link. REG_MULTI_SZ -- An sequence of null-terminated strings, terminated by two null characters. Note that Python handles this termination automatically. REG_NONE -- No defined value type. REG_RESOURCE_LIST -- A device-driver resource list. REG_SZ -- A null-terminated string. reserved can be anything - zero is always passed to the API. value is a string that specifies the new value. This method can also set additional value and type information for the specified key. The key identified by the key parameter must have been opened with KEY_SET_VALUE access. To open the key, use the CreateKeyEx() or OpenKeyEx() methods. Value lengths are limited by available memory. Long values (more than 2048 bytes) should be stored as files with the filenames stored in the configuration registry. This helps the registry perform efficiently.""" hkey = hkey_w(w_hkey, space) buf, buflen = convert_to_regdata(space, w_value, typ) try: ret = rwinreg.RegSetValueEx(hkey, value_name, 0, typ, buf, buflen) finally: lltype.free(buf, flavor='raw') if ret != 0: raiseWindowsError(space, ret, 'RegSetValueEx')
def flock(space, w_fd, op): """flock(fd, operation) Perform the lock operation op on file descriptor fd. See the Unix manual flock(3) for details. (On some systems, this function is emulated using fcntl().)""" fd = _conv_descriptor(space, w_fd) if has_flock: rv = c_flock(fd, op) if rv < 0: raise OperationError(space.w_IOError, space.wrap(_get_error_msg())) else: l = _check_flock_op(space, op) rffi.setintfield(l, 'c_l_whence', 0) rffi.setintfield(l, 'c_l_start', 0) rffi.setintfield(l, 'c_l_len', 0) op = [F_SETLKW, F_SETLK][op & LOCK_NB] fcntl_flock(fd, op, l) lltype.free(l, flavor='raw')
def ioctl_w(self, space, cmd, w_option): from pypy.rpython.lltypesystem import rffi, lltype from pypy.rlib import rwin32 from pypy.rlib.rsocket import _c recv_ptr = lltype.malloc(rwin32.LPDWORD.TO, 1, flavor='raw') try: if cmd == _c.SIO_RCVALL: value_size = rffi.sizeof(rffi.INTP) elif cmd == _c.SIO_KEEPALIVE_VALS: value_size = rffi.sizeof(_c.tcp_keepalive) else: raise operationerrfmt(space.w_ValueError, "invalid ioctl command %d", cmd) value_ptr = lltype.malloc(rffi.VOIDP.TO, value_size, flavor='raw') try: if cmd == _c.SIO_RCVALL: option_ptr = rffi.cast(rffi.INTP, value_ptr) option_ptr[0] = space.int_w(w_option) elif cmd == _c.SIO_KEEPALIVE_VALS: w_onoff, w_time, w_interval = space.unpackiterable(w_option) option_ptr = rffi.cast(lltype.Ptr(_c.tcp_keepalive), value_ptr) option_ptr.c_onoff = space.uint_w(w_onoff) option_ptr.c_keepalivetime = space.uint_w(w_time) option_ptr.c_keepaliveinterval = space.uint_w(w_interval) res = _c.WSAIoctl( self.fd, cmd, value_ptr, value_size, rffi.NULL, 0, recv_ptr, rffi.NULL, rffi.NULL) if res < 0: raise converted_error(space, rsocket.last_error()) finally: if value_ptr: lltype.free(value_ptr, flavor='raw') return space.wrap(recv_ptr[0]) finally: lltype.free(recv_ptr, flavor='raw')
def test_repr(self, space, api): """ W_PyCMethodObject has a repr string which describes it as a method and gives its name and the name of its class. """ def func(space, w_self, w_args): return space.w_None c_func = ApiFunction([PyObject, PyObject], PyObject, func) func.api_func = c_func ml = lltype.malloc(PyMethodDef, flavor='raw', zero=True) namebuf = rffi.str2charp('func') ml.c_ml_name = namebuf ml.c_ml_meth = rffi.cast(PyCFunction_typedef, c_func.get_llhelper(space)) method = api.PyDescr_NewMethod(space.w_str, ml) assert repr(method).startswith( "<built-in method 'func' of 'str' object ") rffi.free_charp(namebuf) lltype.free(ml, flavor='raw')
def deflateInit(level=Z_DEFAULT_COMPRESSION, method=Z_DEFLATED, wbits=MAX_WBITS, memLevel=DEF_MEM_LEVEL, strategy=Z_DEFAULT_STRATEGY): """ Allocate and return an opaque 'stream' object that can be used to compress data. """ stream = lltype.malloc(z_stream, flavor='raw', zero=True) err = _deflateInit2(stream, level, method, wbits, memLevel, strategy) if err == Z_OK: return stream else: try: if err == Z_STREAM_ERROR: raise ValueError("Invalid initialization option") else: raise RZlibError.fromstream( stream, err, "while creating compression object") finally: lltype.free(stream, flavor='raw')
def test_varsized_struct(self): S = lltype.Struct('S', ('x', lltype.Signed), ('a', lltype.Array(lltype.Char))) s1 = lltype.malloc(S, 6, flavor='raw') s1.x = 5 s1.a[2] = 'F' sc = lltype2ctypes(s1, normalize=False) assert isinstance(sc.contents, ctypes.Structure) assert sc.contents.x == 5 assert sc.contents.a.length == 6 assert sc.contents.a.items[2] == ord('F') sc.contents.a.items[3] = ord('P') assert s1.a[3] == 'P' s1.a[1] = 'y' assert sc.contents.a.items[1] == ord('y') # now go back to lltype... res = ctypes2lltype(lltype.Ptr(S), sc) assert res == s1 assert res.x == 5 assert len(res.a) == 6 lltype.free(s1, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def test_mousebutton_wheel(self): if not self.is_interactive: py.test.skip("interactive test only") print print "Press the given MouseButtons:" print " Use Escape to pass tests." event_tests = [("left button", RSDL.BUTTON_LEFT), ("middle button", RSDL.BUTTON_MIDDLE), ("right button", RSDL.BUTTON_RIGHT), ("scroll up", RSDL.BUTTON_WHEELUP), ("scroll down", RSDL.BUTTON_WHEELDOWN)] test_success = [] event = lltype.malloc(RSDL.Event, flavor='raw') try: for button_test in event_tests: print " press %s:" % button_test[0] while True: ok = RSDL.WaitEvent(event) assert rffi.cast(lltype.Signed, ok) == 1 c_type = rffi.getintfield(event, 'c_type') if c_type == RSDL.MOUSEBUTTONDOWN: pass elif c_type == RSDL.MOUSEBUTTONUP: b = rffi.cast(RSDL.MouseButtonEventPtr, event) if rffi.getintfield(b, 'c_button') == button_test[1]: test_success.append(True) break elif c_type == RSDL.KEYUP: p = rffi.cast(RSDL.KeyboardEventPtr, event) if rffi.getintfield(p.c_keysym, 'c_sym') == RSDL.K_ESCAPE: test_success.append(False) print " manually aborted" break #break if False in test_success: py.test.fail("") finally: lltype.free(event, flavor='raw')
def get_calldescr_ty_function_ptr(self, calldescr): if not calldescr.ty_function_ptr: # args_indices = calldescr.args_indices param_types = lltype.malloc(rffi.CArray(llvm_rffi.LLVMTypeRef), len(args_indices), flavor='raw') for i in range(len(args_indices)): param_types[i] = self.types_by_index[args_indices[i]] # res_index = calldescr.res_index if res_index < 0: ty_result = self.ty_void else: ty_result = self.types_by_index[res_index] # ty_func = llvm_rffi.LLVMFunctionType(ty_result, param_types, len(args_indices), 0) lltype.free(param_types, flavor='raw') ty_funcptr = llvm_rffi.LLVMPointerType(ty_func, 0) calldescr.ty_function_ptr = ty_funcptr # return calldescr.ty_function_ptr
def test_with_explicit_length(self): A = lltype.Array(lltype.Signed) a1 = lltype.malloc(A, 5, flavor='raw') a1[0] = 42 c1 = lltype2ctypes(a1, normalize=False) assert c1.contents.length == 5 assert c1.contents.items[0] == 42 res = ctypes2lltype(lltype.Ptr(A), c1) assert res == a1 assert len(res) == 5 assert res[0] == 42 res[0] += 1 assert c1.contents.items[0] == 43 assert a1[0] == 43 a1[0] += 2 assert c1.contents.items[0] == 45 assert a1[0] == 45 c1.contents.items[0] += 3 assert res[0] == 48 assert a1[0] == 48 lltype.free(a1, flavor='raw') assert not ALLOCATED # detects memory leaks in the test
def flock(space, w_fd, op): """flock(fd, operation) Perform the lock operation op on file descriptor fd. See the Unix manual flock(3) for details. (On some systems, this function is emulated using fcntl().)""" fd = space.c_filedescriptor_w(w_fd) if has_flock: rv = c_flock(fd, op) if rv < 0: raise _get_error(space, "flock") else: l = _check_flock_op(space, op) rffi.setintfield(l, 'c_l_whence', 0) rffi.setintfield(l, 'c_l_start', 0) rffi.setintfield(l, 'c_l_len', 0) op = [F_SETLKW, F_SETLK][int(bool(op & LOCK_NB))] op = rffi.cast(rffi.INT, op) # C long => C int fcntl_flock(fd, op, l) lltype.free(l, flavor='raw')
def create(space, threaded, events): "Create a new environment object from scratch" mode = roci.OCI_OBJECT if threaded: mode |= roci.OCI_THREADED if events: mode |= roci.OCI_EVENTS handleptr = lltype.malloc(rffi.CArrayPtr(roci.OCIEnv).TO, 1, flavor='raw') try: status = roci.OCIEnvNlsCreate( handleptr, mode, None, None, None, None, 0, lltype.nullptr(rffi.CArray(roci.dvoidp)), config.CHARSETID, config.CHARSETID) if not handleptr[0] or status not in (roci.OCI_SUCCESS, roci.OCI_SUCCESS_WITH_INFO): raise OperationError( get(space).w_InterfaceError, space.wrap("Unable to acquire Oracle environment handle")) handle = handleptr[0] finally: lltype.free(handleptr, flavor='raw') try: newenv = Environment(space, handle) except: roci.OCIHandleFree(handle, roci.OCI_HTYPE_ENV) raise newenv.maxBytesPerCharacter = config.BYTES_PER_CHAR newenv.maxStringBytes = config.BYTES_PER_CHAR * config.MAX_STRING_CHARS return newenv
def test_blockbuildermixin(translated=True): mc = BlockBuilderMixin(translated) writtencode = [] for i in range(mc.SUBBLOCK_SIZE * 2 + 3): assert mc.get_relative_pos() == i mc.writechar(chr(i % 255)) writtencode.append(chr(i % 255)) if translated: assert mc._cursubindex == 3 assert mc._cursubblock assert mc._cursubblock.prev assert mc._cursubblock.prev.prev assert not mc._cursubblock.prev.prev.prev # for i in range(0, mc.SUBBLOCK_SIZE * 2 + 3, 2): mc.overwrite(i, chr((i + 63) % 255)) writtencode[i] = chr((i + 63) % 255) # p = lltype.malloc(rffi.CCHARP.TO, mc.SUBBLOCK_SIZE * 2 + 3, flavor='raw') addr = rffi.cast(lltype.Signed, p) mc.copy_to_raw_memory(addr) # for i in range(mc.SUBBLOCK_SIZE * 2 + 3): assert p[i] == writtencode[i] # debug._log = debug.DebugLog() try: mc._dump(addr, 'test-logname-section') log = list(debug._log) finally: debug._log = None encoded = ''.join(writtencode).encode('hex').upper() ataddr = '@%x' % addr assert log == [('test-logname-section', [('debug_print', 'SYS_EXECUTABLE', '??'), ('debug_print', 'CODE_DUMP', ataddr, '+0 ', encoded)])] lltype.free(p, flavor='raw')
def llimpl_FormatError(code): "Return a message corresponding to the given Windows error code." buf = lltype.malloc(rffi.CCHARPP.TO, 1, flavor='raw') try: msglen = FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM, None, rffi.cast(DWORD, code), DEFAULT_LANGUAGE, rffi.cast(rffi.CCHARP, buf), 0, None) if msglen <= 2: # includes the case msglen < 0 return fake_FormatError(code) # FormatMessage always appends \r\n. buflen = intmask(msglen - 2) assert buflen > 0 result = rffi.charpsize2str(buf[0], buflen) LocalFree(rffi.cast(rffi.VOIDP, buf[0])) finally: lltype.free(buf, flavor='raw') return result
def _performDefine(self): # determine number of items in select-list attrptr = lltype.malloc(rffi.CArrayPtr(roci.ub4).TO, 1, flavor='raw') try: status = roci.OCIAttrGet(self.handle, roci.OCI_HTYPE_STMT, rffi.cast(roci.dvoidp, attrptr), lltype.nullptr(roci.Ptr(roci.ub4).TO), roci.OCI_ATTR_PARAM_COUNT, self.environment.errorHandle) self.environment.checkForError(status, "Cursor_PerformDefine()") numParams = attrptr[0] finally: lltype.free(attrptr, flavor='raw') self.fetchVariables = [] # define a variable for each select-item self.fetchArraySize = self.arraySize for i in range(numParams): var = interp_variable.define(self, i + 1, self.fetchArraySize) assert isinstance(var, interp_variable.W_Variable) self.fetchVariables.append(var)
def _setRowCount(self): if self.statementType == roci.OCI_STMT_SELECT: self.rowCount = 0 self.actualRows = -1 self.rowNum = 0 elif self.statementType in (roci.OCI_STMT_INSERT, roci.OCI_STMT_UPDATE, roci.OCI_STMT_DELETE): attrptr = lltype.malloc(rffi.CArrayPtr(roci.ub4).TO, 1, flavor='raw') try: status = roci.OCIAttrGet(self.handle, roci.OCI_HTYPE_STMT, rffi.cast(roci.dvoidp, attrptr), lltype.nullptr(roci.Ptr(roci.ub4).TO), roci.OCI_ATTR_ROW_COUNT, self.environment.errorHandle) self.environment.checkForError(status, "Cursor_SetRowCount()") self.rowCount = rffi.cast(lltype.Signed, attrptr[0]) finally: lltype.free(attrptr, flavor='raw') else: self.rowCount = -1