def buffer_attach(space, py_obj, w_obj): """ Fills a newly allocated PyBufferObject with the given (str) buffer object. """ py_buf = rffi.cast(PyBufferObject, py_obj) py_buf.c_b_offset = 0 rffi.setintfield(py_buf, 'c_b_readonly', 1) rffi.setintfield(py_buf, 'c_b_hash', -1) if isinstance(w_obj, SubBuffer): py_buf.c_b_offset = w_obj.offset w_obj = w_obj.buffer # If w_obj already allocated a fixed buffer, use it, and keep a # reference to w_obj. # Otherwise, b_base stays NULL, and we own the b_ptr. if isinstance(w_obj, StringBuffer): py_buf.c_b_base = lltype.nullptr(PyObject.TO) py_buf.c_b_ptr = rffi.cast(rffi.VOIDP, rffi.str2charp(w_obj.value)) py_buf.c_b_size = w_obj.getlength() elif isinstance(w_obj, ArrayBuffer): w_base = w_obj.array py_buf.c_b_base = make_ref(space, w_base) py_buf.c_b_ptr = rffi.cast(rffi.VOIDP, w_obj.array._charbuf_start()) py_buf.c_b_size = w_obj.getlength() else: raise OperationError(space.w_NotImplementedError, space.wrap( "buffer flavor not supported"))
def poll(fddict, timeout=-1): """'fddict' maps file descriptors to interesting events. 'timeout' is an integer in milliseconds, and NOT a float number of seconds, but it's the same in CPython. Use -1 for infinite. Returns a list [(fd, events)]. """ numfd = len(fddict) pollfds = lltype.malloc(_c.pollfdarray, numfd, flavor='raw') try: i = 0 for fd, events in fddict.iteritems(): rffi.setintfield(pollfds[i], 'c_fd', fd) rffi.setintfield(pollfds[i], 'c_events', events) i += 1 assert i == numfd ret = _c.poll(pollfds, numfd, timeout) if ret < 0: raise PollError(_c.geterrno()) retval = [] for i in range(numfd): pollfd = pollfds[i] fd = rffi.cast(lltype.Signed, pollfd.c_fd) revents = rffi.cast(lltype.Signed, pollfd.c_revents) if revents: retval.append((fd, revents)) finally: lltype.free(pollfds, flavor='raw') return retval
def _select(self, for_writing): """Returns 0 when reading/writing is possible, 1 when timing out and -1 on error.""" timeout = self.timeout if timeout <= 0.0 or self.fd == _c.INVALID_SOCKET: # blocking I/O or no socket. return 0 tv = rffi.make(_c.timeval) rffi.setintfield(tv, 'c_tv_sec', int(timeout)) rffi.setintfield(tv, 'c_tv_usec', int((timeout - int(timeout)) * 1000000)) fds = lltype.malloc(_c.fd_set.TO, flavor='raw') _c.FD_ZERO(fds) _c.FD_SET(self.fd, fds) null = lltype.nullptr(_c.fd_set.TO) if for_writing: n = _c.select(self.fd + 1, null, fds, null, tv) else: n = _c.select(self.fd + 1, fds, null, null, tv) lltype.free(fds, flavor='raw') lltype.free(tv, flavor='raw') if n < 0: return -1 if n == 0: return 1 return 0
def fill_from_object(self, space, w_address): # XXX a bit of code duplication _, w_port = space.unpackiterable(w_address, 2) port = space.int_w(w_port) a = self.lock(_c.sockaddr_in) rffi.setintfield(a, 'c_sin_port', htons(port)) self.unlock()
def buffer_attach(space, py_obj, w_obj): """ Fills a newly allocated PyBufferObject with the given (str) buffer object. """ py_buf = rffi.cast(PyBufferObject, py_obj) py_buf.c_b_offset = 0 rffi.setintfield(py_buf, 'c_b_readonly', 1) rffi.setintfield(py_buf, 'c_b_hash', -1) if isinstance(w_obj, SubBuffer): py_buf.c_b_offset = w_obj.offset w_obj = w_obj.buffer # If w_obj already allocated a fixed buffer, use it, and keep a # reference to w_obj. # Otherwise, b_base stays NULL, and we own the b_ptr. if isinstance(w_obj, StringBuffer): py_buf.c_b_base = lltype.nullptr(PyObject.TO) py_buf.c_b_ptr = rffi.cast(rffi.VOIDP, rffi.str2charp(w_obj.value)) py_buf.c_b_size = w_obj.getlength() elif isinstance(w_obj, ArrayBuffer): w_base = w_obj.array py_buf.c_b_base = make_ref(space, w_base) py_buf.c_b_ptr = rffi.cast(rffi.VOIDP, w_obj.array._charbuf_start()) py_buf.c_b_size = w_obj.getlength() else: raise OperationError(space.w_NotImplementedError, space.wrap("buffer flavor not supported"))
def decompress(stream, data, flush=Z_SYNC_FLUSH, max_length=sys.maxint): """ Feed more data into an inflate stream. Returns a tuple (string, finished, unused_data_length). The string contains (a part of) the decompressed data. If flush != Z_NO_FLUSH, this also flushes the output data; see zlib.h or the documentation of the zlib module for the possible values of 'flush'. The 'string' is never longer than 'max_length'. The 'unused_data_length' is the number of unprocessed input characters, either because they are after the end of the compressed stream or because processing it would cause the 'max_length' to be exceeded. """ # Warning, reentrant calls to the zlib with a given stream can cause it # to crash. The caller of pypy.rlib.rzlib should use locks if needed. # _operate() does not support the Z_FINISH method of decompressing. # We can use Z_SYNC_FLUSH instead and manually check that we got to # the end of the data. if flush == Z_FINISH: flush = Z_SYNC_FLUSH should_finish = True else: should_finish = False while_doing = "while decompressing data" data, err, avail_in = _operate(stream, data, flush, max_length, _inflate, while_doing) if should_finish: # detect incomplete input rffi.setintfield(stream, 'c_avail_in', 0) err = _inflate(stream, Z_FINISH) if err < 0: raise RZlibError.fromstream(stream, err, while_doing) finished = (err == Z_STREAM_END) return data, finished, avail_in
def frame_attach(space, py_obj, w_obj): "Fills a newly allocated PyFrameObject with a frame object" frame = space.interp_w(PyFrame, w_obj) py_frame = rffi.cast(PyFrameObject, py_obj) py_frame.c_f_code = rffi.cast(PyCodeObject, make_ref(space, frame.pycode)) py_frame.c_f_globals = make_ref(space, frame.w_globals) rffi.setintfield(py_frame, 'c_f_lineno', frame.f_lineno)
def _select(self, for_writing): """Returns 0 when reading/writing is possible, 1 when timing out and -1 on error.""" timeout = self.timeout if timeout <= 0.0 or self.fd == _c.INVALID_SOCKET: # blocking I/O or no socket. return 0 tv = rffi.make(_c.timeval) rffi.setintfield(tv, 'c_tv_sec', int(timeout)) rffi.setintfield(tv, 'c_tv_usec', int((timeout-int(timeout)) * 1000000)) fds = lltype.malloc(_c.fd_set.TO, flavor='raw') _c.FD_ZERO(fds) _c.FD_SET(self.fd, fds) null = lltype.nullptr(_c.fd_set.TO) if for_writing: n = _c.select(self.fd + 1, null, fds, null, tv) else: n = _c.select(self.fd + 1, fds, null, null, tv) lltype.free(fds, flavor='raw') lltype.free(tv, flavor='raw') if n < 0: return -1 if n == 0: return 1 return 0
def _sem_timedwait_save(sem, deadline): delay = 0 void = lltype.nullptr(rffi.VOIDP.TO) with lltype.scoped_alloc(TIMEVALP.TO, 1) as tvdeadline: while True: # poll if _sem_trywait(sem) == 0: return 0 elif rposix.get_errno() != errno.EAGAIN: return -1 now = gettimeofday() c_tv_sec = rffi.getintfield(deadline[0], 'c_tv_sec') c_tv_nsec = rffi.getintfield(deadline[0], 'c_tv_nsec') if (c_tv_sec < now[0] or (c_tv_sec == now[0] and c_tv_nsec <= now[1])): rposix.set_errno(errno.ETIMEDOUT) return -1 # calculate how much time is left difference = ((c_tv_sec - now[0]) * 1000000 + (c_tv_nsec - now[1])) # check delay not too long -- maximum is 20 msecs if delay > 20000: delay = 20000 if delay > difference: delay = difference delay += 1000 # sleep rffi.setintfield(tvdeadline[0], 'c_tv_sec', delay / 1000000) rffi.setintfield(tvdeadline[0], 'c_tv_usec', delay % 1000000) if _select(0, void, void, void, tvdeadline) < 0: return -1
def get_addr(hostname, socktype, protocol, port, address_to_fill): hostent = _c.gethostbyname(hostname) if not hostent: raise GAIError(EAI_FAIL) hname, aliases, address_list = gethost_common("", hostent) result = [] for address in address_list: if address.family == _c.AF_INET: a = address.lock(_c.sockaddr_in) rffi.setintfield(a, 'c_sin_port', r_uint(port) & 0xffff) address.unlock() a = address.lock() addr = make_address(a, address.addrlen, address_to_fill) address.unlock() result.append((address.family, socktype, protocol, "", # XXX canonname? addr)) return result
def get_addr(hostname, socktype, protocol, port, address_to_fill): hostent = _c.gethostbyname(hostname) if not hostent: raise GAIError(EAI_FAIL) hname, aliases, address_list = gethost_common("", hostent) result = [] for address in address_list: if address.family == _c.AF_INET: a = address.lock(_c.sockaddr_in) rffi.setintfield(a, 'c_sin_port', port & 0xffff) address.unlock() a = address.lock() addr = make_address(a, address.addrlen, address_to_fill) address.unlock() result.append(( address.family, socktype, protocol, "", # XXX canonname? addr)) return result
def _operate(stream, data, flush, max_length, cfunc, while_doing): """Common code for compress() and decompress(). """ # Prepare the input buffer for the stream with lltype.scoped_alloc(rffi.CCHARP.TO, len(data)) as inbuf: for i in xrange(len(data)): inbuf[i] = data[i] stream.c_next_in = rffi.cast(Bytefp, inbuf) rffi.setintfield(stream, 'c_avail_in', len(data)) # Prepare the output buffer with lltype.scoped_alloc(rffi.CCHARP.TO, OUTPUT_BUFFER_SIZE) as outbuf: # Strategy: we call deflate() to get as much output data as fits in # the buffer, then accumulate all output into a StringBuffer # 'result'. result = StringBuilder() while True: stream.c_next_out = rffi.cast(Bytefp, outbuf) bufsize = OUTPUT_BUFFER_SIZE if max_length < bufsize: if max_length <= 0: err = Z_OK break bufsize = max_length max_length -= bufsize rffi.setintfield(stream, 'c_avail_out', bufsize) err = cfunc(stream, flush) if err == Z_OK or err == Z_STREAM_END: # accumulate data into 'result' avail_out = rffi.cast(lltype.Signed, stream.c_avail_out) result.append_charpsize(outbuf, bufsize - avail_out) # if the output buffer is full, there might be more data # so we need to try again. Otherwise, we're done. if avail_out > 0: break # We're also done if we got a Z_STREAM_END (which should # only occur when flush == Z_FINISH). if err == Z_STREAM_END: break else: continue elif err == Z_BUF_ERROR: avail_out = rffi.cast(lltype.Signed, stream.c_avail_out) # When compressing, we will only get Z_BUF_ERROR if # the output buffer was full but there wasn't more # output when we tried again, so it is not an error # condition. if avail_out == bufsize: break # fallback case: report this error raise RZlibError.fromstream(stream, err, while_doing) # When decompressing, if the compressed stream of data was truncated, # then the zlib simply returns Z_OK and waits for more. If it is # complete it returns Z_STREAM_END. return (result.build(), err, rffi.cast(lltype.Signed, stream.c_avail_in))
def draw_pixel(self, x, y, color): color = self.colors[color] start_x = x * self.scale start_y = y * self.scale dstrect = self.blit_rect rffi.setintfield(dstrect, 'c_x', start_x) rffi.setintfield(dstrect, 'c_y', start_y) RSDL.FillRect(self.screen, dstrect, color)
def from_in6_addr(in6_addr): result = instantiate(INET6Address) # store the malloc'ed data into 'result' as soon as possible # to avoid leaks if an exception occurs inbetween sin = lltype.malloc(_c.sockaddr_in6, flavor='raw', zero=True) result.setdata(sin, sizeof(_c.sockaddr_in6)) rffi.setintfield(sin, 'c_sin6_family', AF_INET) rffi.structcopy(sin.c_sin6_addr, in6_addr) return result
def fakeimpl(arg): st = getattr(os, name)(arg) fields = [TYPE for fieldname, TYPE in LL_STAT_FIELDS] TP = TUPLE_TYPE(fields) ll_tup = lltype.malloc(TP.TO) for i, (fieldname, TYPE) in enumerate(LL_STAT_FIELDS): val = getattr(st, fieldname) rffi.setintfield(ll_tup, 'item%d' % i, int(val)) return ll_tup
def select(inl, outl, excl, timeout=-1.0): nfds = 0 if inl: ll_inl = lltype.malloc(_c.fd_set.TO, flavor='raw') _c.FD_ZERO(ll_inl) for i in inl: _c.FD_SET(i, ll_inl) if i > nfds: nfds = i else: ll_inl = lltype.nullptr(_c.fd_set.TO) if outl: ll_outl = lltype.malloc(_c.fd_set.TO, flavor='raw') _c.FD_ZERO(ll_outl) for i in outl: _c.FD_SET(i, ll_outl) if i > nfds: nfds = i else: ll_outl = lltype.nullptr(_c.fd_set.TO) if excl: ll_excl = lltype.malloc(_c.fd_set.TO, flavor='raw') _c.FD_ZERO(ll_excl) for i in excl: _c.FD_SET(i, ll_excl) if i > nfds: nfds = i else: ll_excl = lltype.nullptr(_c.fd_set.TO) if timeout != -1.0: ll_timeval = rffi.make(_c.timeval) rffi.setintfield(ll_timeval, 'c_tv_sec', int(timeout)) rffi.setintfield(ll_timeval, 'c_tv_usec', int((timeout-int(timeout)) * 1000000)) else: ll_timeval = lltype.nullptr(_c.timeval) try: res = _c.select(nfds + 1, ll_inl, ll_outl, ll_excl, ll_timeval) if res == -1: raise SelectError(_c.geterrno()) if res == 0: return ([], [], []) else: return ( [i for i in inl if _c.FD_ISSET(i, ll_inl)], [i for i in outl if _c.FD_ISSET(i, ll_outl)], [i for i in excl if _c.FD_ISSET(i, ll_excl)]) finally: if ll_inl: lltype.free(ll_inl, flavor='raw') if ll_outl: lltype.free(ll_outl, flavor='raw') if ll_excl: lltype.free(ll_excl, flavor='raw') if ll_timeval: lltype.free(ll_timeval, flavor='raw')
def descr__init__(self, space, w_ident, filter=KQ_FILTER_READ, flags=KQ_EV_ADD, fflags=0, data=0, udata=0): ident = space.c_filedescriptor_w(w_ident) self.event = lltype.malloc(kevent, flavor="raw") rffi.setintfield(self.event, "c_ident", ident) rffi.setintfield(self.event, "c_filter", filter) rffi.setintfield(self.event, "c_flags", flags) rffi.setintfield(self.event, "c_fflags", fflags) rffi.setintfield(self.event, "c_data", data) self.event.c_udata = rffi.cast(rffi.VOIDP, udata)
def code_attach(space, py_obj, w_obj): py_code = rffi.cast(PyCodeObject, py_obj) assert isinstance(w_obj, PyCode) py_code.c_co_name = make_ref(space, space.wrap(w_obj.co_name)) co_flags = 0 for name, value in ALL_CODE_FLAGS: if w_obj.co_flags & getattr(pycode, name): co_flags |= value rffi.setintfield(py_code, 'c_co_flags', co_flags) rffi.setintfield(py_code, 'c_co_argcount', w_obj.co_argcount)
def makeipv4addr(s_addr, result=None): if result is None: result = instantiate(INETAddress) elif result.family != AF_INET: raise RSocketError("address family mismatched") sin = lltype.malloc(_c.sockaddr_in, flavor='raw', zero=True) result.setdata(sin, sizeof(_c.sockaddr_in)) rffi.setintfield(sin, 'c_sin_family', AF_INET) # PLAT sin_len rffi.setintfield(sin.c_sin_addr, 'c_s_addr', s_addr) return result
def flush(self): if not self.running: raise OperationError( self.space.w_ValueError, self.space.wrap("this object was already flushed")) self.running = False out_bufsize = SMALLCHUNK out_buf = lltype.malloc(rffi.CCHARP.TO, out_bufsize, flavor='raw', zero=True) try: self.bzs.c_next_out = out_buf rffi.setintfield(self.bzs, 'c_avail_out', out_bufsize) total_out = _bzs_total_out(self.bzs) temp = [] while True: bzerror = BZ2_bzCompress(self.bzs, BZ_FINISH) if bzerror == BZ_STREAM_END: break elif bzerror != BZ_FINISH_OK: _catch_bz2_error(self.space, bzerror) if rffi.getintfield(self.bzs, 'c_avail_out') == 0: data = "".join( [out_buf[i] for i in range(_bzs_total_out(self.bzs))]) temp.append(data) out_bufsize = _new_buffer_size(out_bufsize) out_buf = lltype.malloc(rffi.CCHARP.TO, out_bufsize, flavor='raw', zero=True) self.bzs.c_next_out = out_buf rffi.setintfield(self.bzs, 'c_avail_out', out_bufsize) if temp: return self.space.wrap("".join(temp)) if rffi.getintfield(self.bzs, 'c_avail_out'): size = _bzs_total_out(self.bzs) - total_out res = "".join([out_buf[i] for i in range(size)]) return self.space.wrap(res) total_out = _bzs_total_out(self.bzs) res = "".join([out_buf[i] for i in range(total_out)]) return self.space.wrap(res) finally: lltype.free(out_buf, flavor='raw')
def test_unknown_addr_as_object(): c_addr = lltype.malloc(rsocket._c.sockaddr, flavor='raw') c_addr.c_sa_data[0] = 'c' rffi.setintfield(c_addr, 'c_sa_family', 15) # XXX what size to pass here? for the purpose of this test it has # to be short enough so we have some data, 1 sounds good enough # + sizeof USHORT w_obj = rsocket.Address(c_addr, 1 + 2).as_object(-1, space) assert space.is_true(space.isinstance(w_obj, space.w_tuple)) assert space.int_w(space.getitem(w_obj, space.wrap(0))) == 15 assert space.str_w(space.getitem(w_obj, space.wrap(1))) == 'c'
def epoll_ctl(self, space, ctl, w_fd, eventmask, ignore_ebadf=False): fd = space.c_filedescriptor_w(w_fd) with lltype.scoped_alloc(epoll_event) as ev: ev.c_events = rffi.cast(rffi.UINT, eventmask) rffi.setintfield(ev.c_data, "c_fd", fd) result = epoll_ctl(self.epfd, ctl, fd, ev) if ignore_ebadf and get_errno() == errno.EBADF: result = 0 if result < 0: raise exception_from_errno(space, space.w_IOError)
def epoll_ctl(self, space, ctl, w_fd, eventmask, ignore_ebadf=False): fd = space.c_filedescriptor_w(w_fd) with lltype.scoped_alloc(epoll_event) as ev: ev.c_events = rffi.cast(rffi.UINT, eventmask) rffi.setintfield(ev.c_data, 'c_fd', fd) result = epoll_ctl(self.epfd, ctl, fd, ev) if ignore_ebadf and get_errno() == errno.EBADF: result = 0 if result < 0: raise exception_from_errno(space, space.w_IOError)
def mallocrect(x, y, w, h): p = lltype.malloc(RSDL.Rect, flavor='raw') rffi.setintfield(p, 'c_x', x) rffi.setintfield(p, 'c_y', y) rffi.setintfield(p, 'c_w', w) rffi.setintfield(p, 'c_h', h) return p
def time_sleep_llimpl(secs): void = lltype.nullptr(rffi.VOIDP.TO) t = lltype.malloc(self.TIMEVAL, flavor='raw') try: frac = math.fmod(secs, 1.0) rffi.setintfield(t, 'c_tv_sec', int(secs)) rffi.setintfield(t, 'c_tv_usec', int(frac*1000000.0)) if rffi.cast(rffi.LONG, c_select(0, void, void, void, t)) != 0: errno = rposix.get_errno() if errno != EINTR: raise OSError(rposix.get_errno(), "Select failed") finally: lltype.free(t, flavor='raw')
def posix_fakeimpl(arg): st = getattr(os, name)(arg) fields = [TYPE for fieldname, TYPE in STAT_FIELDS] TP = TUPLE_TYPE(fields) ll_tup = lltype.malloc(TP.TO) for i, (fieldname, TYPE) in enumerate(STAT_FIELDS): val = getattr(st, fieldname) if isinstance(TYPE, lltype.Number): rffi.setintfield(ll_tup, 'item%d' % i, int(val)) elif TYPE is lltype.Float: setattr(ll_tup, 'item%d' % i, float(val)) else: setattr(ll_tup, 'item%d' % i, val) return ll_tup
def mktime(space, w_tup): """mktime(tuple) -> floating point number Convert a time tuple in local time to seconds since the Epoch.""" buf = _gettmarg(space, w_tup, allowNone=False) rffi.setintfield(buf, "c_tm_wday", -1) tt = c_mktime(buf) # A return value of -1 does not necessarily mean an error, but tm_wday # cannot remain set to -1 if mktime succeeds. if tt == -1 and rffi.getintfield(buf, "c_tm_wday") == -1: raise OperationError(space.w_OverflowError, space.wrap("mktime argument out of range")) return space.wrap(float(tt))
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 flush(self): if not self.running: raise OperationError(self.space.w_ValueError, self.space.wrap("this object was already flushed")) self.running = False out_bufsize = SMALLCHUNK out_buf = lltype.malloc(rffi.CCHARP.TO, out_bufsize, flavor='raw', zero=True) try: self.bzs.c_next_out = out_buf rffi.setintfield(self.bzs, 'c_avail_out', out_bufsize) total_out = _bzs_total_out(self.bzs) temp = [] while True: bzerror = BZ2_bzCompress(self.bzs, BZ_FINISH) if bzerror == BZ_STREAM_END: break elif bzerror != BZ_FINISH_OK: _catch_bz2_error(self.space, bzerror) if rffi.getintfield(self.bzs, 'c_avail_out') == 0: data = "".join([out_buf[i] for i in range(_bzs_total_out(self.bzs))]) temp.append(data) out_bufsize = _new_buffer_size(out_bufsize) out_buf = lltype.malloc(rffi.CCHARP.TO, out_bufsize, flavor='raw', zero=True) self.bzs.c_next_out = out_buf rffi.setintfield(self.bzs, 'c_avail_out', out_bufsize) if rffi.getintfield(self.bzs, 'c_avail_out'): size = _bzs_total_out(self.bzs) - total_out res = "".join([out_buf[i] for i in range(size)]) else: total_out = _bzs_total_out(self.bzs) res = "".join([out_buf[i] for i in range(total_out)]) if not temp: return self.space.wrap(res) else: temp.append(res) return self.space.wrap("".join(temp)) finally: lltype.free(out_buf, flavor='raw')
def time_sleep_llimpl(secs): void = lltype.nullptr(rffi.VOIDP.TO) t = lltype.malloc(self.TIMEVAL, flavor='raw') try: frac = math.fmod(secs, 1.0) rffi.setintfield(t, 'c_tv_sec', int(secs)) rffi.setintfield(t, 'c_tv_usec', int(frac * 1000000.0)) if rffi.cast(rffi.LONG, c_select(0, void, void, void, t)) != 0: errno = rposix.get_errno() if errno != EINTR: raise OSError(rposix.get_errno(), "Select failed") finally: lltype.free(t, flavor='raw')
def GetVersionEx(): info = lltype.malloc(OSVERSIONINFO, flavor='raw') rffi.setintfield(info, 'c_dwOSVersionInfoSize', rffi.sizeof(OSVERSIONINFO)) try: if not _GetVersionEx(info): raise lastWindowsError() return (rffi.cast(lltype.Signed, info.c_dwMajorVersion), rffi.cast(lltype.Signed, info.c_dwMinorVersion), rffi.cast(lltype.Signed, info.c_dwBuildNumber), rffi.cast(lltype.Signed, info.c_dwPlatformId), rffi.charp2str(rffi.cast(rffi.CCHARP, info.c_szCSDVersion))) finally: lltype.free(info, flavor='raw')
def get_new_method_def(space): state = space.fromcache(State) if state.new_method_def: return state.new_method_def from pypy.module.cpyext.modsupport import PyMethodDef ptr = lltype.malloc(PyMethodDef, flavor="raw", zero=True, immortal=True) ptr.c_ml_name = rffi.str2charp("__new__") lltype.render_immortal(ptr.c_ml_name) rffi.setintfield(ptr, 'c_ml_flags', METH_VARARGS | METH_KEYWORDS) ptr.c_ml_doc = rffi.str2charp( "T.__new__(S, ...) -> a new object with type S, a subtype of T") lltype.render_immortal(ptr.c_ml_doc) state.new_method_def = ptr return ptr
def __init__(self, path): sun = lltype.malloc(_c.sockaddr_un, flavor='raw', zero=True) baseofs = offsetof(_c.sockaddr_un, 'c_sun_path') self.setdata(sun, baseofs + len(path)) rffi.setintfield(sun, 'c_sun_family', AF_UNIX) if _c.linux and path.startswith('\x00'): # Linux abstract namespace extension if len(path) > sizeof(_c.sockaddr_un.c_sun_path): raise RSocketError("AF_UNIX path too long") else: # regular NULL-terminated string if len(path) >= sizeof(_c.sockaddr_un.c_sun_path): raise RSocketError("AF_UNIX path too long") sun.c_sun_path[len(path)] = '\x00' for i in range(len(path)): sun.c_sun_path[i] = path[i]
def posix_fakeimpl(arg): if s_arg == traits.str0: arg = hlstr(arg) st = getattr(os, name)(arg) fields = [TYPE for fieldname, TYPE in STAT_FIELDS] TP = TUPLE_TYPE(fields) ll_tup = lltype.malloc(TP.TO) for i, (fieldname, TYPE) in enumerate(STAT_FIELDS): val = getattr(st, fieldname) if isinstance(TYPE, lltype.Number): rffi.setintfield(ll_tup, 'item%d' % i, int(val)) elif TYPE is lltype.Float: setattr(ll_tup, 'item%d' % i, float(val)) else: setattr(ll_tup, 'item%d' % i, val) return ll_tup
def decompress(self, data): """decompress(data) -> string Provide more data to the decompressor object. It will return chunks of decompressed data whenever possible. If you try to decompress data after the end of stream is found, EOFError will be raised. If any data was found after the end of stream, it'll be ignored and saved in unused_data attribute.""" if data == '': return self.space.wrap('') if not self.running: raise OperationError( self.space.w_EOFError, self.space.wrap("end of stream was already found")) in_bufsize = len(data) with lltype.scoped_alloc(rffi.CCHARP.TO, in_bufsize) as in_buf: for i in range(in_bufsize): in_buf[i] = data[i] self.bzs.c_next_in = in_buf rffi.setintfield(self.bzs, 'c_avail_in', in_bufsize) with OutBuffer(self.bzs) as out: while True: bzerror = BZ2_bzDecompress(self.bzs) if bzerror == BZ_STREAM_END: if rffi.getintfield(self.bzs, 'c_avail_in') != 0: unused = [ self.bzs.c_next_in[i] for i in range( rffi.getintfield(self.bzs, 'c_avail_in')) ] self.unused_data = "".join(unused) self.running = False break if bzerror != BZ_OK: _catch_bz2_error(self.space, bzerror) if rffi.getintfield(self.bzs, 'c_avail_in') == 0: break elif rffi.getintfield(self.bzs, 'c_avail_out') == 0: out.prepare_next_chunk() res = out.make_result_string() return self.space.wrap(res)
def _connect(self, address): """Connect the socket to a remote address.""" addr = address.lock() res = _c.socketconnect(self.fd, addr, address.addrlen) address.unlock() errno = _c.geterrno() timeout = self.timeout if timeout > 0.0 and res < 0 and errno == _c.EWOULDBLOCK: tv = rffi.make(_c.timeval) rffi.setintfield(tv, 'c_tv_sec', int(timeout)) rffi.setintfield(tv, 'c_tv_usec', int((timeout-int(timeout)) * 1000000)) fds = lltype.malloc(_c.fd_set.TO, flavor='raw') _c.FD_ZERO(fds) _c.FD_SET(self.fd, fds) fds_exc = lltype.malloc(_c.fd_set.TO, flavor='raw') _c.FD_ZERO(fds_exc) _c.FD_SET(self.fd, fds_exc) null = lltype.nullptr(_c.fd_set.TO) try: n = _c.select(self.fd + 1, null, fds, fds_exc, tv) if n > 0: if _c.FD_ISSET(self.fd, fds): # socket writable == connected return (0, False) else: # per MS docs, call getsockopt() to get error assert _c.FD_ISSET(self.fd, fds_exc) return (self.getsockopt_int(_c.SOL_SOCKET, _c.SO_ERROR), False) elif n == 0: return (_c.EWOULDBLOCK, True) else: return (_c.geterrno(), False) finally: lltype.free(fds, flavor='raw') lltype.free(fds_exc, flavor='raw') lltype.free(tv, flavor='raw') if res == 0: errno = 0 return (errno, False)
def _connect(self, address): """Connect the socket to a remote address.""" addr = address.lock() res = _c.socketconnect(self.fd, addr, address.addrlen) address.unlock() errno = _c.geterrno() timeout = self.timeout if timeout > 0.0 and res < 0 and errno == _c.EWOULDBLOCK: tv = rffi.make(_c.timeval) rffi.setintfield(tv, 'c_tv_sec', int(timeout)) rffi.setintfield(tv, 'c_tv_usec', int((timeout - int(timeout)) * 1000000)) fds = lltype.malloc(_c.fd_set.TO, flavor='raw') _c.FD_ZERO(fds) _c.FD_SET(self.fd, fds) fds_exc = lltype.malloc(_c.fd_set.TO, flavor='raw') _c.FD_ZERO(fds_exc) _c.FD_SET(self.fd, fds_exc) null = lltype.nullptr(_c.fd_set.TO) try: n = _c.select(self.fd + 1, null, fds, fds_exc, tv) if n > 0: if _c.FD_ISSET(self.fd, fds): # socket writable == connected return (0, False) else: # per MS docs, call getsockopt() to get error assert _c.FD_ISSET(self.fd, fds_exc) return (self.getsockopt_int( _c.SOL_SOCKET, _c.SO_ERROR), False) elif n == 0: return (_c.EWOULDBLOCK, True) else: return (_c.geterrno(), False) finally: lltype.free(fds, flavor='raw') lltype.free(fds_exc, flavor='raw') lltype.free(tv, flavor='raw') if res == 0: errno = 0 return (errno, False)
def decompress(self, data): """decompress(data) -> string Provide more data to the decompressor object. It will return chunks of decompressed data whenever possible. If you try to decompress data after the end of stream is found, EOFError will be raised. If any data was found after the end of stream, it'll be ignored and saved in unused_data attribute.""" if data == '': return self.space.wrap('') if not self.running: raise OperationError(self.space.w_EOFError, self.space.wrap("end of stream was already found")) in_bufsize = len(data) with lltype.scoped_alloc(rffi.CCHARP.TO, in_bufsize) as in_buf: for i in range(in_bufsize): in_buf[i] = data[i] self.bzs.c_next_in = in_buf rffi.setintfield(self.bzs, 'c_avail_in', in_bufsize) with OutBuffer(self.bzs) as out: while True: bzerror = BZ2_bzDecompress(self.bzs) if bzerror == BZ_STREAM_END: if rffi.getintfield(self.bzs, 'c_avail_in') != 0: unused = [self.bzs.c_next_in[i] for i in range( rffi.getintfield(self.bzs, 'c_avail_in'))] self.unused_data = "".join(unused) self.running = False break if bzerror != BZ_OK: _catch_bz2_error(self.space, bzerror) if rffi.getintfield(self.bzs, 'c_avail_in') == 0: break elif rffi.getintfield(self.bzs, 'c_avail_out') == 0: out.prepare_next_chunk() res = out.make_result_string() return self.space.wrap(res)
def compress(space, data, compresslevel=9): """compress(data [, compresslevel=9]) -> string Compress data in one shot. If you want to compress data sequentially, use an instance of BZ2Compressor instead. The compresslevel parameter, if given, must be a number between 1 and 9.""" if compresslevel < 1 or compresslevel > 9: raise OperationError( space.w_ValueError, space.wrap("compresslevel must be between 1 and 9")) with lltype.scoped_alloc(bz_stream.TO, zero=True) as bzs: in_bufsize = len(data) with lltype.scoped_alloc(rffi.CCHARP.TO, in_bufsize) as in_buf: for i in range(in_bufsize): in_buf[i] = data[i] bzs.c_next_in = in_buf rffi.setintfield(bzs, 'c_avail_in', in_bufsize) # conforming to bz2 manual, this is large enough to fit compressed # data in one shot. We will check it later anyway. with OutBuffer(bzs, in_bufsize + (in_bufsize / 100 + 1) + 600) as out: bzerror = BZ2_bzCompressInit(bzs, compresslevel, 0, 0) if bzerror != BZ_OK: _catch_bz2_error(space, bzerror) while True: bzerror = BZ2_bzCompress(bzs, BZ_FINISH) if bzerror == BZ_STREAM_END: break elif bzerror != BZ_FINISH_OK: BZ2_bzCompressEnd(bzs) _catch_bz2_error(space, bzerror) if rffi.getintfield(bzs, 'c_avail_out') == 0: out.prepare_next_chunk() res = out.make_result_string() BZ2_bzCompressEnd(bzs) return space.wrap(res)
def buffer_attach(space, py_obj, w_obj): """ Fills a newly allocated PyBufferObject with the given (str) buffer object. """ py_buf = rffi.cast(PyBufferObject, py_obj) py_buf.c_b_offset = 0 rffi.setintfield(py_buf, 'c_b_readonly', 1) rffi.setintfield(py_buf, 'c_b_hash', -1) if isinstance(w_obj, SubBuffer): py_buf.c_b_offset = w_obj.offset w_obj = w_obj.buffer if isinstance(w_obj, StringBuffer): py_buf.c_b_base = rffi.cast(PyObject, 0) # space.wrap(w_obj.value) py_buf.c_b_ptr = rffi.cast(rffi.VOIDP, rffi.str2charp(w_obj.as_str())) py_buf.c_b_size = w_obj.getlength() else: raise Exception("Fail fail fail fail fail")
def compress(space, data, compresslevel=9): """compress(data [, compresslevel=9]) -> string Compress data in one shot. If you want to compress data sequentially, use an instance of BZ2Compressor instead. The compresslevel parameter, if given, must be a number between 1 and 9.""" if compresslevel < 1 or compresslevel > 9: raise OperationError(space.w_ValueError, space.wrap("compresslevel must be between 1 and 9")) with lltype.scoped_alloc(bz_stream.TO, zero=True) as bzs: in_bufsize = len(data) with lltype.scoped_alloc(rffi.CCHARP.TO, in_bufsize) as in_buf: for i in range(in_bufsize): in_buf[i] = data[i] bzs.c_next_in = in_buf rffi.setintfield(bzs, 'c_avail_in', in_bufsize) # conforming to bz2 manual, this is large enough to fit compressed # data in one shot. We will check it later anyway. with OutBuffer(bzs, in_bufsize + (in_bufsize / 100 + 1) + 600) as out: bzerror = BZ2_bzCompressInit(bzs, compresslevel, 0, 0) if bzerror != BZ_OK: _catch_bz2_error(space, bzerror) while True: bzerror = BZ2_bzCompress(bzs, BZ_FINISH) if bzerror == BZ_STREAM_END: break elif bzerror != BZ_FINISH_OK: BZ2_bzCompressEnd(bzs) _catch_bz2_error(space, bzerror) if rffi.getintfield(bzs, 'c_avail_out') == 0: out.prepare_next_chunk() res = out.make_result_string() BZ2_bzCompressEnd(bzs) return space.wrap(res)
def GetVersionEx(): info = lltype.malloc(OSVERSIONINFOEX, flavor='raw') rffi.setintfield(info, 'c_dwOSVersionInfoSize', rffi.sizeof(OSVERSIONINFOEX)) try: if not _GetVersionEx(info): raise lastWindowsError() return (rffi.cast(lltype.Signed, info.c_dwMajorVersion), rffi.cast(lltype.Signed, info.c_dwMinorVersion), rffi.cast(lltype.Signed, info.c_dwBuildNumber), rffi.cast(lltype.Signed, info.c_dwPlatformId), rffi.charp2str(rffi.cast(rffi.CCHARP, info.c_szCSDVersion)), rffi.cast(lltype.Signed, info.c_wServicePackMajor), rffi.cast(lltype.Signed, info.c_wServicePackMinor), rffi.cast(lltype.Signed, info.c_wSuiteMask), rffi.cast(lltype.Signed, info.c_wProductType)) finally: lltype.free(info, flavor='raw')
def descr__init__(self, space, w_ident, filter=KQ_FILTER_READ, flags=KQ_EV_ADD, fflags=0, data=0, udata=r_uint(0)): if space.isinstance_w(w_ident, space.w_long): ident = space.uint_w(w_ident) else: ident = r_uint(space.c_filedescriptor_w(w_ident)) self.event = lltype.malloc(kevent, flavor="raw") rffi.setintfield(self.event, "c_ident", ident) rffi.setintfield(self.event, "c_filter", filter) rffi.setintfield(self.event, "c_flags", flags) rffi.setintfield(self.event, "c_fflags", fflags) rffi.setintfield(self.event, "c_data", data) self.event.c_udata = rffi.cast(rffi.VOIDP, udata)