def descr_init(self, space, w_source=None, encoding=None, errors=None): if w_source is None: w_source = space.newbytes('') if encoding is not None: from pypy.objspace.std.unicodeobject import encode_object # if w_source is an integer this correctly raises a # TypeError the CPython error message is: "encoding or # errors without a string argument" ours is: "expected # unicode, got int object" w_source = encode_object(space, w_source, encoding, errors) # Is it an integer? # Note that we're calling space.getindex_w() instead of space.int_w(). try: count = space.getindex_w(w_source, space.w_OverflowError) except OperationError as e: if not e.match(space, space.w_TypeError): raise else: if count < 0: raise oefmt(space.w_ValueError, "bytearray negative count") self._data = resizable_list_supporting_raw_ptr(['\0'] * count) self._offset = 0 return data = makebytearraydata_w(space, w_source) self._data = resizable_list_supporting_raw_ptr(data) self._offset = 0 _tweak_for_tests(self)
def descr_init(self, space, w_source=None, encoding=None, errors=None): if w_source is None: w_source = space.wrap('') if encoding is not None: from pypy.objspace.std.unicodeobject import encode_object # if w_source is an integer this correctly raises a # TypeError the CPython error message is: "encoding or # errors without a string argument" ours is: "expected # unicode, got int object" w_source = encode_object(space, w_source, encoding, errors) # Is it an int? try: count = space.int_w(w_source) except OperationError as e: if not e.match(space, space.w_TypeError): raise else: if count < 0: raise oefmt(space.w_ValueError, "bytearray negative count") self.data = resizable_list_supporting_raw_ptr(['\0'] * count) return data = makebytearraydata_w(space, w_source) self.data = resizable_list_supporting_raw_ptr(data)
def __init__(self, data): check_list_of_chars(data) self._data = resizable_list_supporting_raw_ptr(data) self._offset = 0 # NOTE: the bytearray data is in 'self._data[self._offset:]' check_nonneg(self._offset) _tweak_for_tests(self)
def f(n): lst = ['a', 'b', 'c'] lst = rgc.resizable_list_supporting_raw_ptr(lst) lst.append(chr(n)) assert lst[3] == chr(n) assert lst[-1] == chr(n) # ptr = rgc.nonmoving_raw_ptr_for_resizable_list(lst) assert lst[:] == ['a', 'b', 'c', chr(n)] assert lltype.typeOf(ptr) == rffi.CCHARP assert [ptr[i] for i in range(4)] == ['a', 'b', 'c', chr(n)] # lst[-3] = 'X' assert ptr[1] == 'X' ptr[2] = 'Y' assert lst[-2] == 'Y' # addr = rffi.cast(lltype.Signed, ptr) ptr = rffi.cast(rffi.CCHARP, addr) rgc.collect() # should not move lst.items lst[-4] = 'g' assert ptr[0] == 'g' ptr[3] = 'H' assert lst[-1] == 'H' return lst
def newlist_and_gc_store(TYPE, value): size = rffi.sizeof(TYPE) lst = resizable_list_supporting_raw_ptr(['\x00'] * size) ll_data = ll_for_resizable_list(lst) ll_items = ll_data.items LIST = lltype.typeOf(ll_data).TO # rlist.LIST_OF(lltype.Char) base_ofs = llmemory.itemoffsetof(LIST.items.TO, 0) scale_factor = llmemory.sizeof(lltype.Char) value = lltype.cast_primitive(TYPE, value) llop.gc_store_indexed(lltype.Void, ll_items, 0, value, scale_factor, base_ofs) return lst
def f(n): lst = ['a', 'b', 'c', 'd', 'e'] lst = rgc.resizable_list_supporting_raw_ptr(lst) lst = lst[:3] lst.append(chr(n)) assert lst[3] == chr(n) assert lst[-1] == chr(n) # ptr = rgc.nonmoving_raw_ptr_for_resizable_list(lst) assert lst[:] == ['a', 'b', 'c', chr(n)] assert lltype.typeOf(ptr) == rffi.CCHARP assert [ptr[i] for i in range(4)] == ['a', 'b', 'c', chr(n)] return lst
def _init(self, space): if self.buffer_size <= 0: raise oefmt(space.w_ValueError, "buffer size must be strictly positive") self.buffer = resizable_list_supporting_raw_ptr(['\0'] * self.buffer_size) self.lock = TryLock(space) try: self._raw_tell(space) except OperationError: pass
def f(n): lst = ['a', 'b', 'c'] lst = rgc.resizable_list_supporting_raw_ptr(lst) lst.append(chr(n)) assert lst[3] == chr(n) assert lst[-1] == chr(n) # ll_list = rgc.ll_for_resizable_list(lst) assert lst[:] == ['a', 'b', 'c', chr(n)] assert ll_list.length == 4 assert [ll_list.items[i] for i in range(4)] == ['a', 'b', 'c', chr(n)] # lst[-3] = 'X' assert ll_list.items[1] == 'X' ll_list.items[2] = 'Y' assert lst[-2] == 'Y' # return lst
def descr_init(self, space, w_source=None, encoding=None, errors=None): assert isinstance(self, W_BytearrayObject) data = [c for c in newbytesdata_w(space, w_source, encoding, errors)] self._data = resizable_list_supporting_raw_ptr(data) self._offset = 0 _tweak_for_tests(self)
def test_ListSupportingRawPtr_direct(): lst = ['a', 'b', 'c'] lst = rgc.resizable_list_supporting_raw_ptr(lst) def check_nonresizing(): assert lst[1] == lst[-2] == 'b' lst[1] = 'X' assert lst[1] == 'X' lst[-1] = 'Y' assert lst[1:3] == ['X', 'Y'] assert lst[-2:9] == ['X', 'Y'] lst[1:2] = 'B' assert lst[:] == ['a', 'B', 'Y'] assert list(iter(lst)) == ['a', 'B', 'Y'] assert list(reversed(lst)) == ['Y', 'B', 'a'] assert 'B' in lst assert 'b' not in lst assert p[0] == 'a' assert p[1] == 'B' assert p[2] == 'Y' assert lst + ['*'] == ['a', 'B', 'Y', '*'] assert ['*'] + lst == ['*', 'a', 'B', 'Y'] assert lst + lst == ['a', 'B', 'Y', 'a', 'B', 'Y'] base = ['8'] base += lst assert base == ['8', 'a', 'B', 'Y'] assert lst == ['a', 'B', 'Y'] assert ['a', 'B', 'Y'] == lst assert ['a', 'B', 'Z'] != lst assert ['a', 'B', 'Z'] > lst assert ['a', 'B', 'Z'] >= lst assert lst * 2 == ['a', 'B', 'Y', 'a', 'B', 'Y'] assert 2 * lst == ['a', 'B', 'Y', 'a', 'B', 'Y'] assert lst.count('B') == 1 assert lst.index('Y') == 2 lst.reverse() assert lst == ['Y', 'B', 'a'] lst.sort() assert lst == ['B', 'Y', 'a'] lst.sort(reverse=True) assert lst == ['a', 'Y', 'B'] lst[1] = 'b' lst[2] = 'c' assert list(lst) == ['a', 'b', 'c'] p = lst check_nonresizing() assert lst._raw_items is None lst._nonmoving_raw_ptr_for_resizable_list() p = lst._raw_items check_nonresizing() assert lst._raw_items == p assert p[0] == 'a' assert p[1] == 'b' assert p[2] == 'c' def do_resizing_operation(): del lst[1] yield ['a', 'c'] lst[:2] = ['X'] yield ['X', 'c'] del lst[:2] yield ['c'] x = lst x += ['t'] yield ['a', 'b', 'c', 't'] x = lst x *= 3 yield ['a', 'b', 'c'] * 3 lst.append('f') yield ['a', 'b', 'c', 'f'] lst.extend('fg') yield ['a', 'b', 'c', 'f', 'g'] lst.insert(1, 'k') yield ['a', 'k', 'b', 'c'] n = lst.pop(1) assert n == 'b' yield ['a', 'c'] lst.remove('c') yield ['a', 'b'] assert lst == ['a', 'b', 'c'] for expect in do_resizing_operation(): assert lst == expect assert lst._raw_items is None lst = ['a', 'b', 'c'] lst = rgc.resizable_list_supporting_raw_ptr(lst) lst._nonmoving_raw_ptr_for_resizable_list()
def __init__(self, n): self.data = resizable_list_supporting_raw_ptr(['\0'] * n) self.readonly = False
def _read_generic(self, space, n): """Generic read function: read from the stream until enough bytes are read, or until an EOF occurs or until read() would block.""" # Must run with the lock held! current_size = self._readahead() if n <= current_size: return self._read_fast(n) result_buffer = resizable_list_supporting_raw_ptr(['\0'] * n) remaining = n written = 0 if current_size: for i in range(current_size): result_buffer[written + i] = self.buffer[self.pos + i] remaining -= current_size written += current_size self.pos += current_size # Flush the write buffer if necessary if self.writable: self._flush_and_rewind_unlocked(space) self._reader_reset_buf() # Read whole blocks, and don't buffer them while remaining > 0: r = self.buffer_size * (remaining // self.buffer_size) if r == 0: break try: size = self._raw_read(space, result_buffer, written, r) except BlockingIOError: if written == 0: return None size = 0 if size == 0: return ''.join(result_buffer[:written]) remaining -= size written += size self.pos = 0 self.raw_pos = 0 self.read_end = 0 while remaining > 0 and self.read_end < self.buffer_size: try: size = self._fill_buffer(space) except BlockingIOError: # EOF or read() would block if written == 0: return None size = 0 if size == 0: break if remaining > 0: if size > remaining: size = remaining for i in range(size): result_buffer[written + i] = self.buffer[self.pos + i] self.pos += size written += size remaining -= size return ''.join(result_buffer[:written])
def __init__(self, data): check_list_of_chars(data) self.data = resizable_list_supporting_raw_ptr(data)
def __init__(self, data): check_list_of_chars(data) self.data = resizable_list_supporting_raw_ptr(data)