Lines Matching refs:self
35 check_closed(bytesio *self)
37 if (self->buf == NULL) {
45 check_exports(bytesio *self)
47 if (self->exports > 0) {
55 #define CHECK_CLOSED(self) \
56 if (check_closed(self)) { \
60 #define CHECK_EXPORTS(self) \
61 if (check_exports(self)) { \
65 #define SHARED_BUF(self) (Py_REFCNT((self)->buf) > 1)
72 scan_eol(bytesio *self, Py_ssize_t len)
77 assert(self->buf != NULL);
78 assert(self->pos >= 0);
80 if (self->pos >= self->string_size)
84 maxlen = self->string_size - self->pos;
89 start = PyBytes_AS_STRING(self->buf) + self->pos;
97 assert(self->pos < PY_SSIZE_T_MAX - len);
104 not lesser than self->string_size. Returns 0 on success, -1 otherwise. */
106 unshare_buffer(bytesio *self, size_t size)
109 assert(SHARED_BUF(self));
110 assert(self->exports == 0);
111 assert(size >= (size_t)self->string_size);
115 memcpy(PyBytes_AS_STRING(new_buf), PyBytes_AS_STRING(self->buf),
116 self->string_size);
117 Py_SETREF(self->buf, new_buf);
125 resize_buffer(bytesio *self, size_t size)
129 size_t alloc = PyBytes_GET_SIZE(self->buf);
131 assert(self->buf != NULL);
158 if (SHARED_BUF(self)) {
159 if (unshare_buffer(self, alloc) < 0)
163 if (_PyBytes_Resize(&self->buf, alloc) < 0)
180 write_bytes(bytesio *self, PyObject *b)
182 if (check_closed(self)) {
185 if (check_exports(self)) {
198 assert(self->pos >= 0);
199 size_t endpos = (size_t)self->pos + len;
200 if (endpos > (size_t)PyBytes_GET_SIZE(self->buf)) {
201 if (resize_buffer(self, endpos) < 0) {
206 else if (SHARED_BUF(self)) {
207 if (unshare_buffer(self, Py_MAX(endpos, (size_t)self->string_size)) < 0) {
213 if (self->pos > self->string_size) {
222 memset(PyBytes_AS_STRING(self->buf) + self->string_size, '\0',
223 (self->pos - self->string_size) * sizeof(char));
227 data if self->pos < self->string_size. */
228 memcpy(PyBytes_AS_STRING(self->buf) + self->pos, buf.buf, len);
229 self->pos = endpos;
232 if ((size_t)self->string_size < endpos) {
233 self->string_size = endpos;
242 bytesio_get_closed(bytesio *self, void *Py_UNUSED(ignored))
244 if (self->buf == NULL) {
259 _io_BytesIO_readable_impl(bytesio *self)
262 CHECK_CLOSED(self);
273 _io_BytesIO_writable_impl(bytesio *self)
276 CHECK_CLOSED(self);
287 _io_BytesIO_seekable_impl(bytesio *self)
290 CHECK_CLOSED(self);
301 _io_BytesIO_flush_impl(bytesio *self)
304 CHECK_CLOSED(self);
315 _io_BytesIO_getbuffer_impl(bytesio *self)
322 CHECK_CLOSED(self);
327 Py_INCREF(self);
328 buf->source = self;
341 _io_BytesIO_getvalue_impl(bytesio *self)
344 CHECK_CLOSED(self);
345 if (self->string_size <= 1 || self->exports > 0)
346 return PyBytes_FromStringAndSize(PyBytes_AS_STRING(self->buf),
347 self->string_size);
349 if (self->string_size != PyBytes_GET_SIZE(self->buf)) {
350 if (SHARED_BUF(self)) {
351 if (unshare_buffer(self, self->string_size) < 0)
355 if (_PyBytes_Resize(&self->buf, self->string_size) < 0)
359 Py_INCREF(self->buf);
360 return self->buf;
372 _io_BytesIO_isatty_impl(bytesio *self)
375 CHECK_CLOSED(self);
386 _io_BytesIO_tell_impl(bytesio *self)
389 CHECK_CLOSED(self);
390 return PyLong_FromSsize_t(self->pos);
394 read_bytes(bytesio *self, Py_ssize_t size)
398 assert(self->buf != NULL);
399 assert(size <= self->string_size);
401 self->pos == 0 && size == PyBytes_GET_SIZE(self->buf) &&
402 self->exports == 0) {
403 self->pos += size;
404 Py_INCREF(self->buf);
405 return self->buf;
408 output = PyBytes_AS_STRING(self->buf) + self->pos;
409 self->pos += size;
425 _io_BytesIO_read_impl(bytesio *self, Py_ssize_t size)
430 CHECK_CLOSED(self);
433 n = self->string_size - self->pos;
440 return read_bytes(self, size);
456 _io_BytesIO_read1_impl(bytesio *self, Py_ssize_t size)
459 return _io_BytesIO_read_impl(self, size);
475 _io_BytesIO_readline_impl(bytesio *self, Py_ssize_t size)
480 CHECK_CLOSED(self);
482 n = scan_eol(self, size);
484 return read_bytes(self, n);
500 _io_BytesIO_readlines_impl(bytesio *self, PyObject *arg)
507 CHECK_CLOSED(self);
529 output = PyBytes_AS_STRING(self->buf) + self->pos;
530 while ((n = scan_eol(self, -1)) != 0) {
531 self->pos += n;
564 _io_BytesIO_readinto_impl(bytesio *self, Py_buffer *buffer)
569 CHECK_CLOSED(self);
573 n = self->string_size - self->pos;
580 memcpy(buffer->buf, PyBytes_AS_STRING(self->buf) + self->pos, len);
581 assert(self->pos + len < PY_SSIZE_T_MAX);
583 self->pos += len;
590 size: Py_ssize_t(accept={int, NoneType}, c_default="self->pos") = None
600 _io_BytesIO_truncate_impl(bytesio *self, Py_ssize_t size)
603 CHECK_CLOSED(self);
604 CHECK_EXPORTS(self);
612 if (size < self->string_size) {
613 self->string_size = size;
614 if (resize_buffer(self, size) < 0)
622 bytesio_iternext(bytesio *self)
626 CHECK_CLOSED(self);
628 n = scan_eol(self, -1);
633 return read_bytes(self, n);
652 _io_BytesIO_seek_impl(bytesio *self, Py_ssize_t pos, int whence)
655 CHECK_CLOSED(self);
667 if (pos > PY_SSIZE_T_MAX - self->pos) {
672 pos += self->pos;
675 if (pos > PY_SSIZE_T_MAX - self->string_size) {
680 pos += self->string_size;
690 self->pos = pos;
692 return PyLong_FromSsize_t(self->pos);
706 _io_BytesIO_write(bytesio *self, PyObject *b)
709 Py_ssize_t n = write_bytes(self, b);
726 _io_BytesIO_writelines(bytesio *self, PyObject *lines)
731 CHECK_CLOSED(self);
738 Py_ssize_t ret = write_bytes(self, item);
761 _io_BytesIO_close_impl(bytesio *self)
764 CHECK_EXPORTS(self);
765 Py_CLEAR(self->buf);
785 bytesio_getstate(bytesio *self, PyObject *Py_UNUSED(ignored))
787 PyObject *initvalue = _io_BytesIO_getvalue_impl(self);
793 if (self->dict == NULL) {
798 dict = PyDict_Copy(self->dict);
805 state = Py_BuildValue("(OnN)", initvalue, self->pos, dict);
811 bytesio_setstate(bytesio *self, PyObject *state)
826 Py_TYPE(self)->tp_name, Py_TYPE(state)->tp_name);
829 CHECK_EXPORTS(self);
832 self->string_size = 0;
833 self->pos = 0;
837 result = _io_BytesIO_write(self, PyTuple_GET_ITEM(state, 0));
843 method instead of modifying self->pos directly to better protect the
860 self->pos = pos;
871 if (self->dict) {
874 if (PyDict_Update(self->dict, dict) < 0)
879 self->dict = dict;
887 bytesio_dealloc(bytesio *self)
889 _PyObject_GC_UNTRACK(self);
890 if (self->exports > 0) {
895 Py_CLEAR(self->buf);
896 Py_CLEAR(self->dict);
897 if (self->weakreflist != NULL)
898 PyObject_ClearWeakRefs((PyObject *) self);
899 Py_TYPE(self)->tp_free(self);
905 bytesio *self;
908 self = (bytesio *)type->tp_alloc(type, 0);
909 if (self == NULL)
915 self->buf = PyBytes_FromStringAndSize(NULL, 0);
916 if (self->buf == NULL) {
917 Py_DECREF(self);
921 return (PyObject *)self;
932 _io_BytesIO___init___impl(bytesio *self, PyObject *initvalue)
936 self->string_size = 0;
937 self->pos = 0;
939 if (self->exports > 0) {
947 Py_XSETREF(self->buf, initvalue);
948 self->string_size = PyBytes_GET_SIZE(initvalue);
952 res = _io_BytesIO_write(self, initvalue);
956 self->pos = 0;
964 bytesio_sizeof(bytesio *self, void *unused)
968 res = _PyObject_SIZE(Py_TYPE(self));
969 if (self->buf && !SHARED_BUF(self)) {
970 Py_ssize_t s = _PySys_GetSizeOf(self->buf);
980 bytesio_traverse(bytesio *self, visitproc visit, void *arg)
982 Py_VISIT(self->dict);
987 bytesio_clear(bytesio *self)
989 Py_CLEAR(self->dict);
1107 bytesiobuf_traverse(bytesiobuf *self, visitproc visit, void *arg)
1109 Py_VISIT(self->source);
1114 bytesiobuf_dealloc(bytesiobuf *self)
1117 PyObject_GC_UnTrack(self);
1118 Py_CLEAR(self->source);
1119 Py_TYPE(self)->tp_free(self);